OpenSG: osg::DVRSimpleShader Class Reference

00073 { NextFieldId = 1 };

00063                                      :
00064     Inherited   (  ),
00065     m_nTextureId(-1)
00066 {
00067 }

00070                                                               :
00071     Inherited   (source),
00072     m_nTextureId(    -1)
00073 {
00074 }

00090 {
00091     Inherited::changed(whichField, origin);
00092 }

00097 {
00098     SLOG << "Dump DVRSimpleShader NI" << std::endl;
00099 }

00105 {
00106     FDEBUG(("DVRSimpleShader::initialize\n"));
00107     
00108     m_nTextureId = -1;
00109 
00110     DVRVolumeTexturePtr vol = DVRVOLUME_PARAMETER(volume, DVRVolumeTexture);
00111 
00112     ImagePtr img = vol->getImage();
00113     
00114     // Map the size to an index
00115     
00116     static Int16 types[] =  { Image::OSG_UINT8_IMAGEDATA,
00117                               Image::OSG_UINT16_IMAGEDATA,
00118                               Image::OSG_UINT32_IMAGEDATA,
00119                               Image::OSG_FLOAT16_IMAGEDATA,
00120                               Image::OSG_FLOAT32_IMAGEDATA,
00121                               -1 };
00122     
00123     UInt16 type = 0;
00124     while(types[type] != -1 && types[type] != img->getDataType()) type++;
00125     
00126     if(!types[type])
00127     {
00128         FWARNING(("DVRSimpleShader::initialize: Image data type %d "
00129                   "unknown!\n", img->getDataType()));
00130         type = 0;
00131     }
00132     
00133     if(type > 2) // Ignore float types for now
00134     {
00135         FWARNING(("DVRSimpleShader::initialize: Can't do float image types,"
00136                   " treating as int.\n"));
00137         type = 0;
00138     }
00139     
00140     
00141     // Map the pixel format to an index
00142        
00143     static Int16 formats[] =  { Image::OSG_L_PF,
00144                                 Image::OSG_LA_PF,
00145                                 Image::OSG_RGBA_DXT1,
00146                                 Image::OSG_RGBA_DXT3,
00147                                 Image::OSG_RGBA_DXT5,
00148                                 Image::OSG_RGBA_PF,
00149                                 Image::OSG_RGB_DXT1,
00150                                 Image::OSG_RGB_PF,
00151                                 -1 };
00152     
00153     UInt16 format = 0;
00154     while(formats[format] != -1 && 
00155           formats[format] != img->getPixelFormat()) format++;
00156     
00157     if(!formats[format])
00158     {
00159         FWARNING(("DVRSimpleShader::initialize: Image pixel format %d "
00160                   "unknown!\n", img->getPixelFormat()));
00161         format = 0;
00162     }
00163     
00164     if(type > 5) // RGB doesn't have alpha...
00165     {
00166         FNOTICE(("DVRSimpleShader::initialize: Image pixel format doesn't "
00167                  "have alpha! Volume will not be transparent!\n"));
00168     }
00169 
00170     // Now get the best internal format for the image
00171     
00172     static GLenum intfs[8][3] = {
00173         { GL_INTENSITY, GL_INTENSITY16, GL_INTENSITY16 },
00174         { GL_LUMINANCE_ALPHA, GL_LUMINANCE16_ALPHA16, GL_LUMINANCE16_ALPHA16 },
00175         { GL_RGBA, GL_RGBA, GL_RGBA },
00176         { GL_RGBA, GL_RGBA, GL_RGBA },
00177         { GL_RGBA, GL_RGBA, GL_RGBA },
00178         { GL_RGBA, GL_RGBA16, GL_RGBA16 },
00179         { GL_RGB, GL_RGB, GL_RGB },
00180         { GL_RGB, GL_RGB16, GL_RGB16 }
00181         };
00182                                
00183     
00184     m_nTextureId = volume->getTextureManager().registerTexture(
00185         vol->getImage(),        // image
00186         intfs[format][type],    // internalFormat
00187         GL_NONE,                // externalFormat
00188         1,                      // doBricking
00189         0,                      // textureStage0
00190         -1);                    // textureStage1
00191     
00192     if(m_nTextureId == -1) 
00193     {
00194         SWARNING << "Error registering textures ..." << std::endl;
00195         return false;
00196     }
00197     
00198     return true;
00199 }

00204 {
00205     //FDEBUG << "DVRSimpleShader::activate\n"));
00206 
00207     glPushAttrib(GL_ENABLE_BIT         | 
00208                  GL_COLOR_BUFFER_BIT   |
00209                  GL_STENCIL_BUFFER_BIT |
00210                  GL_DEPTH_BUFFER_BIT   | 
00211                  GL_POLYGON_BIT        | 
00212                  GL_TEXTURE_BIT);
00213 
00214     glDisable(GL_DITHER);
00215     glDisable(GL_LIGHTING);
00216     
00217     glColor4f(1.0,1.0,1.0,1.0); 
00218     
00219     if(volume->getDoTextures()) 
00220     {
00221         // glDisable(GL_TEXTURE_2D);  
00222         // glEnable(GL_TEXTURE_3D_EXT);  
00223         glEnable(GL_BLEND);  
00224         glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);   
00225         
00226         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);  
00227     }
00228 }

00234 {
00235     //FDEBUG(("DVRSimpleShader::brickActivate\n"));
00236 }

00241 {
00242     FDEBUG(("DVRSimpleShader::deactivate\n"));
00243     
00244     glPopAttrib();
00245 }

00249 {
00250     if (volume != NULL)
00251     {
00252         if (m_nTextureId != -1)
00253             volume->getTextureManager().unregisterTexture(m_nTextureId);
00254     }
00255 }

00059 {
00060     return _type; 
00061 }

00066 {
00067     return _type.getId(); 
00068 }

00087 {
00088     return _type; 
00089 }

00092 {
00093     return _type;
00094 }

00107 { 
00108     return sizeof(DVRSimpleShader); 
00109 }

00167 {
00168     UInt32 returnValue = Inherited::getBinSize(whichField);
00169 
00170 
00171     return returnValue;
00172 }

00176 {
00177     Inherited::copyToBin(pMem, whichField);
00178 
00179 
00180 }

00184 {
00185     Inherited::copyFromBin(pMem, whichField);
00186 
00187 
00188 }

00073 {
00074     DVRSimpleShaderPtr fc; 
00075 
00076     if(getClassType().getPrototype() != OSG::NullFC) 
00077     {
00078         fc = DVRSimpleShaderPtr::dcast(
00079             getClassType().getPrototype()-> shallowCopy()); 
00080     }
00081     
00082     return fc; 
00083 }

00088 { 
00089     DVRSimpleShaderPtr returnValue; 
00090     
00091     newPtr(returnValue); 
00092 
00093     return returnValue; 
00094 }

00098 { 
00099     DVRSimpleShaderPtr returnValue; 
00100 
00101     newPtr(returnValue, dynamic_cast<const DVRSimpleShader *>(this)); 
00102 
00103     return returnValue; 
00104 }

00193 {
00194 
00195     Inherited::executeSyncImpl(pOther, whichField);
00196 
00197 
00198 }

00184 {
00185 
00186     Inherited::executeSyncImpl(pOther, whichField);
00187 
00188 
00189 }

00115 {
00116     this->executeSyncImpl((DVRSimpleShaderBase *) &other, whichField);
00117 }

00090 {
00091     SLOG << "DVRShader::renderSlice - NI" << std::endl;
00092 }

00097 {
00098     SLOG << "DVRShader::renderSlice - NI" << std::endl;
00099 }

00102 {
00103     return false; 
00104 }

00107 {
00108     return false; 
00109 };

00072 {
00073     return _type.getGroupId();
00074 }

00078 {
00079     return getType().getId();
00080 }

00084 {
00085     return getType().getGroupId();
00086 }

00090 {
00091     return getType().getCName();
00092 }

00096 {
00097     const FieldDescription *desc = getType().getFieldDescription(fieldId);
00098 
00099     return desc ? desc->getField(*this) : NULL;
00100 }

00104 {
00105     const FieldDescription *desc =getType().findFieldDescription(fieldName);
00106 
00107     return desc ? desc->getField(*this) : NULL;
00108 }


Public Types
typedef DVRSimpleShaderPtr	Ptr
enum	{ NextFieldId = 1 }
Public Member Functions
Sync
*virtual void	changed (BitVector whichField, UInt32 from)
	react to field changes
Output
*virtual void	dump (UInt32 uiIndent=0, const BitVector bvFlags=0) const
	output the instance for debug purposes
Volume Rendering
*virtual bool	initialize (DVRVolume volume, DrawActionBase action)
	Callback to set up shader - register textures here.
virtual void	activate (DVRVolume volume, DrawActionBase action)
	Callback before any slice is rendered - setup per volume.
virtual void	brickActivate (DVRVolume volume, DrawActionBase action, Brick *brick)
	Callback before any brick - state setup per brick.
virtual void	deactivate (DVRVolume volume, DrawActionBase action)
	Callback after all rendering of the volume is done.
virtual void	cleanup (DVRVolume volume, DrawActionBase action)
	Callback to clean up shader resources.
FieldContainer Get
*virtual FieldContainerType &	getType (void)
virtual const FieldContainerType &	getType (void) const
virtual UInt32	getContainerSize (void) const
Binary Access
*virtual UInt32	getBinSize (const BitVector &whichField)
virtual void	copyToBin (BinaryDataHandler &pMem, const BitVector &whichField)
virtual void	copyFromBin (BinaryDataHandler &pMem, const BitVector &whichField)
Copy
*virtual FieldContainerPtr	shallowCopy (void) const
Volume Rendering
virtual void	renderSlice (DVRVolume volume, DrawActionBase action, Real32 *data, UInt32 vertices, UInt32 values)
virtual void	renderSlice (DVRVolume volume, DrawActionBase action, DVRRenderSlice *clippedSlice)
virtual bool	hasRenderCallback (void)
virtual bool	useMTSlabs (void)
Static Public Member Functions
Class Get
*static FieldContainerType &	getClassType (void)
	access the type of the class
static UInt32	getClassTypeId (void)
	access the numerical type of the class
Construction
*static DVRSimpleShaderPtr	create (void)
	create a new instance of the class
static DVRSimpleShaderPtr	createEmpty (void)
	create an empty new instance of the class, do not copy the prototype
Static Public Attributes
static const osg::BitVector	MTInfluenceMask
static const BitVector	NextFieldMask
Protected Member Functions
Constructors
*	DVRSimpleShader (void)
	Constructor.
	DVRSimpleShader (const DVRSimpleShader &source)
	Copy Constructor.
Destructors
*virtual	~DVRSimpleShader (void)
	Destructor.
Sync
*void	executeSyncImpl (DVRSimpleShaderBase *pOther, const BitVector &whichField)
virtual void	executeSync (FieldContainer &other, const BitVector &whichField)
Sync
*void	executeSyncImpl (DVRShaderBase *pOther, const BitVector &whichField)
Protected Attributes
Int32	m_nTextureId
Private Types
typedef DVRSimpleShaderBase	Inherited
Private Member Functions
void	operator= (const DVRSimpleShader &source)
Static Private Member Functions
static void	initMethod (void)
	initialize the static features of the class, e.g. action callbacks
Friends
class	FieldContainer
class	DVRSimpleShaderBase

osg::DVRSimpleShader Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation