osg::Brick Class Reference

#include <OSGBrick.h>

List of all members.

Public Member Functions
Brick *	getNext (void)
	Returns next brick in sorted order.
void	init (Int32 minVoxX, Int32 minVoxY, Int32 minVoxZ, Int32 resX, Int32 resY, Int32 resZ, Real32 xMin, Real32 yMin, Real32 zMin, Real32 xMax, Real32 yMax, Real32 zMax, Int32 overlap=1, BrickSet::Orientation ori=BrickSet::UNDEF)
	Initialize brick size and geometry.
void	activateTexture (DrawActionBase *action)
	Activate textures.
void	changeFromTexture (DrawActionBase *action, Brick *old)
	Change active texture.
void	deactivateTexture (DrawActionBase *action)
	Deactivate textures.
void	renderSlices (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, TextureManager::TextureMode mode)
	Render slices.
void	renderBrick (void)
	Render brick boundaries.
void	vertToTex (Real32 *vx, Real32 *vy, Real32 *vz, Real32 *tx, Real32 *ty, Real32 *tz)
	Transform vertex to texture coordinates.
void	vertToTex (Vec3f &vert, Vec3f &tex)
	Transform vertex to texture coordinates.
Private Member Functions
void	render3DSlices (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, const Vec3f &sliceDir)
	Render slices.
void	render2DSlices (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, const Vec3f &sliceDir)
void	render2DMultiSlices (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, bool btf, const Vec3f &sliceDir)
	Render Slices 2D with Multi-textures.
void	render2DSliceXY (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, const Vec3f &sliceDir, const Real32 &zCoord)
void	render2DSliceXZ (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, const Vec3f &sliceDir, const Real32 &yCoord)
void	render2DSliceYZ (DVRVolume *volume, DrawActionBase *action, DVRShaderPtr shader, DVRClipper *clipper, const Vec3f &sliceDir, const Real32 &xCoord)
Private Attributes
Vec3f	vertex [8]
Line	edges [12]
TextureChunkPtr *	texture
UInt32 *	texStage
Int32	numTextures
Vec3f	center
Real32	radius
Vec3f	texTranslate
Vec3f	texScale
Int32	voxSize [3]
Int32	minVox [3]
Vec3f	m_lowerLeft
Vec3f	m_upperRight
BrickSet::Orientation	m_ori
Real32	distance
Brick *	prev
Brick *	next
DVRSlice	slice
DVRRenderSlice	clippedSlice
Friends
class	BrickSet

---

Detailed Description

Definition at line 88 of file OSGBrick.h.

---

Member Function Documentation

Brick * osg::Brick::getNext

(

void

)

[inline]

Definition at line 13 of file OSGBrick.inl.

References next.

Referenced by osg::DVRVolume::draw().

{
    return next;
}

void osg::Brick::init	(	Int32	minVoxX,
		Int32	minVoxY,
		Int32	minVoxZ,
		Int32	resX,
		Int32	resY,
		Int32	resZ,
		Real32	xMin,
		Real32	yMin,
		Real32	zMin,
		Real32	xMax,
		Real32	yMax,
		Real32	zMax,
		Int32	overlap = 1,
		BrickSet::Orientation	ori = BrickSet::UNDEF
	)

! Initialize edge/vertex structure

Definition at line 601 of file OSGBrick.cpp.

References center, edges, FINFO, m_lowerLeft, m_ori, m_upperRight, minVox, radius, texScale, texTranslate, vertex, and voxSize.

Referenced by osg::BrickSet::buildBricks2D(), and osg::BrickSet::buildBricks3D().

{
    
    FINFO(("Brick::init - upper left (%d, %d, %d)\n",
           minVoxX, minVoxY, minVoxZ));

    FINFO(("Brick::init (%d, %d, %d): %f %f %f -> %f %f %f \n",
           resX, resY, resZ, xmin, ymin, zmin, xmax, ymax, zmax));

    Real32 xrange = xmax - xmin;
    Real32 yrange = ymax - ymin;
    Real32 zrange = zmax - zmin;               
    
    minVox[0] = minVoxX;
    minVox[1] = minVoxY;
    minVox[2] = minVoxZ;
    
    voxSize[0] = resX;
    voxSize[1] = resY;
    voxSize[2] = resZ;
    
    m_lowerLeft  = Vec3f(xmin, ymin, zmin);
    m_upperRight = Vec3f(xmax, ymax, zmax);
    
    m_ori = ori;
    
    Real32 texCoorMin[3], texCoorMax[3];
    
    texCoorMin[0] = (2 * Real32(overlap) - 1) / 2.0f / Real32(resX);
    texCoorMin[1] = (2 * Real32(overlap) - 1) / 2.0f / Real32(resY);
    texCoorMin[2] = (2 * Real32(overlap) - 1) / 2.0f / Real32(resZ);
    
    texCoorMax[0] = 1 - texCoorMin[0];
    texCoorMax[1] = 1 - texCoorMin[1];
    texCoorMax[2] = 1 - texCoorMin[2];
    
    texScale = Vec3f((texCoorMax[0] - texCoorMin[0]) / xrange,
                     (texCoorMax[1] - texCoorMin[1]) / yrange,
                     (texCoorMax[2] - texCoorMin[2]) / zrange);

    texTranslate = Vec3f(texCoorMin[0] - texScale[0] * xmin,
                         texCoorMin[1] - texScale[1] * ymin,
                         texCoorMin[2] - texScale[2] * zmin);
    
    FINFO (("Brick::init - overlap:      %d \n", 
            overlap));

    FINFO (("Brick::init - texScale:     %f %f %f \n", 
            texScale[0], texScale[1], texScale[2]));

    FINFO (("Brick::init - texTranslate: %f %f %f \n", 
            texTranslate[0], texTranslate[1], texTranslate[2]));
    
    
    //
    //                         e3       
    //          v5 o----------------o v4
    //            /|               /|
    //           / |              / |
    //      e10 /  |          e9 /  |e7
    //         /   |   e1       /   |
    //     v3 o----------------o v2 |
    //        |    |           |    |
    //        |    |e6         |    |
    //        |e5  |           |e4  |
    //        |    |    e2     |    |
    //        |    o-----------|----o v7
    //        |   /  v6        |   /
    //        |  /             |  /
    //        | /e11           | /e8
    //        |/               |/
    //   y    o----------------o
    //   | z  v0      e0       v1
    //   |/
    //   +---x
                
    // ------------- Initialize 8 Vertices -------------

    vertex[0] = Vec3f( xmin,  ymin,  zmin); 
    vertex[1] = Vec3f( xmax,  ymin,  zmin);
    vertex[2] = Vec3f( xmax,  ymax,  zmin);
    vertex[3] = Vec3f( xmin,  ymax,  zmin);
    
    vertex[4] = Vec3f( xmax,  ymax,  zmax);
    vertex[5] = Vec3f( xmin,  ymax,  zmax); 
    vertex[6] = Vec3f( xmin,  ymin,  zmax);
    vertex[7] = Vec3f( xmax,  ymin,  zmax);
    
    center = Vec3f(0.0, 0.0, 0.0);

    for(Int32 j = 0; j < 8; j++) 
    {
        center += vertex[j];
    }

    center /= 8.0;
    radius  = (vertex[0] - center).length();
    
    // -------------- Initialize 12 Edges --------------

    const int eindex[12][2] = 
    {
        {0, 1}, // e0
        {2, 3}, // e1
        {6, 7}, // e2
        {4, 5}, // e3
        {1, 2}, // e4
        {0, 3}, // e5
        {5, 6}, // e6
        {4, 7}, // e7
        {1, 7}, // e8
        {2, 4}, // e9
        {3, 5}, // e10
        {0, 6}  // e11
    };
    
    for(Int32 i = 0; i < 12; i++) 
    {
        edges[i] = Line(Pnt3f(vertex[eindex[i][0]]),
                        Pnt3f(vertex[eindex[i][1]]));
    }
    
#if 0
    TOUT("Init Brick");
    TOUT("Brick (" << x << ", " << y << ", " << z << ")");
    TOUT(VARDUMP(nXMin) << ", " << VARDUMP(nXMax));
    TOUT(VARDUMP(nYMin) << ", " << VARDUMP(nYMax));
    TOUT(VARDUMP(nZMin) << ", " << VARDUMP(nZMax));
    TOUT(VARDUMP(nDataSize));
#endif
}

void osg::Brick::activateTexture

(

DrawActionBase *

action

)

Definition at line 741 of file OSGBrick.cpp.

References FDEBUG, numTextures, texStage, and texture.

Referenced by changeFromTexture(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), and render3DSlices().

{
    for(Int32 i = 0; i < numTextures; i++) 
    {
        FDEBUG(("Brick::activateTexture - Brick: %d - Texture %d "
                "- Stage: %d - ID: %d\n",
                this, i, texStage[i], texture[i]->getGLId()));

        texture[i]->activate(action, texStage[i]);
    }
}

void osg::Brick::changeFromTexture	(	DrawActionBase *	action,
		Brick *	old
	)

Definition at line 755 of file OSGBrick.cpp.

References activateTexture(), FDEBUG, numTextures, texStage, and texture.

{
    FDEBUG(("Brick::changeFromTexture\n"));
    
    if(old == NULL)
        activateTexture(action);
    
    for(Int32 i = 0; i < numTextures; i++)
    {
        texture[i]->changeFrom(action, &(*(old->texture[i])), texStage[i]);
    }
}

void osg::Brick::deactivateTexture

(

DrawActionBase *

action

)

Definition at line 770 of file OSGBrick.cpp.

References numTextures, texStage, and texture.

Referenced by osg::DVRVolume::draw(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), and render3DSlices().

{
    for(Int32 i = 0; i < numTextures; i++) 
    {
        texture[i]->deactivate(action, texStage[i]);
    }
    
}

void osg::Brick::renderSlices	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		TextureManager::TextureMode	mode
	)

Render 2D/3D Slices.

Definition at line 781 of file OSGBrick.cpp.

References FDEBUG, osg::Slicer::getAASlicingDirection(), osg::Slicer::getSlicingDirection(), GL_TEXTURE_3D, GLboolean, osg::Slicer::isBackToFront(), render2DMultiSlices(), render2DSlices(), render3DSlices(), SWARNING, osg::TextureManager::TM_2D, osg::TextureManager::TM_2D_Multi, and osg::TextureManager::TM_3D.

{  
    switch (textureMode)
    {
        case TextureManager::TM_2D:
        {
            GLboolean val;
            glGetBooleanv(GL_TEXTURE_3D, &val);

            if(val != 0) 
            {
                glDisable(GL_TEXTURE_3D);
                SWARNING << "Brick::renderSlices - 3DTextures enabled "
                         << "-> DISABLING " 
                         << (int) val 
                         << std::endl;
            }

            Vec3f sliceDir;

            Slicer::getAASlicingDirection(action, &sliceDir);

            render2DSlices(volume, action, shader, clipper, sliceDir);

            break;
        }
        case TextureManager::TM_2D_Multi:
        {
            FDEBUG(("Brick::renderSlices - 2D MTex Slabs\n"));

            Vec3f sliceDir;

            Int32 dir = Slicer::getAASlicingDirection(action, &sliceDir);

            render2DMultiSlices(volume, action, shader, clipper,
                                Slicer::isBackToFront(dir),sliceDir);
            break;
        }

        default:
        case TextureManager::TM_3D:
        {
            FDEBUG(("Brick::renderSlices -3D slices\n"));

            Vec3f sliceDir;

            Slicer::getSlicingDirection(action, &sliceDir);

            render3DSlices(volume, action, shader, clipper, sliceDir);

            break;
        }
    }
}

void osg::Brick::renderBrick

(

void

)

Render brick bounding box.

Definition at line 842 of file OSGBrick.cpp.

References FDEBUG, GL_TEXTURE_3D, and vertex.

Referenced by osg::DVRVolume::draw().

{
    FDEBUG(("Brick::renderBrick"));
    
    const int eindex[12][2] = 
    {
        {0,1}, 
        {2,3}, 
        {6,7}, 
        {4,5}, 
        {1,2}, 
        {0,3}, 
        {5,6}, 
        {4,7}, 
        {1,7}, 
        {2,4}, 
        {3,5}, 
        {0,6}
    };
    
    glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
    glDisable   (GL_TEXTURE_3D);
    glDisable   (GL_TEXTURE_2D);

    glColor4f   (1.0, 0.0, 0.0, 1.0 );
    
    glBegin(GL_LINES);
    {
        for(Int32 i = 0; i < 12; i++) 
        {
            glVertex3fv(vertex[eindex[i][0]].getValues());
            glVertex3fv(vertex[eindex[i][1]].getValues());
        }
    }
    glEnd();
    
    glPopAttrib();
}

void osg::Brick::vertToTex	(	Real32 *	vx,
		Real32 *	vy,
		Real32 *	vz,
		Real32 *	tx,
		Real32 *	ty,
		Real32 *	tz
	)

Definition at line 883 of file OSGBrick.cpp.

References texScale, and texTranslate.

{
    *tx = *vx * texScale[0] + texTranslate[0];
    *ty = *vy * texScale[1] + texTranslate[1]; 
    *tz = *vz * texScale[2] + texTranslate[2];
}

void osg::Brick::vertToTex	(	Vec3f &	vert,
		Vec3f &	tex
	)

Definition at line 893 of file OSGBrick.cpp.

References texScale, and texTranslate.

{
    tex[0] = vert[0] * texScale[0] + texTranslate[0];
    tex[1] = vert[1] * texScale[1] + texTranslate[1];
    tex[2] = vert[2] * texScale[2] + texTranslate[2];
};

void osg::Brick::render3DSlices	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		const Vec3f &	sliceDir
	)			[private]

Render 3D Slices.

Definition at line 902 of file OSGBrick.cpp.

References activateTexture(), center, osg::DVRRenderSlice::clear(), clippedSlice, osg::DVRClipper::clipSlice(), deactivateTexture(), osg::DVRRenderSlice::directRender, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), DVRVOLUME_PARAMETER, edges, FACE_BACK, FACE_BOTTOM, FACE_FRONT, FACE_LEFT, FACE_RIGHT, FACE_TOP, FDEBUG, osg::DVRVolumeBase::getBaseAlpha(), osg::DVRVolumeBase::getDoTextures(), osg::DVRVolumeBase::getSampling(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::getValues(), osg::Plane::intersect(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), osg::NullFC, osg::DVRRenderSlice::numPerVertexData, osg::DVRClipObjects::Off, osg::Plane::offset(), osg::DVRRenderSlice::orientation, osg::osgpow(), radius, osg::DVRClipper::reset(), osg::DVRSlice::resetSlice(), osg::DVRSlice::setNormal(), osg::DVRSlice::setTextureTransform(), osg::DVRSlice::setVertex(), SINFO, slice, texScale, texTranslate, and osg::DVRRenderSlice::UNDEFINED.

Referenced by renderSlices().

{
    Int32 i, j;

    DVRVolumeTexturePtr tex = DVRVOLUME_PARAMETER(volume, DVRVolumeTexture);

    if(tex == NullFC) 
        return;
    
    Vec3f res            = tex->getResolution();
    Vec3f vox            = tex->getSliceThickness();

    Real32 fSampleRate    = volume->getSampling();
    Real32 fSliceDistance = vox.length() / 2.0f / fSampleRate;
    Real32 fTolerance     = fSliceDistance / 100.0f;
    Real32 fAlphaCorrect  = 1.f - osgpow(1.f  - volume->getBaseAlpha(), 
                                         1.0f / fSampleRate           );
    
    SINFO << "Sampling rate: "
          << fSampleRate 
          << " Alpha-Correction " 
          << fAlphaCorrect
          << std::endl;
    
    Vec3f diag(res[0]*vox[0], res[1]*vox[1], res[2]*vox[2]);

    Real32 fRadius = 0.5f * diag.length();
    
    const int ecodes[12] = 
    {
        (FACE_FRONT  + FACE_BOTTOM), // edge 0
        (FACE_FRONT  + FACE_TOP   ), // edge 1
        (FACE_BACK   + FACE_BOTTOM), // edge 2
        (FACE_BACK   + FACE_TOP   ), // edge 3

        (FACE_FRONT  + FACE_RIGHT ), // edge 4
        (FACE_FRONT  + FACE_LEFT  ), // edge 5
        (FACE_BACK   + FACE_LEFT  ), // edge 6
        (FACE_BACK   + FACE_RIGHT ), // edge 7

        (FACE_RIGHT  + FACE_BOTTOM), // edge 8
        (FACE_RIGHT  + FACE_TOP   ), // edge 9
        (FACE_TOP    + FACE_LEFT  ), // edge 10
        (FACE_BOTTOM + FACE_LEFT  )  // edge 11
    };
    
    // get the slicing normal
    Vec3f vecViewDir = sliceDir;

    Plane planeSlice(vecViewDir, -fRadius);

    Int32 numSlices = 1 + (Int32) (2.0f * fRadius/ fSliceDistance); 
    
    Vec3f   vecIntersections[12];
    Int32   nEdgeCodes[12];

    bool    bIntersectionUsed[12];

    Vec3f   vecIntersectionsSorted[12];
    Vec3f   vecIntersection;

    Int32   nSlice, numIntersections, nEdgeCode, numUsedIntersections;

    Vec3f   v, texscale, textrans; 

    texscale = texScale;
    textrans = texTranslate;

    // set the reference plane for clipping
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);

    bool doClipping = false;

    if(clipObjects != NullFC)
    {
        if(clipObjects->count()       >  0                && 
           clipObjects->getClipMode() != DVRClipObjects::Off)
        {
            doClipping = true;
            clipper->reset(volume);
        }
    }

    slice.setTextureTransform(texScale,texTranslate);

    for(nSlice = 0; nSlice < numSlices; nSlice++) 
    {
        
        // calculate intersection with each edge
        numIntersections = 0;

        for(i = 0; i < 12; i++) 
        {
            if(planeSlice.intersect(edges[i],vecIntersection)) 
            {
                
                if((vecIntersection-center).length() <= radius) 
                {
                    vecIntersections[numIntersections]  = vecIntersection;
                    nEdgeCodes[numIntersections]        = ecodes[i];
                    bIntersectionUsed[numIntersections] = false;

                    numIntersections++;
                }
            }
        }
        
        // eleminate double vertices
        // --------------------------------------------

        if (numIntersections > 2) 
        {
            for(i = 0; i < numIntersections-1; i++) 
            {
                for(j = i+1; j < numIntersections; j++) 
                {
                    if((vecIntersections[i]-vecIntersections[j]).length() < 
                       fTolerance) 
                    {
                        // merge the two intersections
                        nEdgeCodes[i] |= nEdgeCodes[j];
                        // remove j
                        if(j < numIntersections-1) 
                        {
                            vecIntersections[j] = 
                                vecIntersections[numIntersections-1];
                            nEdgeCodes[j] = nEdgeCodes[numIntersections-1];

                            // vertex j has changed, so examine the 
                            // vertex j again
                            j--; 
                        }

                        numIntersections--;
                    }
                }
            }
        }
        
        assert(numIntersections <= 6);
        
        if(numIntersections > 2) 
        {
            
            //find correct sequence;
            vecIntersectionsSorted[0] = vecIntersections[0];
            bIntersectionUsed[0]      = true;
            numUsedIntersections      = 1;
              
            nEdgeCode = nEdgeCodes[0];

            // HACK need to fix the endless loop!
            UInt32 count = 0;
            while(numUsedIntersections != numIntersections && ++count <= numIntersections)
            {
                for(Int32 i = 1; i < numIntersections; i++) 
                {
                    if ((bIntersectionUsed[i] == false   ) && 
                        (nEdgeCodes[i]        & nEdgeCode)  ) 
                    {
                        vecIntersectionsSorted[numUsedIntersections] = 
                            vecIntersections[i];

                        nEdgeCode            = nEdgeCodes[i];
                        bIntersectionUsed[i] = true;

                        numUsedIntersections++;
                    }
                }
            }
            
            if(doClipping)
            {
                // check slice orientation
                Vec3f sliceNormal = 
                    (vecIntersectionsSorted[1] -
                     vecIntersectionsSorted[0]).cross(
                         vecIntersectionsSorted[2]-vecIntersectionsSorted[1]);
                
                bool sliceCCW = sliceNormal.dot(sliceDir) > 0.0; 
                
                slice.resetSlice();
                
                if(sliceCCW)
                {
                    for(Int32 i = 0; i < numIntersections; i++)
                    {
                        slice.setVertex(vecIntersectionsSorted[i]);
                    }
                }
                else
                {
                    for(Int32 i = numIntersections-1; i >=0 ; i--)
                    {
                        slice.setVertex(vecIntersectionsSorted[i]);
                    }       
                }
                
                slice.setNormal(sliceDir);
                
                // number of additional per vertex attributes 
                // (not position + first texture coordinates)

                clippedSlice.numPerVertexData = 0;
                
                // we use 3D textures
                clippedSlice.orientation = DVRRenderSlice::UNDEFINED;
                
                // contours only
                if(clipObjects->getDoContours())
                {
                    deactivateTexture(action);
                    clipper->clipSlice(volume, 
                                       slice, 
                                       sliceDir,
                                       fSliceDistance * nSlice, 
                                       clippedSlice);
                    activateTexture(action);
                }        
                else if (shader->hasRenderCallback()) 
                {
                    // shader managed slice rendering
                    
                    clippedSlice.directRender = false;
                    
                    clipper->clipSlice(volume, slice, 
                                       sliceDir,
                                       fSliceDistance * nSlice, 
                                       clippedSlice);
                    
                    shader->renderSlice(volume, action, &clippedSlice);
                } 
                else if (volume->getDoTextures()) 
                {
                    // textured slices
                    
                    clippedSlice.directRender = true;
                    
                    clipper->clipSlice(volume, 
                                       slice, 
                                       sliceDir,
                                       fSliceDistance * nSlice, 
                                       clippedSlice);
                }
                else 
                {
                    // untextured slices only

                    glColor4f(1.0, 1.0, 1.0, 1.0);

                    clippedSlice.directRender = true;   
    
                    clipper->clipSlice(volume, 
                                       slice, 
                                       sliceDir,
                                       fSliceDistance * nSlice, 
                                       clippedSlice);
                }
                clippedSlice.clear();
            }      
            else
            { 
                // clipping disabled    
                
                if(shader->hasRenderCallback()) 
                {
                    
                    // copy all data into a single field and 
                    // call rendercallback

                    Real32 data[12 * 6]; // numIntersections is bounded by 12
                    UInt32 index = 0;

                    for(Int32 i = 0; i < numIntersections; i++) 
                    {
                        v = vecIntersectionsSorted[i];
                        
                        data[index++] = v[0];
                        data[index++] = v[1];
                        data[index++] = v[2];
                        
                        data[index++] = v[0] * texscale[0] + textrans[0];
                        data[index++] = v[1] * texscale[1] + textrans[1];
                        data[index++] = v[2] * texscale[2] + textrans[2];
                    }
                    
                    shader->renderSlice(volume, 
                                        action, 
                                        data, 
                                        numIntersections, 
                                        6);
                } 
                else if (volume->getDoTextures()) 
                {
                    // textured slices
                    
                    glBegin(GL_TRIANGLE_FAN);
                    
                    for(i = 0; i < numIntersections; i++) 
                    {
                        v = vecIntersectionsSorted[i];
                        
                        glColor4f(1.0, 1.0, 1.0, fAlphaCorrect);

                        glTexCoord3f((v[0] * texscale[0] + textrans[0]), 
                                     (v[1] * texscale[1] + textrans[1]) , 
                                     (v[2] * texscale[2] + textrans[2]));
                        glVertex3fv(v.getValues());
                        
                        FDEBUG(
                            ("Brick::render3DSlices V: %f %f %f T: %f %f %f\n",
                             v[0], v[1], v[2],
                             (v[0] * texscale[0] + textrans[0]), 
                             (v[1] * texscale[1] + textrans[1]), 
                             (v[2] * texscale[2] + textrans[2])));
                    }

                    glEnd();
                    
                }
                else 
                {
                    // untextured slices only
                    
                    glColor4f(1.0, 1.0, 1.0, 1.0);

                    glBegin(GL_LINE_LOOP);
                    {
                        for(i = 0; i < numIntersections; i++) 
                        {
                            v = vecIntersectionsSorted[i];

                            glVertex3fv(v.getValues());
                        }
                    }                    
                    glEnd();
                }
            }
        }
        
        // next plane
        planeSlice.offset(fSliceDistance);
    }
}

void osg::Brick::render2DSlices	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		const Vec3f &	sliceDir
	)			[private]

Definition at line 1875 of file OSGBrick.cpp.

References center, clippedSlice, m_ori, osg::DVRRenderSlice::numPerVertexData, osg::DVRRenderSlice::orientation, render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), osg::DVRSlice::setTextureTransform(), slice, texScale, texTranslate, osg::DVRRenderSlice::XY, osg::BrickSet::XY, osg::DVRRenderSlice::XZ, osg::BrickSet::XZ, osg::DVRRenderSlice::YZ, and osg::BrickSet::YZ.

Referenced by renderSlices().

{
    // number of additional per vertex attributes 
    // (not position + first texture coordinates)

    clippedSlice.numPerVertexData = 0;

    slice.setTextureTransform(texScale,texTranslate);

    switch(m_ori)
    {
        case BrickSet::XY:
            clippedSlice.orientation = DVRRenderSlice::XY;
            render2DSliceXY(volume,
                            action,
                            shader,
                            clipper,
                            sliceDir,
                            center[2]);
            break;

        case BrickSet::XZ:
            clippedSlice.orientation = DVRRenderSlice::XZ;
            render2DSliceXZ(volume,
                            action,
                            shader,
                            clipper,
                            sliceDir,
                            center[1]);
            break;

        case BrickSet::YZ:
            clippedSlice.orientation = DVRRenderSlice::YZ;
            render2DSliceYZ(volume,
                            action,
                            shader,
                            clipper,
                            sliceDir,
                            center[0]);
            break;

        default:
            break;
    }   
}

void osg::Brick::render2DMultiSlices	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		bool	btf,
		const Vec3f &	sliceDir
	)			[private]

Definition at line 1927 of file OSGBrick.cpp.

References clippedSlice, DVRVOLUME_PARAMETER, FDEBUG, osg::DVRVolumeBase::getSampling(), m_lowerLeft, m_ori, m_upperRight, osg::NullFC, osg::DVRRenderSlice::numPerVertexData, osg::DVRRenderSlice::orientation, render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), osg::DVRSlice::setTextureTransform(), SINFO, slice, texScale, texTranslate, osg::DVRRenderSlice::XY, osg::BrickSet::XY, osg::DVRRenderSlice::XZ, osg::BrickSet::XZ, osg::DVRRenderSlice::YZ, and osg::BrickSet::YZ.

Referenced by renderSlices().

{
    DVRVolumeTexturePtr tex = DVRVOLUME_PARAMETER(volume, DVRVolumeTexture);

    if(tex == NullFC) 
        return;

    Vec3f  res         = tex->getResolution();
    Vec3f  vox         = tex->getSliceThickness();

    Real32 fSampleRate = volume->getSampling();
    
    Int32  dim       = 2 - m_ori; // dimension perpenticular to slice planes

    Real32 numSlices = res[dim] * fSampleRate;

    // ancor for the slices
    Real32 anchor    = (-res[dim] / 2.0f + 0.5f) * vox[dim]; 
    Real32 dist      = vox[dim] / fSampleRate;

    if(btf)
    {
        SINFO << "Brick::render2DMultiSlices - BTF" << std::endl;

        anchor = -anchor;
        dist   = -dist;
    }
    
    FDEBUG(("Brick::render2DMultiSlices - ori:       %d", m_ori));
    FDEBUG(("Brick::render2DMultiSlices - numSlices: %d", numSlices));
    
    // number of additional per vertex attributes 
    // (not position + first texture coordinates)

    clippedSlice.numPerVertexData = 0;
    
    Vec3f multiTexScale     = texScale;
    Vec3f multiTexTranslate = texTranslate;
    
    switch(m_ori)
    {
        case BrickSet::XY:

            clippedSlice.orientation = DVRRenderSlice::XY;

            // "reuse" texScale/translate for setting the interpolation 
            // factor whem clipping is performed
            multiTexScale[2] = 0.0;

            for(UInt32 nSlice = 0; nSlice < numSlices; nSlice++)
            {
                if((anchor >= m_lowerLeft[2]) && (anchor < m_upperRight[2]))
                {      
                    FDEBUG(("Slice %d: %f\n", nSlice, anchor));

                    multiTexTranslate[2] = anchor - m_lowerLeft[2];

                    slice.setTextureTransform(multiTexScale,multiTexTranslate);

                    render2DSliceXY(volume,
                                    action,
                                    shader,
                                    clipper,
                                    sliceDir,
                                    anchor);
                }

                // next slice
                anchor += dist;
            }    
            break;

        case BrickSet::XZ:

            clippedSlice.orientation = DVRRenderSlice::XZ;

            multiTexScale[1] = 0.0;

            for(UInt32 nSlice = 0; nSlice < numSlices; nSlice++)
            {
                if((anchor >= m_lowerLeft[1]) && (anchor < m_upperRight[1]))
                {        
                    FDEBUG(("Slice %d: %f\n", nSlice, anchor));
                    // "reuse" texScale/translate for setting the 
                    // interpolation factor whem clipping is performed

                    multiTexTranslate[1] = anchor - m_lowerLeft[1];

                    slice.setTextureTransform(multiTexScale,multiTexTranslate);

                    render2DSliceXZ(volume,
                                    action,
                                    shader,
                                    clipper,
                                    sliceDir,
                                    anchor);
                }
                // next slice
                anchor += dist;
            }
            break;

        case BrickSet::YZ:

            clippedSlice.orientation = DVRRenderSlice::YZ;

            multiTexScale[0] = 0.0;

            for(UInt32 nSlice = 0; nSlice < numSlices; nSlice++)
            {
                if((anchor >= m_lowerLeft[0]) && (anchor < m_upperRight[0]))
                {        
                    FDEBUG(("Slice %d: %f\n", nSlice, anchor));
                    // "reuse" texScale/translate for setting the 
                    // interpolation factor whem clipping is performed

                    multiTexTranslate[0] = anchor - m_lowerLeft[0];

                    slice.setTextureTransform(multiTexScale,multiTexTranslate);

                    render2DSliceYZ(volume,
                                    action,
                                    shader,
                                    clipper,
                                    sliceDir,
                                    anchor);
                }

                // next slice
                anchor += dist;
            }
            break;

        default:
            break;
    }
}

void osg::Brick::render2DSliceXY	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		const Vec3f &	sliceDir,
		const Real32 &	zCoord
	)			[private]

Definition at line 1253 of file OSGBrick.cpp.

References activateTexture(), center, osg::DVRRenderSlice::clear(), clippedSlice, osg::DVRClipper::clipSlice(), deactivateTexture(), osg::DVRRenderSlice::directRender, osg::Plane::distance(), DVRVOLUME_PARAMETER, FDEBUG, osg::DVRVolumeBase::getDoTextures(), osg::DVRClipper::getReferencePlane(), m_lowerLeft, osg::NullFC, osg::DVRClipObjects::Off, osg::DVRSlice::resetSlice(), osg::DVRSlice::setNormal(), osg::DVRSlice::setVertex(), slice, texScale, texTranslate, and vertex.

Referenced by render2DMultiSlices(), and render2DSlices().

{
    Real32 xmin = vertex[0][0];
    Real32 xmax = vertex[1][0];
    
    Real32 ymin = vertex[0][1];
    Real32 ymax = vertex[2][1]; 
  
    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);
  
    // check whether clipping should be performed
    bool doClipping = false;  
    if(clipObjects != NullFC)
    {
        if(clipObjects->count()       >  0                && 
           clipObjects->getClipMode() != DVRClipObjects::Off)
        {
            doClipping = true;
        }
    }
    
    if(doClipping)
    {
        slice.resetSlice();
        
        if(sliceDir[2] > 0.0)
        {
            slice.setVertex(Vec3f(xmin, ymin, zCoord));
            slice.setVertex(Vec3f(xmax, ymin, zCoord));
            slice.setVertex(Vec3f(xmax, ymax, zCoord));
            slice.setVertex(Vec3f(xmin, ymax, zCoord));
        }
        else
        {
            slice.setVertex(Vec3f(xmin, ymax, zCoord));
            slice.setVertex(Vec3f(xmax, ymax, zCoord));
            slice.setVertex(Vec3f(xmax, ymin, zCoord));
            slice.setVertex(Vec3f(xmin, ymin, zCoord));
        }

        slice.setNormal(sliceDir);
        
        Real32 dist = clipper->getReferencePlane().distance(
            Pnt3f(center[0], center[1], zCoord)); 
    
        FDEBUG(("Brick - dist to refPlane: %f\n",dist))
            FDEBUG(("Brick - Brick center: %f\n",zCoord))

            // contours only
            if(clipObjects->getDoContours())
            {
                deactivateTexture(action);

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);

                activateTexture(action);
            }        
            else if (shader->hasRenderCallback()) 
            {
                // shader managed slice rendering
      
                clippedSlice.directRender = false;
                
                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
                
                shader->renderSlice(volume, action, &clippedSlice);
            } 
            else if(volume->getDoTextures()) 
            {
                // textured slices
      
                clippedSlice.directRender = true;
                
                clipper->clipSlice(volume, slice, 
                                   sliceDir,dist, 
                                   clippedSlice);
            }
            else 
            {
                // untextured slices only

                glColor4f(1.0, 1.0, 1.0, 1.0);

                clippedSlice.directRender = true;       

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
            }
        clippedSlice.clear();
    }    
    else 
    { 
        // clipping disabled
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        } 
        else if(volume->getDoTextures()) 
        {
            glBegin(GL_TRIANGLE_FAN);
        } 
        else
        {
            glColor4f(1.0, 1.0, 1.0, 1.0);
            glBegin(GL_LINE_LOOP);
        }      
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // copy all data into a single field and call rendercallback
      
            Real32 multiTexIntFactor = zCoord - m_lowerLeft[2];
            
            Real32 data[] = 
            {
                xmin, 
                ymin, 
                zCoord, // first vertex
                xmin * texScale[0] + texTranslate[0], 
                ymin * texScale[1] + texTranslate[1], 
                multiTexIntFactor,

                xmax, 
                ymin, 
                zCoord, // second vertex
                xmax * texScale[0] + texTranslate[0], 
                ymin * texScale[1] + texTranslate[1], multiTexIntFactor,

                xmax, 
                ymax, 
                zCoord, // third vertex
                xmax * texScale[0] + texTranslate[0], 
                ymax * texScale[1] + texTranslate[1], 
                multiTexIntFactor,

                xmin, 
                ymax, 
                zCoord, // fourth vertex
                xmin * texScale[0] + texTranslate[0], 
                ymax * texScale[1] + texTranslate[1], 
                multiTexIntFactor
            };
            
            shader->renderSlice(volume, action, data, 4, 6);
            
        } 
        else 
        {
            glTexCoord2f(xmin * texScale[0] + texTranslate[0],
                         ymin * texScale[1] + texTranslate[1]);

            glVertex3f(xmin, ymin, zCoord);
            

            glTexCoord2f(xmax * texScale[0] + texTranslate[0],
                         ymin * texScale[1] + texTranslate[1]);

            glVertex3f(xmax, ymin, zCoord);
            

            glTexCoord2f(xmax * texScale[0] + texTranslate[0],
                         ymax * texScale[1] + texTranslate[1]);

            glVertex3f(xmax, ymax, zCoord);
            

            glTexCoord2f(xmin * texScale[0] + texTranslate[0],
                         ymax * texScale[1] + texTranslate[1]);

            glVertex3f(xmin, ymax, zCoord);
        }
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        } 
        else
        {
            glEnd();
        }
        
    }
    
}

void osg::Brick::render2DSliceXZ	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		const Vec3f &	sliceDir,
		const Real32 &	yCoord
	)			[private]

Definition at line 1457 of file OSGBrick.cpp.

References activateTexture(), center, osg::DVRRenderSlice::clear(), clippedSlice, osg::DVRClipper::clipSlice(), deactivateTexture(), osg::DVRRenderSlice::directRender, osg::Plane::distance(), DVRVOLUME_PARAMETER, FDEBUG, osg::DVRVolumeBase::getDoTextures(), osg::DVRClipper::getReferencePlane(), m_lowerLeft, osg::NullFC, osg::DVRClipObjects::Off, osg::DVRSlice::resetSlice(), osg::DVRSlice::setNormal(), osg::DVRSlice::setVertex(), slice, texScale, texTranslate, and vertex.

Referenced by render2DMultiSlices(), and render2DSlices().

{
    Real32 xmin = vertex[0][0];
    Real32 xmax = vertex[1][0];
    
    Real32 zmin = vertex[0][2];
    Real32 zmax = vertex[4][2]; 
  
    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);

    // check whether clipping should be performed
    bool doClipping = false;  
    if(clipObjects != NullFC)
    {
        if(clipObjects->count()       >  0                && 
           clipObjects->getClipMode() != DVRClipObjects::Off)
        {
            doClipping = true;
        }
    }
    
    if(doClipping)
    {
        slice.resetSlice();

        if(sliceDir[1] < 0.0)
        {
            slice.setVertex(Vec3f(xmin, yCoord, zmin));
            slice.setVertex(Vec3f(xmax, yCoord, zmin));
            slice.setVertex(Vec3f(xmax, yCoord, zmax));
            slice.setVertex(Vec3f(xmin, yCoord, zmax));
        }
        else
        {
            slice.setVertex(Vec3f(xmin, yCoord, zmax));
            slice.setVertex(Vec3f(xmax, yCoord, zmax));
            slice.setVertex(Vec3f(xmax, yCoord, zmin));
            slice.setVertex(Vec3f(xmin, yCoord, zmin));
        }
        
        slice.setNormal(sliceDir);
    
        Real32 dist = clipper->getReferencePlane().distance(
            Pnt3f(center[0], yCoord, center[2])); 
        
        FDEBUG(("Brick - dist to refPlane: %f\n",dist))
            FDEBUG(("Brick - Brick center: %f\n",yCoord))
            
            // contours only
            if(clipObjects->getDoContours())
            {
                deactivateTexture(action);

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);

                activateTexture(action);
            }        
            else if(shader->hasRenderCallback()) 
            {
                // shader managed slice rendering
                
                clippedSlice.directRender = false;
                
                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
                
                shader->renderSlice(volume, action, &clippedSlice);
            } 
            else if(volume->getDoTextures()) 
            {      
                // textured slices
      
                clippedSlice.directRender = true;
                
                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
            }
            else 
            {
                // untextured slices only

                glColor4f(1.0, 1.0, 1.0, 1.0);

                clippedSlice.directRender = true;       

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
            }
        clippedSlice.clear();
    }    
    else 
    { 
        // clipping disabled
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        }
        else if(volume->getDoTextures()) 
        {
            glBegin(GL_TRIANGLE_FAN);
        }
        else
        {
            glColor4f(1.0, 1.0, 1.0, 1.0);

            glBegin(GL_LINE_LOOP);
        }
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // copy all data into a single field and call rendercallback
            
            Real32 multiTexIntFactor = yCoord - m_lowerLeft[1];
            
            Real32 data[] = 
            {
                xmin, 
                yCoord, 
                zmin, // first vertex
                xmin * texScale[0] + texTranslate[0], 
                zmin * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xmax, 
                yCoord, 
                zmin, // second vertex
                xmax * texScale[0] + texTranslate[0], 
                zmin * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xmax, 
                yCoord, 
                zmax, // third vertex
                xmax * texScale[0] + texTranslate[0], 
                zmax * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xmin, 
                yCoord, 
                zmax, // fourth vertex
                xmin * texScale[0] + texTranslate[0], 
                zmax * texScale[2] + texTranslate[2], 
                multiTexIntFactor
            };
                 
            shader->renderSlice(volume, action, data, 4, 6);
        } 
        else 
        {
            FDEBUG(("XZ render2dslice (texcoor): %f %f\n",
                    xmin * texScale[0] + texTranslate[0],
                    zmin * texScale[2] + texTranslate[2]));       

            glTexCoord2f(xmin * texScale[0] + texTranslate[0],
                         zmin * texScale[2] + texTranslate[2]);
        
            glVertex3f(xmin, yCoord, zmin);
            
            
            glTexCoord2f(xmax * texScale[0] + texTranslate[0],
                         zmin * texScale[2] + texTranslate[2]);

            glVertex3f(xmax, yCoord, zmin);
            

            glTexCoord2f(xmax * texScale[0] + texTranslate[0],
                         zmax * texScale[2] + texTranslate[2]);

            glVertex3f(xmax, yCoord, zmax);
            

            glTexCoord2f(xmin * texScale[0] + texTranslate[0],
                         zmax * texScale[2] + texTranslate[2]);

            glVertex3f(xmin, yCoord, zmax);
        }
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        } 
        else
        {
            glEnd();
        }
    }
}

void osg::Brick::render2DSliceYZ	(	DVRVolume *	volume,
		DrawActionBase *	action,
		DVRShaderPtr	shader,
		DVRClipper *	clipper,
		const Vec3f &	sliceDir,
		const Real32 &	xCoord
	)			[private]

Definition at line 1666 of file OSGBrick.cpp.

References activateTexture(), center, osg::DVRRenderSlice::clear(), clippedSlice, osg::DVRClipper::clipSlice(), deactivateTexture(), osg::DVRRenderSlice::directRender, osg::Plane::distance(), DVRVOLUME_PARAMETER, FDEBUG, osg::DVRVolumeBase::getDoTextures(), osg::DVRClipper::getReferencePlane(), m_lowerLeft, osg::NullFC, osg::DVRClipObjects::Off, osg::DVRSlice::resetSlice(), osg::DVRSlice::setNormal(), osg::DVRSlice::setVertex(), slice, texScale, texTranslate, and vertex.

Referenced by render2DMultiSlices(), and render2DSlices().

{  
    Real32 ymin = vertex[0][1];
    Real32 ymax = vertex[2][1]; 
    
    Real32 zmin = vertex[0][2];
    Real32 zmax = vertex[4][2]; 
  
    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);
  
    // check whether clipping should be performed
    bool doClipping = false;  

    if(clipObjects != NullFC)
    {
        if(clipObjects->count()       >  0                && 
           clipObjects->getClipMode() != DVRClipObjects::Off)
        {
            doClipping = true;
        }
    }
    
    if(doClipping)
    {
        
        slice.resetSlice();
        
        if(sliceDir[0] > 0.0)
        {
            slice.setVertex(Vec3f(xCoord, ymin, zmin));
            slice.setVertex(Vec3f(xCoord, ymax, zmin));
            slice.setVertex(Vec3f(xCoord, ymax, zmax));
            slice.setVertex(Vec3f(xCoord, ymin, zmax));
        }
        else
        {
            slice.setVertex(Vec3f(xCoord, ymin, zmax));
            slice.setVertex(Vec3f(xCoord, ymax, zmax));
            slice.setVertex(Vec3f(xCoord, ymax, zmin));
            slice.setVertex(Vec3f(xCoord, ymin, zmin));
        }
    
        slice.setNormal(sliceDir);
    
        Real32 dist = clipper->getReferencePlane().distance(
            Pnt3f(xCoord,center[1],center[2])); 
        
        FDEBUG(("Brick - dist to refPlane: %f\n",dist))
            FDEBUG(("Brick - Brick center: %f\n",xCoord))
            
            // contours only
            if(clipObjects->getDoContours())
            {
                deactivateTexture(action);

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);

                activateTexture(action);
            }        
            else if(shader->hasRenderCallback()) 
            {
                // shader managed slice rendering
                
                clippedSlice.directRender = false;
                
                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
                
                shader->renderSlice(volume, action, &clippedSlice);
                
            } 
            else if (volume->getDoTextures()) 
            {     
                // textured slices
                
                clippedSlice.directRender = true;
                
                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
            }
            else 
            {
                // untextured slices only

                glColor4f(1.0, 1.0, 1.0, 1.0);

                clippedSlice.directRender = true;       

                clipper->clipSlice(volume, 
                                   slice, 
                                   sliceDir,
                                   dist, 
                                   clippedSlice);
            }
        clippedSlice.clear();
    }    
    else 
    { 
        // clipping disabled

        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        } 
        else if (volume->getDoTextures()) 
        {
            glBegin(GL_TRIANGLE_FAN);
        } 
        else 
        {
            glColor4f(1.0, 1.0, 1.0, 1.0);

            glBegin(GL_LINE_LOOP);
        }

        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // copy all data into a single field and call render callback
            
            Real32 multiTexIntFactor = xCoord - m_lowerLeft[0];
            
            Real32 data[] = 
            { 
                xCoord, 
                ymin, 
                zmin,
                ymin * texScale[1] + texTranslate[1], 
                zmin * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xCoord, 
                ymax, 
                zmin,
                ymax * texScale[1] + texTranslate[1], 
                zmin * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xCoord, 
                ymax, 
                zmax,
                ymax * texScale[1] + texTranslate[1], 
                zmax * texScale[2] + texTranslate[2], 
                multiTexIntFactor,

                xCoord, 
                ymin, 
                zmax,
                ymin * texScale[1] + texTranslate[1], 
                zmax * texScale[2] + texTranslate[2], 
                multiTexIntFactor
            };
                 
            shader->renderSlice(volume, action, data, 4, 6);
        } 
        else 
        {
            glTexCoord2f(ymin * texScale[1] + texTranslate[1],
                         zmin * texScale[2] + texTranslate[2]);

            glVertex3f(xCoord, ymin, zmin);
            

            glTexCoord2f(ymax * texScale[1] + texTranslate[1],
                         zmin * texScale[2] + texTranslate[2]);

            glVertex3f(xCoord, ymax, zmin);
            

            glTexCoord2f(ymax * texScale[1] + texTranslate[1],
                         zmax * texScale[2] + texTranslate[2]);

            glVertex3f(xCoord, ymax, zmax);

            
            glTexCoord2f(ymin * texScale[1] + texTranslate[1],
                         zmax * texScale[2] + texTranslate[2]);

            glVertex3f(xCoord, ymin, zmax);
        }
        
        if((shader != NullFC) && shader->hasRenderCallback()) 
        {
            // do nothing
        } 
        else
        {
            glEnd();
        }
    }
}

---

Friends And Related Function Documentation

friend class BrickSet [friend]

Definition at line 191 of file OSGBrick.h.

---

Member Data Documentation

Vec3f osg::Brick::vertex[8] [private]

Definition at line 127 of file OSGBrick.h.

Referenced by init(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), and renderBrick().

Line osg::Brick::edges[12] [private]

Definition at line 128 of file OSGBrick.h.

Referenced by init(), and render3DSlices().

TextureChunkPtr* osg::Brick::texture [private]

Definition at line 129 of file OSGBrick.h.

Referenced by activateTexture(), osg::BrickSet::buildBrickTextures(), changeFromTexture(), and deactivateTexture().

UInt32* osg::Brick::texStage [private]

Definition at line 130 of file OSGBrick.h.

Referenced by activateTexture(), osg::BrickSet::buildBrickTextures(), changeFromTexture(), and deactivateTexture().

Int32 osg::Brick::numTextures [private]

Definition at line 131 of file OSGBrick.h.

Referenced by activateTexture(), osg::BrickSet::buildBrickTextures(), changeFromTexture(), osg::BrickSet::clearBrickTextures(), deactivateTexture(), and osg::BrickSet::reloadBrickTextures().

Vec3f osg::Brick::center [private]

Definition at line 132 of file OSGBrick.h.

Referenced by init(), render2DSlices(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), render3DSlices(), and osg::BrickSet::sortBricks3D().

Real32 osg::Brick::radius [private]

Definition at line 133 of file OSGBrick.h.

Referenced by init(), and render3DSlices().

Vec3f osg::Brick::texTranslate [private]

Definition at line 134 of file OSGBrick.h.

Referenced by init(), render2DMultiSlices(), render2DSlices(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), render3DSlices(), and vertToTex().

Vec3f osg::Brick::texScale [private]

Definition at line 135 of file OSGBrick.h.

Referenced by init(), render2DMultiSlices(), render2DSlices(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), render3DSlices(), and vertToTex().

Int32 osg::Brick::voxSize[3] [private]

Definition at line 136 of file OSGBrick.h.

Referenced by osg::BrickSet::buildBrickTextures(), and init().

Int32 osg::Brick::minVox[3] [private]

Definition at line 137 of file OSGBrick.h.

Referenced by osg::BrickSet::buildBrickTextures(), and init().

Vec3f osg::Brick::m_lowerLeft [private]

Definition at line 138 of file OSGBrick.h.

Referenced by init(), render2DMultiSlices(), render2DSliceXY(), render2DSliceXZ(), and render2DSliceYZ().

Vec3f osg::Brick::m_upperRight [private]

Definition at line 139 of file OSGBrick.h.

Referenced by init(), and render2DMultiSlices().

BrickSet::Orientation osg::Brick::m_ori [private]

Definition at line 140 of file OSGBrick.h.

Referenced by init(), render2DMultiSlices(), and render2DSlices().

Real32 osg::Brick::distance [private]

Definition at line 143 of file OSGBrick.h.

Referenced by osg::BrickSet::sortBricks3D().

Brick* osg::Brick::prev [private]

Definition at line 144 of file OSGBrick.h.

Referenced by osg::BrickSet::sortBricks2D(), and osg::BrickSet::sortBricks3D().

Brick* osg::Brick::next [private]

Definition at line 145 of file OSGBrick.h.

Referenced by getNext(), osg::BrickSet::sortBricks2D(), and osg::BrickSet::sortBricks3D().

DVRSlice osg::Brick::slice [private]

Definition at line 147 of file OSGBrick.h.

Referenced by render2DMultiSlices(), render2DSlices(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), and render3DSlices().

DVRRenderSlice osg::Brick::clippedSlice [private]

Definition at line 148 of file OSGBrick.h.

Referenced by render2DMultiSlices(), render2DSlices(), render2DSliceXY(), render2DSliceXZ(), render2DSliceYZ(), and render3DSlices().

---

The documentation for this class was generated from the following files:

• OSGBrick.h
• OSGBrick.cpp
• OSGBrick.inl