osg::BrickSet Struct Reference

#include <OSGBrick.h>

List of all members.

Public Types
enum	Orientation { XY = 0, XZ = 1, YZ = 2, UNDEF = 3 }
Public Member Functions
	BrickSet (void)
	~BrickSet (void)
Brick *	sortBricks3D (const Matrix &modelMat, const Vec3f &eyePoint)
	Return sorted brick list.
Brick *	sortBricks2D (bool backToFront)
	Return sorted brick list.
void	buildBrickTextures (ChunkMaterialPtr &material, TextureSet &textures, TextureManager::TextureMode mode)
	Build textures for bricks.
void	reloadBrickTextures (DrawActionBase *action, UInt32 texStage)
	Reload brick textures.
void	clearBrickTextures (ChunkMaterialPtr &material)
	Clear brick textures.
void	buildBricks3D (DVRVolume *volume, Vec3f brickSubdivision, Int32 overlap=1, Orientation ori=UNDEF)
	Build 3D bricks.
void	buildBricks2D (DVRVolume *volume, Orientation ori)
	Build 2D bricks.
Static Public Member Functions
static TextureChunkPtr	makeTexture (UInt32 internalFormat, UInt32 externalFormat, ImagePtr image)
	Create texture chunk for image.
Public Attributes
Brick *	m_pBricks
int	m_nNumBricks
Orientation	m_nOrientation

---

Detailed Description

Definition at line 31 of file OSGBrick.h.

---

Member Enumeration Documentation

enum osg::BrickSet::Orientation

Enumerator:

XY
XZ
YZ
UNDEF

Definition at line 35 of file OSGBrick.h.

    {
        XY    = 0,
        XZ    = 1,
        YZ    = 2,
        UNDEF = 3   // especially for 3D textures
    };

---

Constructor & Destructor Documentation

osg::BrickSet::BrickSet

(

void

)

[inline]

Definition at line 5 of file OSGBrick.inl.

                       : 
    m_pBricks(0), 
    m_nNumBricks(0), 
    m_nOrientation(UNDEF) 
{
}

osg::BrickSet::~BrickSet

(

void

)

Definition at line 22 of file OSGBrick.cpp.

References m_pBricks.

{
    delete [] m_pBricks;
}

---

Member Function Documentation

Brick * osg::BrickSet::sortBricks3D	(	const Matrix &	modelMat,
		const Vec3f &	eyePoint
	)

Definition at line 492 of file OSGBrick.cpp.

References osg::Brick::center, osg::Brick::distance, m_nNumBricks, m_pBricks, osg::TransformationMatrix< ValueTypeT >::mult(), osg::Brick::next, and osg::Brick::prev.

Referenced by osg::TextureManager::sortBricks().

{
    
    Brick  *BrickList = m_pBricks;

    Int32   nBrick;
    Real32  distance;
    Brick  *previous, *current, *incoming;
    
    Vec3f transformedCenter;

    m_pBricks[0].prev = NULL;
    m_pBricks[0].next = NULL;

    modelMat.mult(m_pBricks[0].center, transformedCenter);

    m_pBricks[0].distance = (eyePoint - transformedCenter).length();
    

    for(nBrick = 1; nBrick < m_nNumBricks; nBrick++) 
    {
        incoming = &(m_pBricks[nBrick]);

        modelMat.mult(incoming->center, transformedCenter);

        distance = (eyePoint - transformedCenter).length();

        incoming->distance = distance;
        incoming->next     = NULL;
        incoming->prev     = NULL;

        current  = BrickList;
        previous = NULL;

        while((current != NULL) && (current->distance > distance)) 
        {
            previous = current;
            current = current->next;
        }

        // insert 
        if (current == NULL) 
        {
            // insert at the end of the list;
            previous->next = incoming;
            incoming->prev = previous;
            
        }
        else
        {
            incoming->next = current;
            incoming->prev = current->prev;
            current->prev  = incoming;

            if (incoming->prev == NULL) 
            {
                BrickList = incoming;
            } 
            else
            {
                incoming->prev->next = incoming;
            }
        }
    }
    
    return BrickList;
}

Brick * osg::BrickSet::sortBricks2D

(

bool

backToFront

)

Definition at line 562 of file OSGBrick.cpp.

References m_nNumBricks, m_pBricks, osg::Brick::next, and osg::Brick::prev.

Referenced by osg::TextureManager::sortBricks().

{
    Brick *brickList = m_pBricks;
    
    if(brickList) 
    {
        if(backToFront) 
        {
            for(int i = m_nNumBricks - 1; i >= 0; i--) 
            {
                m_pBricks[i].prev = &(m_pBricks[i + 1]);
                m_pBricks[i].next = &(m_pBricks[i - 1]);
            }
            
            m_pBricks[0].next                = NULL;
            m_pBricks[m_nNumBricks - 1].prev = NULL;
            
            brickList = &(m_pBricks[m_nNumBricks - 1]);
        } 
        else 
        {
            for (int i = 0; i < m_nNumBricks; i++) 
            {
                m_pBricks[i].prev = &(m_pBricks[i - 1]);
                m_pBricks[i].next = &(m_pBricks[i + 1]);
            }
            
            m_pBricks[0].prev                = NULL;
            m_pBricks[m_nNumBricks - 1].next = NULL;
            
            brickList = &(m_pBricks[0]);
        }
    }
    
    return brickList;
}

void osg::BrickSet::buildBrickTextures	(	ChunkMaterialPtr &	material,
		TextureSet &	textures,
		TextureManager::TextureMode	mode
	)

Definition at line 314 of file OSGBrick.cpp.

References osg::beginEditCP(), osg::ImageBase::create(), osg::endEditCP(), m_nNumBricks, m_pBricks, makeTexture(), osg::Brick::minVox, osg::Brick::numTextures, osg::Brick::texStage, osg::Brick::texture, osg::TextureManager::TM_2D, osg::TextureManager::TM_2D_Multi, osg::TextureManager::TM_3D, and osg::Brick::voxSize.

Referenced by osg::TextureManager::buildTextures().

{
    // overall number of textures
    UInt32 numTextures = textures.size();
    
    if(mode == TextureManager::TM_2D_Multi)
        numTextures *= 2;
    
    beginEditCP(material);
    {
        // build all texture chunks
        for(Int32 index = 0; index < m_nNumBricks; index++)
        {
            Int32 &resX  = m_pBricks[index].voxSize[0];
            Int32 &resY  = m_pBricks[index].voxSize[1];
            Int32 &resZ  = m_pBricks[index].voxSize[2];
            
            Int32 &nXMin = m_pBricks[index].minVox[0];
            Int32 &nYMin = m_pBricks[index].minVox[1];
            Int32 &nZMin = m_pBricks[index].minVox[2];
            
            int texCounter = 0;
            
            m_pBricks[index].texture     = new TextureChunkPtr[numTextures];
            m_pBricks[index].texStage    = new UInt32[numTextures];
            m_pBricks[index].numTextures = numTextures;
            
            // create texture chunks
            for(UInt32 tch = 0; tch < textures.size(); tch++) 
            { 
                ImagePtr img = Image::create();
                
                switch (mode)
                {
                    case TextureManager::TM_2D_Multi: // 2D multi textures
                    {
                        // first texture
                        textures[tch]->_image->slice(resX == 2 ? nXMin : -1,
                                                     resY == 2 ? nYMin : -1,
                                                     resZ == 2 ? nZMin : -1,
                                                     img);
                        if (index == 0)
                        {
                            m_pBricks[index].texture[texCounter] = 
                                makeTexture(textures[tch]->_internalFormat,
                                            textures[tch]->_externalFormat,
                                            img                           );
                        }
                        else
                        {
                            // each but first brick can reuse texture 
                            // chunks of previous brick

                            m_pBricks[index].texture[texCounter] = 
                                m_pBricks[index-1].texture[texCounter+1];
                        }
                        
                        m_pBricks[index].texStage[texCounter] = 
                            textures[tch]->_textureStage0;

                        material->addChunk(
                            m_pBricks[index].texture[texCounter]);

                        texCounter++;
                        
                        // second texture
                        img = Image::create();

                        textures[tch]->_image->slice(
                            resX == 2 ? nXMin + 1 : -1,
                            resY == 2 ? nYMin + 1 : -1,
                            resZ == 2 ? nZMin + 1 : -1,
                            img                       );

                        m_pBricks[index].texture[texCounter] = 
                            makeTexture(textures[tch]->_internalFormat,
                                        textures[tch]->_externalFormat,
                                        img                           );

                        m_pBricks[index].texStage[texCounter] = 
                            textures[tch]->_textureStage1;

                        material->addChunk(
                            m_pBricks[index].texture[texCounter]);

                        texCounter++;
                        
                        break;
                    }
                    
                    case TextureManager::TM_2D: // 2D ordinary textures
                    {
                        textures[tch]->_image->slice(resX == 1 ? nXMin : -1,
                                                     resY == 1 ? nYMin : -1,
                                                     resZ == 1 ? nZMin : -1,
                                                     img);

                        m_pBricks[index].texture[texCounter] = 
                            makeTexture(textures[tch]->_internalFormat,
                                        textures[tch]->_externalFormat,
                                        img                           );

                        m_pBricks[index].texStage[texCounter] = 
                            textures[tch]->_textureStage0;

                        material->addChunk(
                            m_pBricks[index].texture[texCounter]);

                        texCounter++;
                        
                        break;
                    }
                    
                    case TextureManager::TM_3D: // 3D ordinary textures
                    default:
                    {
                        textures[tch]->_image->subImage(nXMin, nYMin, nZMin,
                                                        resX, resY, resZ,
                                                        img                );

                        m_pBricks[index].texture[texCounter] = 
                            makeTexture(textures[tch]->_internalFormat,
                                        textures[tch]->_externalFormat,
                                        img                           );

                        m_pBricks[index].texStage[texCounter] = 
                            textures[texCounter]->_textureStage0;

                        material->addChunk(
                            m_pBricks[index].texture[texCounter]);

                        texCounter++;
                        
                        break;
                    }
                }
                
            } // for all registered textures
            
        } // for all bricks
    }
    endEditCP(material);
}

void osg::BrickSet::reloadBrickTextures	(	DrawActionBase *	action,
		UInt32	texStage
	)

Definition at line 462 of file OSGBrick.cpp.

References osg::DrawActionBase::getWindow(), m_nNumBricks, m_pBricks, osg::Brick::numTextures, and osg::Window::refreshGLObject().

Referenced by osg::TextureManager::reloadTexture().

{
    for(Int32 i = 0; i < m_nNumBricks; i++)
    {
        for(Int32 j = 0; j < m_pBricks[i].numTextures; j++)
        {
            if(m_pBricks[i].texStage[j] == texStage)
            {
                action->getWindow()->refreshGLObject(
                    m_pBricks[i].texture[j]->getGLId());
            }
        }
    }
}

void osg::BrickSet::clearBrickTextures

(

ChunkMaterialPtr &

material

)

Definition at line 479 of file OSGBrick.cpp.

References m_nNumBricks, m_pBricks, and osg::Brick::numTextures.

Referenced by osg::TextureManager::clearTextures().

{
    for(Int32 i = 0; i < m_nNumBricks; i++)
    {
        for(Int32 j = 0; j < m_pBricks[i].numTextures; j++)
        {
            material->subChunk(m_pBricks[i].texture[j]);
        }
    }
}

void osg::BrickSet::buildBricks3D	(	DVRVolume *	volume,
		Vec3f	brickSubdivision,
		Int32	overlap = 1,
		Orientation	ori = UNDEF
	)

Definition at line 27 of file OSGBrick.cpp.

References DVRVOLUME_PARAMETER, FDEBUG, osg::Brick::init(), m_nNumBricks, m_nOrientation, m_pBricks, osg::NullFC, SFATAL, SINFO, and SWARNING.

Referenced by osg::TextureManager::buildTextures().

{
    FDEBUG(("BrickSet::buildBricks3D %d %d %d\n", 
            brickSize[0],
            brickSize[1], 
            brickSize[2]));

    SINFO << "BrickSet::buildBricks3D (size)" 
          << brickSize[0] << ", " 
          << brickSize[1] << ","
          << brickSize[2] << std::endl;
    
    m_nOrientation = ori;
    
    DVRVolumeTexturePtr vT = DVRVOLUME_PARAMETER(volume, DVRVolumeTexture);

    if(vT == NullFC) 
    {
        SWARNING << "BrickSet::buildTextures3D - No Volume" << std::endl;
        return;
    }

    if((brickSize[0] <= overlap) || 
       (brickSize[1] <= overlap) || 
       (brickSize[2] <= overlap)  )
    {
        SFATAL << "BrickSet::buildBricks3D - brickSize too small: "
               << brickSize[0] << ","
               << brickSize[1] << "," 
               << brickSize[2] << "for overlap " 
               << overlap << std::endl;

        return;
    }
    
    Vec3f vox  = vT->getSliceThickness();
    Vec3f res  = vT->getResolution();
    Int32 resX = Int32(res[0]);
    Int32 resY = Int32(res[1]);
    Int32 resZ = Int32(res[2]);

    Int32 nNumBricksX = Int32((resX - overlap) / (brickSize[0] - overlap));
    Int32 nNumBricksY = Int32((resY - overlap) / (brickSize[1] - overlap));
    Int32 nNumBricksZ = Int32((resZ - overlap) / (brickSize[2] - overlap));

    SINFO << "BrickSet::buildBricks3D (num)" 
          << nNumBricksX << ", " 
          << nNumBricksY << ","
          << nNumBricksZ << std::endl;
    
    m_nNumBricks = nNumBricksX * nNumBricksY * nNumBricksZ; 

    m_pBricks = new Brick[m_nNumBricks];
    
    Int32 nBrickSizeX = Int32(brickSize[0]);
    Int32 nBrickSizeY = Int32(brickSize[1]);
    Int32 nBrickSizeZ = Int32(brickSize[2]);

    Int32 nXMin = 0;
    Int32 nYMin = 0;
    Int32 nZMin = 0;

    Real32 xmin = (overlap - 1 + 0.5f - resX / 2) * vox[0];
    Real32 ymin = (overlap - 1 + 0.5f - resY / 2) * vox[1];
    Real32 zmin = (overlap - 1 + 0.5f - resZ / 2) * vox[2];

    Real32 xmax = 0, ymax = 0, zmax = 0;
    
    Int32 index = 0;
    
    for(Int32 z = 0; z < nNumBricksZ; z++) 
    {
        nYMin = 0;
        ymin  = (overlap - 1 + 0.5f - resY / 2) * vox[1];
        
        for(Int32 y = 0; y < nNumBricksY; y++) 
        {
            nXMin = 0;
            xmin  = (overlap - 1 + 0.5f - resX / 2) * vox[0];
            
            for(Int32 x = 0; x < nNumBricksX; x++) 
            {
                xmax = xmin + (nBrickSizeX - (2 * (overlap - 1) + 1)) * vox[0];
                ymax = ymin + (nBrickSizeY - (2 * (overlap - 1) + 1)) * vox[1];
                zmax = zmin + (nBrickSizeZ - (2 * (overlap - 1) + 1)) * vox[2];
                
                m_pBricks[index].init(nXMin,       nYMin,       nZMin,
                                      nBrickSizeX, nBrickSizeY, nBrickSizeZ,
                                      xmin,        ymin,        zmin,
                                      xmax,        ymax,        zmax,
                                      overlap, 
                                      ori                                  );
                
                index++;

                nXMin += nBrickSizeX - (2 * overlap - 1);
                xmin   = xmax; 
            }

            nYMin += nBrickSizeY - (2 * overlap - 1);
            ymin   = ymax;
        }
        
        nZMin += nBrickSizeZ - (2 * overlap - 1);
        zmin   = zmax;
    }
}

void osg::BrickSet::buildBricks2D	(	DVRVolume *	volume,
		Orientation	ori
	)

Definition at line 139 of file OSGBrick.cpp.

References DVRVOLUME_PARAMETER, osg::Brick::init(), m_nNumBricks, m_nOrientation, m_pBricks, osg::NullFC, SFATAL, UNDEF, XY, XZ, and YZ.

Referenced by osg::TextureManager::buildTextures().

{
    m_nOrientation = ori;
    
    DVRVolumeTexturePtr vT = DVRVOLUME_PARAMETER(volume, DVRVolumeTexture);

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

    Int32  resX = 0, resY= 0, resZ= 0;
    Real32 xmin = 0, ymin = 0, zmin = 0;             
    Real32 xmax = 0, ymax = 0, zmax = 0;          
    Real32 xinc = 0, yinc = 0, zinc = 0;
    
    switch(ori) 
    {
        case XY: 
        {
            // XY stack of textures
            resX  = Int32(res[0]);
            resY  = Int32(res[1]);
            resZ  = 1;
            
            xinc = 0;
            yinc = 0;
            zinc = 1;

            // "geometrical" size of the brick
            xmin = (-(res[0] - 1) / 2) * vox[0];  
            ymin = (-(res[1] - 1) / 2) * vox[1];
            zmin = (-(res[2]    ) / 2) * vox[2];
            
            xmax = -xmin;
            ymax = -ymin;
            zmax =  zmin + zinc * vox[2];

            m_nNumBricks = int(res[2]);
            m_pBricks    = new Brick[m_nNumBricks];

            break;
        }

        case XZ: 
        {
            // XZ stack of textures
            resX  = Int32(res[0]);
            resY  = 1;
            resZ  = Int32(res[2]);
            
            xinc = 0;
            yinc = 1;
            zinc = 0;
            
            // "geometrical" size of the brick
            xmin = (-(res[0] - 1) / 2) * vox[0];  
            ymin = (-(res[1]    ) / 2) * vox[1];
            zmin = (-(res[2] - 1) / 2) * vox[2];
            
            xmax = -xmin;
            ymax =  ymin + yinc * vox[1];
            zmax = -zmin;
            
            m_nNumBricks = int(res[1]);
            m_pBricks    = new Brick[m_nNumBricks];

            break;
        }

        case YZ: 
        {
            // YZ stack of textures
            resX  = 1;
            resY  = Int32(res[1]);
            resZ  = Int32(res[2]);
            
            xinc = 1;
            yinc = 0;
            zinc = 0;
            
            // "geometrical" size of the brick
            xmin = (-(res[0]    ) / 2) * vox[0];  
            ymin = (-(res[1] - 1) / 2) * vox[1];
            zmin = (-(res[2] - 1) / 2) * vox[2];
            
            xmax =  xmin + xinc * vox[0];
            ymax = -ymin;
            zmax = -zmin;
            
            m_nNumBricks = int(res[0]);
            m_pBricks    = new Brick[m_nNumBricks];

            break;
        }

        case UNDEF: 
        {
            SFATAL << "BrickSet::buildBricks2D called with unspecified "
                   << "orientation" 
                   << std::endl;
            break;
        }
    }
    
    for(Int32 index = 0; index < m_nNumBricks; index++) 
    {
        m_pBricks[index].init(resX == 1 ? index : 0,
                              resY == 1 ? index : 0,
                              resZ == 1 ? index : 0,
                              resX, resY, resZ,
                              xmin, ymin, zmin,
                              xmax, ymax, zmax, 
                              1, 
                              ori);
        
        xmin += xinc * vox[0];
        xmax += xinc * vox[0];
        
        ymin += yinc * vox[1];
        ymax += yinc * vox[1];
        
        zmin += zinc * vox[2];
        zmax += zinc * vox[2];
    }
}

TextureChunkPtr osg::BrickSet::makeTexture	(	UInt32	internalFormat,
		UInt32	externalFormat,
		ImagePtr	image
	)			[static]

! FIXME: this is required by the PreIntegration shader but ! may not be supported on all OpenSG platforms - so we must ! add a way that the shader can specify the wrapping

Definition at line 269 of file OSGBrick.cpp.

References osg::beginEditCP(), osg::TextureChunkBase::create(), osg::endEditCP(), and FDEBUG.

Referenced by buildBrickTextures().

{
    TextureChunkPtr chunk = TextureChunk::create();

    beginEditCP(chunk);
    {
        chunk->setImage         (img           );
        chunk->setInternalFormat(internalFormat);
        chunk->setExternalFormat(externalFormat);

        FDEBUG(("TextureManager - makeTexture: intern %d - extern %d\n",
                internalFormat, externalFormat));

#if defined GL_ARB_texture_border_clamp
        chunk->setWrapS(GL_CLAMP_TO_BORDER);
        chunk->setWrapT(GL_CLAMP_TO_BORDER);
        chunk->setWrapR(GL_CLAMP_TO_BORDER);
#else
//      chunk->setWrapS(GL_CLAMP_TO_EDGE);
//      chunk->setWrapT(GL_CLAMP_TO_EDGE);
//      chunk->setWrapR(GL_CLAMP_TO_EDGE);
        
        chunk->setWrapS(GL_CLAMP);
        chunk->setWrapT(GL_CLAMP);
        chunk->setWrapR(GL_CLAMP);
#endif

        chunk->setMinFilter(GL_LINEAR);
        chunk->setMagFilter(GL_LINEAR);
    
//      chunk->setEnvMode(GL_REPLACE);
        chunk->setEnvMode(GL_MODULATE);
    }
    endEditCP(chunk);

    return chunk;
}

---

Member Data Documentation

Brick* osg::BrickSet::m_pBricks

Definition at line 43 of file OSGBrick.h.

Referenced by buildBricks2D(), buildBricks3D(), buildBrickTextures(), clearBrickTextures(), osg::TextureManager::clearTextures(), reloadBrickTextures(), sortBricks2D(), sortBricks3D(), and ~BrickSet().

int osg::BrickSet::m_nNumBricks

Definition at line 44 of file OSGBrick.h.

Referenced by buildBricks2D(), buildBricks3D(), buildBrickTextures(), clearBrickTextures(), osg::TextureManager::clearTextures(), reloadBrickTextures(), sortBricks2D(), and sortBricks3D().

Orientation osg::BrickSet::m_nOrientation

Definition at line 45 of file OSGBrick.h.

Referenced by buildBricks2D(), and buildBricks3D().

---

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

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