osg::CubeTextureChunk Class Reference
[OpenGL State Handling]

State chunk for cubic textures. See CubeTextureChunk for a description. More...

#include <OSGCubeTextureChunk.h>

Inheritance diagram for osg::CubeTextureChunk:

Detailed Description

See CubeTextureChunk for a description.

The CubeTexture is defined by 6 separate texture images. As it is derived from the standard texture chunk it already has an image, which is used for the negative Z direction. The other 5 images are stored in variables that are named according to the direction they represent (osg::CubeTextureChunk::_sfPosZImage, osg::CubeTextureChunk::_sfNegYImage, osg::CubeTextureChunk::_sfPosYImage, osg::CubeTextureChunk::_sfNegXImage, osg::CubeTextureChunk::_sfPosXImage).

Definition at line 56 of file OSGCubeTextureChunk.h.

Member Typedef Documentation

typedef CubeTextureChunkBase osg::CubeTextureChunk::Inherited [private]

Reimplemented from osg::CubeTextureChunkBase.

Definition at line 162 of file OSGCubeTextureChunk.h.

typedef CubeTextureChunkPtr osg::CubeTextureChunkBase::Ptr [inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 95 of file OSGCubeTextureChunkBase.h.

Member Enumeration Documentation

anonymous enum [inherited]

Enumerator:

PosZImageFieldId
PosXImageFieldId
NegXImageFieldId
PosYImageFieldId
NegYImageFieldId
IsReflectionMapFieldId
NextFieldId

Definition at line 97 of file OSGCubeTextureChunkBase.h.

00098     {
00099         PosZImageFieldId       = Inherited::NextFieldId,
00100         PosXImageFieldId       = PosZImageFieldId       + 1,
00101         NegXImageFieldId       = PosXImageFieldId       + 1,
00102         PosYImageFieldId       = NegXImageFieldId       + 1,
00103         NegYImageFieldId       = PosYImageFieldId       + 1,
00104         IsReflectionMapFieldId = NegYImageFieldId       + 1,
00105         NextFieldId            = IsReflectionMapFieldId + 1
00106     };

enum osg::TextureChunk::NPOTMatrixScaleE [inherited]

Enumerator:

None_TT
NPotTexScale_TT
XFlip_TT
YFlip_TT
ZFlip_TT

Definition at line 66 of file OSGTextureChunk.h.

00067     { 
00068         None_TT = 0, 
00069         NPotTexScale_TT = 1, 
00070         XFlip_TT = 2, 
00071         YFlip_TT = 4, 
00072         ZFlip_TT = 8 
00073     };

anonymous enum [inherited]

Enumerator:

ImageFieldId
InternalFormatFieldId
ExternalFormatFieldId
ScaleFieldId
FrameFieldId
MinFilterFieldId
MagFilterFieldId
WrapSFieldId
WrapTFieldId
WrapRFieldId
EnvModeFieldId
EnvColorFieldId
EnvCombineRGBFieldId
EnvCombineAlphaFieldId
EnvScaleRGBFieldId
EnvScaleAlphaFieldId
EnvSource0RGBFieldId
EnvSource1RGBFieldId
EnvSource2RGBFieldId
EnvSource0AlphaFieldId
EnvSource1AlphaFieldId
EnvSource2AlphaFieldId
EnvOperand0RGBFieldId
EnvOperand1RGBFieldId
EnvOperand2RGBFieldId
EnvOperand0AlphaFieldId
EnvOperand1AlphaFieldId
EnvOperand2AlphaFieldId
GLIdFieldId
IgnoreGLForAspectFieldId
PointSpriteFieldId
PriorityFieldId
ShaderOperationFieldId
ShaderInputFieldId
ShaderOffsetMatrixFieldId
ShaderOffsetScaleFieldId
ShaderOffsetBiasFieldId
ShaderRGBADotProductFieldId
ShaderCullModesFieldId
ShaderConstEyeFieldId
LodBiasFieldId
TargetFieldId
DirtyLeftFieldId
DirtyMinXFieldId
DirtyMaxXFieldId
DirtyMinYFieldId
DirtyMaxYFieldId
DirtyMinZFieldId
DirtyMaxZFieldId
AnisotropyFieldId
BorderColorFieldId
BorderWidthFieldId
NPOTMatrixScaleFieldId
NextFieldId

Definition at line 144 of file OSGTextureChunkBase.h.

00145     {
00146         ImageFieldId                = Inherited::NextFieldId,
00147         InternalFormatFieldId       = ImageFieldId                + 1,
00148         ExternalFormatFieldId       = InternalFormatFieldId       + 1,
00149         ScaleFieldId                = ExternalFormatFieldId       + 1,
00150         FrameFieldId                = ScaleFieldId                + 1,
00151         MinFilterFieldId            = FrameFieldId                + 1,
00152         MagFilterFieldId            = MinFilterFieldId            + 1,
00153         WrapSFieldId                = MagFilterFieldId            + 1,
00154         WrapTFieldId                = WrapSFieldId                + 1,
00155         WrapRFieldId                = WrapTFieldId                + 1,
00156         EnvModeFieldId              = WrapRFieldId                + 1,
00157         EnvColorFieldId             = EnvModeFieldId              + 1,
00158         EnvCombineRGBFieldId        = EnvColorFieldId             + 1,
00159         EnvCombineAlphaFieldId      = EnvCombineRGBFieldId        + 1,
00160         EnvScaleRGBFieldId          = EnvCombineAlphaFieldId      + 1,
00161         EnvScaleAlphaFieldId        = EnvScaleRGBFieldId          + 1,
00162         EnvSource0RGBFieldId        = EnvScaleAlphaFieldId        + 1,
00163         EnvSource1RGBFieldId        = EnvSource0RGBFieldId        + 1,
00164         EnvSource2RGBFieldId        = EnvSource1RGBFieldId        + 1,
00165         EnvSource0AlphaFieldId      = EnvSource2RGBFieldId        + 1,
00166         EnvSource1AlphaFieldId      = EnvSource0AlphaFieldId      + 1,
00167         EnvSource2AlphaFieldId      = EnvSource1AlphaFieldId      + 1,
00168         EnvOperand0RGBFieldId       = EnvSource2AlphaFieldId      + 1,
00169         EnvOperand1RGBFieldId       = EnvOperand0RGBFieldId       + 1,
00170         EnvOperand2RGBFieldId       = EnvOperand1RGBFieldId       + 1,
00171         EnvOperand0AlphaFieldId     = EnvOperand2RGBFieldId       + 1,
00172         EnvOperand1AlphaFieldId     = EnvOperand0AlphaFieldId     + 1,
00173         EnvOperand2AlphaFieldId     = EnvOperand1AlphaFieldId     + 1,
00174         GLIdFieldId                 = EnvOperand2AlphaFieldId     + 1,
00175         IgnoreGLForAspectFieldId    = GLIdFieldId                 + 1,
00176         PointSpriteFieldId          = IgnoreGLForAspectFieldId    + 1,
00177         PriorityFieldId             = PointSpriteFieldId          + 1,
00178         ShaderOperationFieldId      = PriorityFieldId             + 1,
00179         ShaderInputFieldId          = ShaderOperationFieldId      + 1,
00180         ShaderOffsetMatrixFieldId   = ShaderInputFieldId          + 1,
00181         ShaderOffsetScaleFieldId    = ShaderOffsetMatrixFieldId   + 1,
00182         ShaderOffsetBiasFieldId     = ShaderOffsetScaleFieldId    + 1,
00183         ShaderRGBADotProductFieldId = ShaderOffsetBiasFieldId     + 1,
00184         ShaderCullModesFieldId      = ShaderRGBADotProductFieldId + 1,
00185         ShaderConstEyeFieldId       = ShaderCullModesFieldId      + 1,
00186         LodBiasFieldId              = ShaderConstEyeFieldId       + 1,
00187         TargetFieldId               = LodBiasFieldId              + 1,
00188         DirtyLeftFieldId            = TargetFieldId               + 1,
00189         DirtyMinXFieldId            = DirtyLeftFieldId            + 1,
00190         DirtyMaxXFieldId            = DirtyMinXFieldId            + 1,
00191         DirtyMinYFieldId            = DirtyMaxXFieldId            + 1,
00192         DirtyMaxYFieldId            = DirtyMinYFieldId            + 1,
00193         DirtyMinZFieldId            = DirtyMaxYFieldId            + 1,
00194         DirtyMaxZFieldId            = DirtyMinZFieldId            + 1,
00195         AnisotropyFieldId           = DirtyMaxZFieldId            + 1,
00196         BorderColorFieldId          = AnisotropyFieldId           + 1,
00197         BorderWidthFieldId          = BorderColorFieldId          + 1,
00198         NPOTMatrixScaleFieldId      = BorderWidthFieldId          + 1,
00199         NextFieldId                 = NPOTMatrixScaleFieldId      + 1
00200     };

anonymous enum [inherited]

Enumerator:

IgnoreFieldId
NextFieldId

Definition at line 92 of file OSGStateChunkBase.h.

00093     {
00094         IgnoreFieldId = Inherited::NextFieldId,
00095         NextFieldId   = IgnoreFieldId + 1
00096     };

anonymous enum [inherited]

Enumerator:

ParentsFieldId
InternalFieldId
NextFieldId

Definition at line 86 of file OSGAttachmentImpl.h.

00087     { 
00088         ParentsFieldId     = Inherited::NextFieldId, 
00089         InternalFieldId    = ParentsFieldId  + 1,
00090         NextFieldId        = InternalFieldId + 1
00091     };

anonymous enum [inherited]

Enumerator:

NextFieldId

Definition at line 73 of file OSGFieldContainerImpl.h.

00073 { NextFieldId = 1 };

Constructor & Destructor Documentation

CubeTextureChunk::CubeTextureChunk ( void ) [protected]

Definition at line 89 of file OSGCubeTextureChunk.cpp.

00089                                        :
00090     Inherited()
00091 {
00092 }

CubeTextureChunk::CubeTextureChunk ( const CubeTextureChunk & source ) [protected]

Definition at line 94 of file OSGCubeTextureChunk.cpp.

00094                                                                  :
00095     Inherited(source)
00096 {
00097 }

CubeTextureChunk::~CubeTextureChunk ( void ) [protected, virtual]

Definition at line 99 of file OSGCubeTextureChunk.cpp.

00100 {
00101 }

Member Function Documentation

const StateChunkClass * CubeTextureChunk::getClass ( void ) const [virtual]

Reimplemented from osg::TextureChunk.

Definition at line 105 of file OSGCubeTextureChunk.cpp.

References osg::TextureChunk::getClass().

00106 {
00107     return TextureChunk::getClass();
00108 }

UInt32 osg::CubeTextureChunk::getStaticClassId ( void ) [inline, static]

Reimplemented from osg::TextureChunk.

Definition at line 46 of file OSGCubeTextureChunk.inl.

References osg::StateChunkClass::getId(), and getStaticClass().

00047 {
00048     return getStaticClass()->getId();
00049 }

const StateChunkClass * osg::CubeTextureChunk::getStaticClass ( void ) [inline, static]

Reimplemented from osg::TextureChunk.

Definition at line 52 of file OSGCubeTextureChunk.inl.

References osg::TextureChunk::_class.

Referenced by getStaticClassId().

00053 {
00054     return &TextureChunk::_class;
00055 }

void CubeTextureChunk::changed	(	BitVector	whichField,
		UInt32	origin
	)			`[virtual]`

Reimplemented from osg::TextureChunk.

Definition at line 112 of file OSGCubeTextureChunk.cpp.

00113 {
00114     if(whichField & PosZImageFieldMask)
00115     {
00116         if(origin & ChangedOrigin::Abstract)
00117         {
00118             if(origin & ChangedOrigin::AbstrIncRefCount)
00119             {
00120                 addRefCP(_sfPosZImage.getValue());
00121             }
00122             else
00123             {
00124                 ImagePtr pImage = _sfPosZImage.getValue();
00125 
00126                 _sfPosZImage.setValue(NullFC);
00127 
00128                 setPosZImage(pImage);
00129             }
00130         }
00131     }
00132 
00133     if(whichField & PosXImageFieldMask)
00134     {
00135         if(origin & ChangedOrigin::Abstract)
00136         {
00137             if(origin & ChangedOrigin::AbstrIncRefCount)
00138             {
00139                 addRefCP(_sfPosXImage.getValue());
00140             }
00141             else
00142             {
00143                 ImagePtr pImage = _sfPosXImage.getValue();
00144 
00145                 _sfPosXImage.setValue(NullFC);
00146 
00147                 setPosXImage(pImage);
00148             }
00149         }
00150     }
00151     
00152     if(whichField & NegXImageFieldMask)
00153     {
00154         if(origin & ChangedOrigin::Abstract)
00155         {
00156             if(origin & ChangedOrigin::AbstrIncRefCount)
00157             {
00158                 addRefCP(_sfNegXImage.getValue());
00159             }
00160             else
00161             {
00162                 ImagePtr pImage = _sfNegXImage.getValue();
00163 
00164                 _sfNegXImage.setValue(NullFC);
00165 
00166                 setNegXImage(pImage);
00167             }
00168         }
00169     }
00170     
00171     if(whichField & PosYImageFieldMask)
00172     {
00173         if(origin & ChangedOrigin::Abstract)
00174         {
00175             if(origin & ChangedOrigin::AbstrIncRefCount)
00176             {
00177                 addRefCP(_sfPosYImage.getValue());
00178             }
00179             else
00180             {
00181                 ImagePtr pImage = _sfPosYImage.getValue();
00182 
00183                 _sfPosYImage.setValue(NullFC);
00184 
00185                 setPosYImage(pImage);
00186             }
00187         }
00188     }
00189     
00190     if(whichField & NegYImageFieldMask)
00191     {
00192         if(origin & ChangedOrigin::Abstract)
00193         {
00194             if(origin & ChangedOrigin::AbstrIncRefCount)
00195             {
00196                 addRefCP(_sfNegYImage.getValue());
00197             }
00198             else
00199             {
00200                 ImagePtr pImage = _sfNegYImage.getValue();
00201 
00202                 _sfNegYImage.setValue(NullFC);
00203 
00204                 setNegYImage(pImage);
00205             }
00206         }
00207     }
00208     Inherited::changed(whichField, origin);
00209 }

void CubeTextureChunk::dump	(	UInt32	uiIndent = `0`,
		const BitVector	bvFlags = `0`
	)			const `[virtual]`

Reimplemented from osg::TextureChunk.

Definition at line 257 of file OSGCubeTextureChunk.cpp.

References SLOG.

00259 {
00260     SLOG << "Dump CubeTextureChunk NI" << std::endl;
00261 }

void CubeTextureChunk::activate	(	DrawActionBase *	action,
		UInt32	index = `0`
	)			`[virtual]`

Reimplemented from osg::TextureChunk.

Definition at line 371 of file OSGCubeTextureChunk.cpp.

Referenced by changeFrom().

00372 {   
00373     // does the window support cubemaps?
00374     if(action->getWindow()->hasExtension(_arbCubeTex) == false)
00375         return;
00376         
00377     Window *win = action->getWindow();
00378     
00379     Real32 nteximages, ntexcoords;
00380     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
00381        Window::unknownConstant
00382       )
00383     {
00384         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00385         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
00386         if(nteximages == Window::unknownConstant)
00387             nteximages = 1.0f;
00388     }
00389     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
00390        Window::unknownConstant
00391       )
00392     {
00393         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00394         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
00395         if(ntexcoords == Window::unknownConstant)
00396             ntexcoords = 1.0f;
00397     }
00398 
00399     if(idx >= static_cast<UInt32>(nteximages))
00400     {
00401 #ifdef OSG_DEBUG
00402         FWARNING(("CubeTextureChunk::activate: Trying to bind image unit %d,"
00403                   " but Window %p only supports %d!\n",
00404                   idx, win, nteximages));
00405 #endif
00406         return;        
00407     }
00408     
00409     TextureChunk::activateTexture(win, idx);
00410     
00411     win->validateGLObject(getGLId());
00412 
00413     glErr("CubeTextureChunk::activate precheck");
00414   
00415     FDEBUG(("CubeTextureChunk::activate - %d\n", getGLId()));
00416 
00417     action->getStatistics()->getElem(RenderAction::statNTextures)->inc(idx);
00418     // all 6 images are forced (by opengl) to be of the same size and type so we can
00419     // multiply the size of the first image by 6.
00420     if(getImage() != NullFC)
00421     {
00422         action->getStatistics()->getElem(RenderAction::statNTexBytes)->add(
00423             getGLId(), getImage()->getSize() * 6);
00424     }
00425 
00426     glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, win->getGLObjectId(getGLId()));
00427 
00428 #ifdef GL_NV_point_sprite
00429     if(idx < static_cast<UInt32>(ntexcoords))
00430     {
00431         if(getPointSprite() &&
00432            win->hasExtension(_nvPointSprite))
00433         {
00434             glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_TRUE);
00435         }
00436     }
00437 #endif
00438 
00439     if(idx < static_cast<UInt32>(nteximages))
00440     {
00441         if(getLodBias() != 0.0f &&
00442            win->hasExtension(_extTextureLodBias))
00443         {
00444             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
00445                   getLodBias());
00446         }
00447     }
00448 
00449     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00450 
00451     // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
00452     if(ntexunits == Window::unknownConstant)
00453         ntexunits = 1.0f;
00454 
00455     if(idx < static_cast<UInt32>(ntexunits))
00456     {
00457         // texture env
00458         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
00459         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
00460                     (GLfloat*)getEnvColor().getValuesRGBA());
00461 
00462         if(getEnvMode() == GL_COMBINE_EXT)
00463         {
00464             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT,  getEnvCombineRGB ());
00465             glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,    getEnvScaleRGB   ());
00466             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT,  getEnvSource0RGB ());
00467             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT,  getEnvSource1RGB ());
00468             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT,  getEnvSource2RGB ());
00469             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, getEnvOperand0RGB());
00470             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, getEnvOperand1RGB());
00471             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, getEnvOperand2RGB());
00472 
00473             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, getEnvCombineAlpha ());
00474             glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE,       getEnvScaleAlpha   ());
00475             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, getEnvSource0Alpha ());
00476             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, getEnvSource1Alpha ());
00477             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, getEnvSource2Alpha ());
00478             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT,getEnvOperand0Alpha());
00479             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT,getEnvOperand1Alpha());
00480             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT,getEnvOperand2Alpha());
00481         }
00482 
00483         TextureChunk::handleTextureShader(win, GL_TEXTURE_CUBE_MAP_ARB);
00484 
00485         if(getShaderOperation() != GL_NONE &&
00486            win->hasExtension(_nvTextureShader) &&
00487            idx == 0)
00488         {
00489             glEnable(GL_TEXTURE_SHADER_NV);
00490         }
00491         glEnable(GL_TEXTURE_CUBE_MAP_ARB);
00492     }
00493     
00494     glErr("CubeTextureChunk::activate");
00495 }

void CubeTextureChunk::changeFrom	(	DrawActionBase *	action,
		StateChunk *	old,
		UInt32	index = `0`
	)			`[virtual]`

Reimplemented from osg::TextureChunk.

Definition at line 497 of file OSGCubeTextureChunk.cpp.

00500 {
00501     // does the window support cubemaps?
00502     if(action->getWindow()->hasExtension(_arbCubeTex) == false)
00503         return;
00504         
00505     // change from me to me?
00506     // this assumes I haven't changed in the meantime. 
00507     // is that a valid assumption?
00508     if(old == this)
00509         return;
00510     
00511     // If the old one is not a cube texture chunk, deactivate it and
00512     // activate ourselves
00513     if(getTypeId() != old->getTypeId())
00514     {
00515         old->deactivate(action, idx);
00516         activate(action, idx);
00517         return;
00518     }
00519 
00520     CubeTextureChunk *oldp      = dynamic_cast<CubeTextureChunk *>(old);
00521 
00522     glErr("CubeTextureChunk::changeFrom precheck");
00523 
00524     Window *win = action->getWindow();   
00525 
00526     if(TextureChunk::activateTexture(win, idx))
00527         return; // trying to use too many textures
00528 
00529     UInt32 nteximages, ntexcoords, ntexunits;
00530     
00531     Real32 dummy = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00532 
00533     if(dummy == Window::unknownConstant)
00534     {
00535         ntexunits = 1;
00536     }
00537     else
00538     {
00539         ntexunits = static_cast<UInt32>(dummy);
00540     }
00541 
00542     if((dummy = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
00543        Window::unknownConstant
00544       )
00545     {
00546         nteximages = ntexunits;
00547     }
00548     else
00549     {
00550         nteximages = static_cast<UInt32>(dummy);
00551     }
00552     
00553     if((dummy = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
00554        Window::unknownConstant
00555       )
00556     {
00557         ntexcoords = ntexunits;
00558     }
00559     else
00560     {
00561         ntexcoords = static_cast<UInt32>(dummy);
00562     }
00563 
00564     if(idx >= nteximages)
00565     {
00566 #ifdef OSG_DEBUG
00567         FWARNING(("TextureChunk::activate: Trying to bind image unit %d,"
00568                   " but Window %p only supports %d!\n",
00569                   idx, win, nteximages));
00570 #endif
00571         return;        
00572     }
00573 
00574     win->validateGLObject(getGLId());
00575     
00576     FDEBUG(("CubeTextureChunk::activate - %d\n", getGLId()));
00577 
00578     action->getStatistics()->getElem(RenderAction::statNTextures)->inc(getGLId());
00579     // all 6 images are forced (by opengl) to be of the same size and type so we can
00580     // multiply the size of the first image by 6.
00581     if(getImage() != NullFC)
00582     {
00583         action->getStatistics()->getElem(RenderAction::statNTexBytes)->add(
00584             getGLId(), getImage()->getSize() * 6);
00585     }
00586 
00587     glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, win->getGLObjectId(getGLId()));
00588 
00589 #ifdef GL_NV_point_sprite
00590     if(idx < ntexcoords)
00591     {
00592         if(oldp->getPointSprite() != getPointSprite() &&
00593            win->hasExtension(_nvPointSprite)
00594           )
00595         {
00596             glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, getPointSprite());
00597         }
00598     }
00599 #endif
00600 
00601     if(idx < nteximages)
00602     {
00603         if(oldp->getLodBias() != getLodBias() &&
00604            win->hasExtension(_extTextureLodBias)
00605           )
00606         {
00607             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
00608                   getLodBias());
00609         }
00610     }
00611 
00612     if(idx < ntexunits)
00613     {
00614         if(oldp->getEnvMode() != getEnvMode())
00615             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
00616 
00617         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
00618                         (GLfloat*)getEnvColor().getValuesRGBA());
00619 
00620         if(getEnvMode() == GL_COMBINE_EXT)
00621         {
00622             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT,  getEnvCombineRGB ());
00623             glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,    getEnvScaleRGB   ());
00624             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT,  getEnvSource0RGB ());
00625             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT,  getEnvSource1RGB ());
00626             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT,  getEnvSource2RGB ());
00627             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, getEnvOperand0RGB());
00628             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, getEnvOperand1RGB());
00629             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, getEnvOperand2RGB());
00630 
00631             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, getEnvCombineAlpha ());
00632             glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE,       getEnvScaleAlpha   ());
00633             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, getEnvSource0Alpha ());
00634             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, getEnvSource1Alpha ());
00635             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, getEnvSource2Alpha ());
00636             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT,getEnvOperand0Alpha());
00637             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT,getEnvOperand1Alpha());
00638             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT,getEnvOperand2Alpha());
00639         }
00640 
00641         if(win->hasExtension(_nvTextureShader))
00642         {
00643             if(      getShaderOperation() != GL_NONE &&
00644                oldp->getShaderOperation() == GL_NONE
00645               )
00646             {
00647                 handleTextureShader(win, GL_TEXTURE_CUBE_MAP_ARB);
00648                 if(idx == 0)
00649                     glEnable(GL_TEXTURE_SHADER_NV);
00650             }
00651             else if(      getShaderOperation() == GL_NONE &&
00652                     oldp->getShaderOperation() != GL_NONE
00653                    )
00654             {
00655                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
00656                 if(idx == 0)
00657                     glDisable(GL_TEXTURE_SHADER_NV);
00658             }
00659         }
00660     }
00661 
00662     glErr("CubeTextureChunk::changeFrom");
00663 }

void CubeTextureChunk::deactivate	(	DrawActionBase *	action,
		UInt32	index = `0`
	)			`[virtual]`

Reimplemented from osg::TextureChunk.

Definition at line 665 of file OSGCubeTextureChunk.cpp.

References osg::TextureChunk::_arbCubeTex, osg::TextureChunk::_extTextureLodBias, osg::TextureChunk::_nvPointSprite, osg::TextureChunk::_nvTextureShader, osg::TextureChunk::activateTexture(), FWARNING, osg::Window::getConstantValue(), osg::TextureChunkBase::getLodBias(), osg::TextureChunkBase::getPointSprite(), osg::TextureChunkBase::getShaderOperation(), osg::DrawActionBase::getWindow(), GL_COORD_REPLACE_NV, GL_MAX_TEXTURE_COORDS_ARB, GL_MAX_TEXTURE_IMAGE_UNITS_ARB, GL_MAX_TEXTURE_UNITS_ARB, GL_POINT_SPRITE_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, GL_TEXTURE_SHADER_NV, glErr, osg::Window::hasExtension(), and osg::Window::unknownConstant.

00666 {
00667     // does the window support cubemaps?
00668     if(action->getWindow()->hasExtension(_arbCubeTex) == false)
00669         return;
00670         
00671     Window *win = action->getWindow();   
00672 
00673     Real32 nteximages, ntexcoords;
00674     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
00675        Window::unknownConstant
00676       )
00677     {
00678         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00679         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
00680         if(nteximages == Window::unknownConstant)
00681             nteximages = 1.0f;
00682     }
00683     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
00684        Window::unknownConstant
00685       )
00686     {
00687         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00688         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
00689         if(ntexcoords == Window::unknownConstant)
00690             ntexcoords = 1.0f;
00691     }
00692 
00693     if(idx >= static_cast<UInt32>(nteximages))
00694     {
00695 #ifdef OSG_DEBUG
00696         FWARNING(("CubeTextureChunk::deactivate: Trying to bind image unit %d,"
00697                   " but Window %p only supports %d!\n",
00698                   idx, win, nteximages));
00699 #endif
00700         return;        
00701     }
00702 
00703 
00704     bool isActive = false;
00705 
00706 #ifdef GL_NV_point_sprite
00707     if(getPointSprite() &&
00708        win->hasExtension(_nvPointSprite) &&
00709        idx < static_cast<UInt32>(ntexcoords)
00710       )
00711     {
00712         if(!isActive)
00713         {
00714             TextureChunk::activateTexture(win, idx);
00715             isActive = true;
00716         }
00717         glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_FALSE);
00718     }
00719 #endif
00720 
00721     if(getLodBias() != 0.0f &&
00722        win->hasExtension(_extTextureLodBias))
00723     {
00724         if(!isActive)
00725             TextureChunk::activateTexture(win, idx);
00726         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
00727               0.0f);
00728     }
00729 
00730     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
00731     if(ntexunits == Window::unknownConstant)
00732         ntexunits = 1.0f;
00733 
00734     if(idx >= static_cast<UInt32>(ntexunits))
00735         return; // tetxures >= MTU are not enabled and don't have an env
00736         
00737     if(!isActive)
00738         TextureChunk::activateTexture(win, idx);
00739 
00740     if(getShaderOperation() != GL_NONE &&
00741        win->hasExtension(_nvTextureShader))
00742     {
00743         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
00744 
00745         if(idx == 0)
00746             glDisable(GL_TEXTURE_SHADER_NV);
00747     }
00748 
00749     glDisable(GL_TEXTURE_CUBE_MAP_ARB);
00750 
00751     glErr("CubeTextureChunk::deactivate");
00752 }

Real32 CubeTextureChunk::switchCost ( StateChunk * chunk ) [virtual]

Reimplemented from osg::TextureChunk.

Definition at line 756 of file OSGCubeTextureChunk.cpp.

00757 {
00758     return 0;
00759 }

bool CubeTextureChunk::operator< ( const StateChunk & other ) const [virtual]

Reimplemented from osg::TextureChunk.

Definition at line 761 of file OSGCubeTextureChunk.cpp.

00762 {
00763     return this < &other;
00764 }

bool CubeTextureChunk::operator== ( const StateChunk & other ) const [virtual]

Reimplemented from osg::TextureChunk.

Definition at line 766 of file OSGCubeTextureChunk.cpp.

References osg::CubeTextureChunkBase::getNegXImage(), osg::CubeTextureChunkBase::getNegYImage(), osg::CubeTextureChunkBase::getPosXImage(), osg::CubeTextureChunkBase::getPosYImage(), osg::CubeTextureChunkBase::getPosZImage(), and osg::operator==().

00767 {
00768     CubeTextureChunk const *tother = 
00769             dynamic_cast<CubeTextureChunk const*>(&other);
00770 
00771     if(!tother)
00772         return false;
00773 
00774     if(tother == this)
00775         return true;
00776 
00777     return  TextureChunk::operator==(other) &&
00778             getPosZImage()  == tother->getPosZImage() &&
00779             getPosYImage()  == tother->getPosYImage() &&
00780             getNegYImage()  == tother->getNegYImage() &&
00781             getPosXImage()  == tother->getPosXImage() &&
00782             getNegXImage()  == tother->getNegXImage();
00783 }

bool CubeTextureChunk::operator!= ( const StateChunk & other ) const [virtual]

Reimplemented from osg::TextureChunk.

Definition at line 785 of file OSGCubeTextureChunk.cpp.

00786 {
00787     return ! (*this == other);
00788 }

void osg::CubeTextureChunk::setPosZImage ( ImagePtr & value ) [inline]

Definition at line 58 of file OSGCubeTextureChunk.inl.

References osg::CubeTextureChunkBase::_sfPosZImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by changed().

00059 {
00060      addRefCP(pImage);
00061 
00062      subRefCP(_sfPosZImage.getValue());
00063 
00064     _sfPosZImage.setValue(pImage);
00065 }

void osg::CubeTextureChunk::setPosXImage ( ImagePtr & value ) [inline]

Definition at line 68 of file OSGCubeTextureChunk.inl.

References osg::CubeTextureChunkBase::_sfPosXImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by changed().

00069 {
00070      addRefCP(pImage);
00071 
00072      subRefCP(_sfPosXImage.getValue());
00073 
00074     _sfPosXImage.setValue(pImage);
00075 }

void osg::CubeTextureChunk::setNegXImage ( ImagePtr & value ) [inline]

Definition at line 78 of file OSGCubeTextureChunk.inl.

References osg::CubeTextureChunkBase::_sfNegXImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by changed().

00079 {
00080      addRefCP(pImage);
00081 
00082      subRefCP(_sfNegXImage.getValue());
00083 
00084     _sfNegXImage.setValue(pImage);
00085 }

void osg::CubeTextureChunk::setPosYImage ( ImagePtr & value ) [inline]

Definition at line 88 of file OSGCubeTextureChunk.inl.

References osg::CubeTextureChunkBase::_sfPosYImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by changed().

00089 {
00090      addRefCP(pImage);
00091 
00092      subRefCP(_sfPosYImage.getValue());
00093 
00094     _sfPosYImage.setValue(pImage);
00095 }

void osg::CubeTextureChunk::setNegYImage ( ImagePtr & value ) [inline]

Definition at line 98 of file OSGCubeTextureChunk.inl.

References osg::CubeTextureChunkBase::_sfNegYImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by changed().

00099 {
00100      addRefCP(pImage);
00101 
00102      subRefCP(_sfNegYImage.getValue());
00103 
00104     _sfNegYImage.setValue(pImage);
00105 }

void CubeTextureChunk::onCreate ( const CubeTextureChunk * source = NULL ) [protected]

Definition at line 213 of file OSGCubeTextureChunk.cpp.

References osg::beginEditCP(), osg::endEditCP(), osg::TextureChunkBase::GLIdFieldMask, osg::GlobalSystemState, handleGL(), osg::osgTypedMethodVoidFunctor2ObjCPtrPtr(), osg::Window::registerGLObject(), osg::TextureChunkBase::setGLId(), and osg::Startup.

00214 {
00215     if(GlobalSystemState == Startup)
00216         return;
00217 
00218     // !!! this temporary is needed to work around compiler problems (sgi)
00219     // CHECK CHECK
00220     //  TextureChunkPtr tmpPtr = FieldContainer::getPtr<TextureChunkPtr>(*this);
00221     CubeTextureChunkPtr tmpPtr(*this);
00222 
00223     beginEditCP(tmpPtr, CubeTextureChunk::GLIdFieldMask);
00224 
00225     setGLId(
00226         Window::registerGLObject(
00227             osgTypedMethodVoidFunctor2ObjCPtrPtr<CubeTextureChunkPtr, 
00228                                                  Window , 
00229                                                  UInt32>(
00230                                                 tmpPtr, 
00231                                                 &CubeTextureChunk::handleGL),
00232             1));
00233 
00234     endEditCP(tmpPtr, CubeTextureChunk::GLIdFieldMask);
00235 }

void CubeTextureChunk::onDestroy ( void ) [protected, virtual]

Reimplemented from osg::TextureChunk.

Definition at line 237 of file OSGCubeTextureChunk.cpp.

References osg::CubeTextureChunkBase::_sfNegXImage, osg::CubeTextureChunkBase::_sfNegYImage, osg::CubeTextureChunkBase::_sfPosXImage, osg::CubeTextureChunkBase::_sfPosYImage, osg::CubeTextureChunkBase::_sfPosZImage, osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::NullFC, osg::TextureChunk::onDestroy(), and osg::subRefCP().

00238 {
00239     Inherited::onDestroy();
00240 
00241     if(_sfPosZImage.getValue() != NullFC)
00242         subRefCP(_sfPosZImage.getValue());
00243 
00244     if(_sfPosXImage.getValue() != NullFC)
00245         subRefCP(_sfPosXImage.getValue());
00246     if(_sfNegXImage.getValue() != NullFC)
00247         subRefCP(_sfNegXImage.getValue());
00248 
00249     if(_sfPosYImage.getValue() != NullFC)
00250         subRefCP(_sfPosYImage.getValue());
00251     if(_sfNegYImage.getValue() != NullFC)
00252         subRefCP(_sfNegYImage.getValue());
00253 }

void CubeTextureChunk::handleGL	(	Window *	win,
		UInt32	id
	)			`[private]`

Reimplemented from osg::TextureChunk.

Definition at line 266 of file OSGCubeTextureChunk.cpp.

References osg::TextureChunk::_arbCubeTex, osg::Window::destroy, osg::Window::finaldestroy, osg::Window::getGLObjectId(), osg::TextureChunkBase::getImage(), osg::CubeTextureChunkBase::getNegXImage(), osg::CubeTextureChunkBase::getNegYImage(), osg::CubeTextureChunkBase::getPosXImage(), osg::CubeTextureChunkBase::getPosYImage(), osg::CubeTextureChunkBase::getPosZImage(), GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, GLuint(), osg::TextureChunk::handleTexture(), osg::Window::hasExtension(), osg::Window::initialize, osg::Window::needrefresh, osg::Window::reinitialize, osg::Window::setGLObjectId(), SWARNING, and osg::Window::unpackIdStatus().

Referenced by onCreate().

00267 {
00268     Window::GLObjectStatusE mode;
00269     UInt32 osgid;
00270     GLuint id;
00271     
00272     // does the window support cubemaps?
00273     if(win->hasExtension(_arbCubeTex) == false)
00274         return;
00275         
00276     Window::unpackIdStatus(idstatus, osgid, mode);
00277 
00278     id = win->getGLObjectId(osgid);
00279     
00280     if(mode == Window::destroy)
00281     {
00282         glDeleteTextures(1, &id);
00283     }
00284     else if(mode == Window::finaldestroy)
00285     {
00286         //SWARNING << "Last texture user destroyed" << std::endl;
00287     }
00288     else if(mode == Window::initialize || mode == Window::reinitialize)
00289     {
00290         if(mode == Window::initialize)
00291         {
00292             glGenTextures(1, &id);
00293             win->setGLObjectId(osgid, id);
00294         }
00295 
00296         handleTexture(win, id, 
00297                       GL_TEXTURE_CUBE_MAP_ARB, 
00298                       GL_TEXTURE_CUBE_MAP_ARB, 
00299                       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 
00300                       mode, getImage());        
00301         handleTexture(win, id, 
00302                       GL_TEXTURE_CUBE_MAP_ARB, 
00303                       GL_NONE, 
00304                       GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 
00305                       Window::initialize, getPosZImage());        
00306         handleTexture(win, id, 
00307                       GL_TEXTURE_CUBE_MAP_ARB, 
00308                       GL_NONE, 
00309                       GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 
00310                       Window::initialize, getNegYImage());        
00311         handleTexture(win, id, 
00312                       GL_TEXTURE_CUBE_MAP_ARB, 
00313                       GL_NONE, 
00314                       GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 
00315                       Window::initialize, getPosYImage());        
00316         handleTexture(win, id, 
00317                       GL_TEXTURE_CUBE_MAP_ARB, 
00318                       GL_NONE, 
00319                       GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 
00320                       Window::initialize, getNegXImage());        
00321         handleTexture(win, id, 
00322                       GL_TEXTURE_CUBE_MAP_ARB, 
00323                       GL_NONE, 
00324                       GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 
00325                       Window::initialize, getPosXImage());        
00326     }
00327     else if(mode == Window::needrefresh)
00328     {
00329         handleTexture(win, id, 
00330                       GL_TEXTURE_CUBE_MAP_ARB, 
00331                       GL_TEXTURE_CUBE_MAP_ARB, 
00332                       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 
00333                       mode, getImage());        
00334         handleTexture(win, id, 
00335                       GL_TEXTURE_CUBE_MAP_ARB, 
00336                       GL_NONE, 
00337                       GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 
00338                       mode, getPosZImage());        
00339         handleTexture(win, id, 
00340                       GL_TEXTURE_CUBE_MAP_ARB, 
00341                       GL_NONE, 
00342                       GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 
00343                       mode, getNegYImage());        
00344         handleTexture(win, id, 
00345                       GL_TEXTURE_CUBE_MAP_ARB, 
00346                       GL_NONE, 
00347                       GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 
00348                       mode, getPosYImage());        
00349         handleTexture(win, id, 
00350                       GL_TEXTURE_CUBE_MAP_ARB, 
00351                       GL_NONE, 
00352                       GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 
00353                       mode, getNegXImage());        
00354         handleTexture(win, id, 
00355                       GL_TEXTURE_CUBE_MAP_ARB, 
00356                       GL_NONE, 
00357                       GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 
00358                       mode, getPosXImage());        
00359     }
00360     else
00361     {
00362         SWARNING << "Win:" << win << "TextureChunk(" << this 
00363                  << "::handleGL: Illegal mode: "
00364                  << mode << " for id " << id << std::endl;
00365     }
00366 }

void osg::CubeTextureChunk::operator= ( const CubeTextureChunk & source ) [private]

osg::FieldContainerType & osg::CubeTextureChunkBase::getClassType ( void ) [inline, static, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 58 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_type.

Referenced by osg::CubeTextureChunkBase::create(), and osg::RemoteAspect::RemoteAspect().

00059 {
00060     return _type; 
00061 }

osg::UInt32 osg::CubeTextureChunkBase::getClassTypeId ( void ) [inline, static, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 65 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_type, and osg::TypeBase::getId().

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

FieldContainerType & CubeTextureChunkBase::getType ( void ) [virtual, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 161 of file OSGCubeTextureChunkBase.cpp.

References osg::CubeTextureChunkBase::_type.

00162 {
00163     return _type; 
00164 }

const FieldContainerType & CubeTextureChunkBase::getType ( void ) const [virtual, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 166 of file OSGCubeTextureChunkBase.cpp.

References osg::CubeTextureChunkBase::_type.

00167 {
00168     return _type;
00169 }

UInt32 CubeTextureChunkBase::getContainerSize ( void ) const [virtual, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 181 of file OSGCubeTextureChunkBase.cpp.

00182 { 
00183     return sizeof(CubeTextureChunk); 
00184 }

SFImagePtr * osg::CubeTextureChunkBase::getSFPosZImage ( void ) [inline, inherited]

Definition at line 101 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosZImage.

00102 {
00103     return &_sfPosZImage;
00104 }

SFImagePtr * osg::CubeTextureChunkBase::getSFPosXImage ( void ) [inline, inherited]

Definition at line 108 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosXImage.

00109 {
00110     return &_sfPosXImage;
00111 }

SFImagePtr * osg::CubeTextureChunkBase::getSFNegXImage ( void ) [inline, inherited]

Definition at line 115 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegXImage.

00116 {
00117     return &_sfNegXImage;
00118 }

SFImagePtr * osg::CubeTextureChunkBase::getSFPosYImage ( void ) [inline, inherited]

Definition at line 122 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosYImage.

00123 {
00124     return &_sfPosYImage;
00125 }

SFImagePtr * osg::CubeTextureChunkBase::getSFNegYImage ( void ) [inline, inherited]

Definition at line 129 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegYImage.

00130 {
00131     return &_sfNegYImage;
00132 }

SFBool * osg::CubeTextureChunkBase::getSFIsReflectionMap ( void ) [inline, inherited]

Definition at line 136 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfIsReflectionMap.

00137 {
00138     return &_sfIsReflectionMap;
00139 }

ImagePtr & osg::CubeTextureChunkBase::getPosZImage ( void ) [inline, inherited]

Definition at line 144 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosZImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by handleGL(), and operator==().

00145 {
00146     return _sfPosZImage.getValue();
00147 }

const ImagePtr & osg::CubeTextureChunkBase::getPosZImage ( void ) const [inline, inherited]

Definition at line 151 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosZImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00152 {
00153     return _sfPosZImage.getValue();
00154 }

ImagePtr & osg::CubeTextureChunkBase::getPosXImage ( void ) [inline, inherited]

Definition at line 165 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosXImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by handleGL(), and operator==().

00166 {
00167     return _sfPosXImage.getValue();
00168 }

const ImagePtr & osg::CubeTextureChunkBase::getPosXImage ( void ) const [inline, inherited]

Definition at line 172 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosXImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00173 {
00174     return _sfPosXImage.getValue();
00175 }

ImagePtr & osg::CubeTextureChunkBase::getNegXImage ( void ) [inline, inherited]

Definition at line 186 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegXImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by handleGL(), and operator==().

00187 {
00188     return _sfNegXImage.getValue();
00189 }

const ImagePtr & osg::CubeTextureChunkBase::getNegXImage ( void ) const [inline, inherited]

Definition at line 193 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegXImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00194 {
00195     return _sfNegXImage.getValue();
00196 }

ImagePtr & osg::CubeTextureChunkBase::getPosYImage ( void ) [inline, inherited]

Definition at line 207 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosYImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by handleGL(), and operator==().

00208 {
00209     return _sfPosYImage.getValue();
00210 }

const ImagePtr & osg::CubeTextureChunkBase::getPosYImage ( void ) const [inline, inherited]

Definition at line 214 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosYImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00215 {
00216     return _sfPosYImage.getValue();
00217 }

ImagePtr & osg::CubeTextureChunkBase::getNegYImage ( void ) [inline, inherited]

Definition at line 228 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegYImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by handleGL(), and operator==().

00229 {
00230     return _sfNegYImage.getValue();
00231 }

const ImagePtr & osg::CubeTextureChunkBase::getNegYImage ( void ) const [inline, inherited]

Definition at line 235 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegYImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00236 {
00237     return _sfNegYImage.getValue();
00238 }

bool & osg::CubeTextureChunkBase::getIsReflectionMap ( void ) [inline, inherited]

Definition at line 249 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfIsReflectionMap, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00250 {
00251     return _sfIsReflectionMap.getValue();
00252 }

const bool & osg::CubeTextureChunkBase::getIsReflectionMap ( void ) const [inline, inherited]

Definition at line 256 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfIsReflectionMap, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00257 {
00258     return _sfIsReflectionMap.getValue();
00259 }

void osg::CubeTextureChunkBase::setPosZImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 158 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosZImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00159 {
00160     _sfPosZImage.setValue(value);
00161 }

void osg::CubeTextureChunkBase::setPosXImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 179 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosXImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00180 {
00181     _sfPosXImage.setValue(value);
00182 }

void osg::CubeTextureChunkBase::setNegXImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 200 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegXImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00201 {
00202     _sfNegXImage.setValue(value);
00203 }

void osg::CubeTextureChunkBase::setPosYImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 221 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfPosYImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00222 {
00223     _sfPosYImage.setValue(value);
00224 }

void osg::CubeTextureChunkBase::setNegYImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 242 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfNegYImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00243 {
00244     _sfNegYImage.setValue(value);
00245 }

void osg::CubeTextureChunkBase::setIsReflectionMap ( const bool & value ) [inline, inherited]

Definition at line 263 of file OSGCubeTextureChunkBase.inl.

References osg::CubeTextureChunkBase::_sfIsReflectionMap, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00264 {
00265     _sfIsReflectionMap.setValue(value);
00266 }

UInt32 CubeTextureChunkBase::getBinSize ( const BitVector & whichField ) [virtual, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 253 of file OSGCubeTextureChunkBase.cpp.

00254 {
00255     UInt32 returnValue = Inherited::getBinSize(whichField);
00256 
00257     if(FieldBits::NoField != (PosZImageFieldMask & whichField))
00258     {
00259         returnValue += _sfPosZImage.getBinSize();
00260     }
00261 
00262     if(FieldBits::NoField != (PosXImageFieldMask & whichField))
00263     {
00264         returnValue += _sfPosXImage.getBinSize();
00265     }
00266 
00267     if(FieldBits::NoField != (NegXImageFieldMask & whichField))
00268     {
00269         returnValue += _sfNegXImage.getBinSize();
00270     }
00271 
00272     if(FieldBits::NoField != (PosYImageFieldMask & whichField))
00273     {
00274         returnValue += _sfPosYImage.getBinSize();
00275     }
00276 
00277     if(FieldBits::NoField != (NegYImageFieldMask & whichField))
00278     {
00279         returnValue += _sfNegYImage.getBinSize();
00280     }
00281 
00282     if(FieldBits::NoField != (IsReflectionMapFieldMask & whichField))
00283     {
00284         returnValue += _sfIsReflectionMap.getBinSize();
00285     }
00286 
00287 
00288     return returnValue;
00289 }

void CubeTextureChunkBase::copyToBin	(	BinaryDataHandler &	pMem,
		const BitVector &	whichField
	)			`[virtual, inherited]`

Reimplemented from osg::TextureChunkBase.

Definition at line 291 of file OSGCubeTextureChunkBase.cpp.

00293 {
00294     Inherited::copyToBin(pMem, whichField);
00295 
00296     if(FieldBits::NoField != (PosZImageFieldMask & whichField))
00297     {
00298         _sfPosZImage.copyToBin(pMem);
00299     }
00300 
00301     if(FieldBits::NoField != (PosXImageFieldMask & whichField))
00302     {
00303         _sfPosXImage.copyToBin(pMem);
00304     }
00305 
00306     if(FieldBits::NoField != (NegXImageFieldMask & whichField))
00307     {
00308         _sfNegXImage.copyToBin(pMem);
00309     }
00310 
00311     if(FieldBits::NoField != (PosYImageFieldMask & whichField))
00312     {
00313         _sfPosYImage.copyToBin(pMem);
00314     }
00315 
00316     if(FieldBits::NoField != (NegYImageFieldMask & whichField))
00317     {
00318         _sfNegYImage.copyToBin(pMem);
00319     }
00320 
00321     if(FieldBits::NoField != (IsReflectionMapFieldMask & whichField))
00322     {
00323         _sfIsReflectionMap.copyToBin(pMem);
00324     }
00325 
00326 
00327 }

void CubeTextureChunkBase::copyFromBin	(	BinaryDataHandler &	pMem,
		const BitVector &	whichField
	)			`[virtual, inherited]`

Reimplemented from osg::TextureChunkBase.

Definition at line 329 of file OSGCubeTextureChunkBase.cpp.

00331 {
00332     Inherited::copyFromBin(pMem, whichField);
00333 
00334     if(FieldBits::NoField != (PosZImageFieldMask & whichField))
00335     {
00336         _sfPosZImage.copyFromBin(pMem);
00337     }
00338 
00339     if(FieldBits::NoField != (PosXImageFieldMask & whichField))
00340     {
00341         _sfPosXImage.copyFromBin(pMem);
00342     }
00343 
00344     if(FieldBits::NoField != (NegXImageFieldMask & whichField))
00345     {
00346         _sfNegXImage.copyFromBin(pMem);
00347     }
00348 
00349     if(FieldBits::NoField != (PosYImageFieldMask & whichField))
00350     {
00351         _sfPosYImage.copyFromBin(pMem);
00352     }
00353 
00354     if(FieldBits::NoField != (NegYImageFieldMask & whichField))
00355     {
00356         _sfNegYImage.copyFromBin(pMem);
00357     }
00358 
00359     if(FieldBits::NoField != (IsReflectionMapFieldMask & whichField))
00360     {
00361         _sfIsReflectionMap.copyFromBin(pMem);
00362     }
00363 
00364 
00365 }

CubeTextureChunkPtr osg::CubeTextureChunkBase::create ( void ) [inline, static, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 72 of file OSGCubeTextureChunkBase.inl.

References osg::AttachmentPtr::dcast(), osg::CubeTextureChunkBase::getClassType(), osg::NullFC, and osg::CubeTextureChunkBase::shallowCopy().

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

CubeTextureChunkPtr osg::CubeTextureChunkBase::createEmpty ( void ) [inline, static, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 87 of file OSGCubeTextureChunkBase.inl.

References osg::FieldContainer::newPtr().

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

FieldContainerPtr CubeTextureChunkBase::shallowCopy ( void ) const [virtual, inherited]

Reimplemented from osg::TextureChunkBase.

Definition at line 172 of file OSGCubeTextureChunkBase.cpp.

References osg::FieldContainer::newPtr().

Referenced by osg::CubeTextureChunkBase::create().

00173 { 
00174     CubeTextureChunkPtr returnValue; 
00175 
00176     newPtr(returnValue, dynamic_cast<const CubeTextureChunk *>(this)); 
00177 
00178     return returnValue; 
00179 }

void CubeTextureChunkBase::executeSyncImpl	(	CubeTextureChunkBase *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 368 of file OSGCubeTextureChunkBase.cpp.

Referenced by osg::CubeTextureChunkBase::executeSync().

00370 {
00371 
00372     Inherited::executeSyncImpl(pOther, whichField);
00373 
00374     if(FieldBits::NoField != (PosZImageFieldMask & whichField))
00375         _sfPosZImage.syncWith(pOther->_sfPosZImage);
00376 
00377     if(FieldBits::NoField != (PosXImageFieldMask & whichField))
00378         _sfPosXImage.syncWith(pOther->_sfPosXImage);
00379 
00380     if(FieldBits::NoField != (NegXImageFieldMask & whichField))
00381         _sfNegXImage.syncWith(pOther->_sfNegXImage);
00382 
00383     if(FieldBits::NoField != (PosYImageFieldMask & whichField))
00384         _sfPosYImage.syncWith(pOther->_sfPosYImage);
00385 
00386     if(FieldBits::NoField != (NegYImageFieldMask & whichField))
00387         _sfNegYImage.syncWith(pOther->_sfNegYImage);
00388 
00389     if(FieldBits::NoField != (IsReflectionMapFieldMask & whichField))
00390         _sfIsReflectionMap.syncWith(pOther->_sfIsReflectionMap);
00391 
00392 
00393 }

void osg::TextureChunkBase::executeSyncImpl	(	TextureChunkBase *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 1712 of file OSGTextureChunkBase.cpp.

Referenced by osg::TextureChunkBase::executeSync(), and osg::CubeTextureChunkBase::executeSyncImpl().

01714 {
01715 
01716     Inherited::executeSyncImpl(pOther, whichField);
01717 
01718     if(FieldBits::NoField != (ImageFieldMask & whichField))
01719         _sfImage.syncWith(pOther->_sfImage);
01720 
01721     if(FieldBits::NoField != (InternalFormatFieldMask & whichField))
01722         _sfInternalFormat.syncWith(pOther->_sfInternalFormat);
01723 
01724     if(FieldBits::NoField != (ExternalFormatFieldMask & whichField))
01725         _sfExternalFormat.syncWith(pOther->_sfExternalFormat);
01726 
01727     if(FieldBits::NoField != (ScaleFieldMask & whichField))
01728         _sfScale.syncWith(pOther->_sfScale);
01729 
01730     if(FieldBits::NoField != (FrameFieldMask & whichField))
01731         _sfFrame.syncWith(pOther->_sfFrame);
01732 
01733     if(FieldBits::NoField != (MinFilterFieldMask & whichField))
01734         _sfMinFilter.syncWith(pOther->_sfMinFilter);
01735 
01736     if(FieldBits::NoField != (MagFilterFieldMask & whichField))
01737         _sfMagFilter.syncWith(pOther->_sfMagFilter);
01738 
01739     if(FieldBits::NoField != (WrapSFieldMask & whichField))
01740         _sfWrapS.syncWith(pOther->_sfWrapS);
01741 
01742     if(FieldBits::NoField != (WrapTFieldMask & whichField))
01743         _sfWrapT.syncWith(pOther->_sfWrapT);
01744 
01745     if(FieldBits::NoField != (WrapRFieldMask & whichField))
01746         _sfWrapR.syncWith(pOther->_sfWrapR);
01747 
01748     if(FieldBits::NoField != (EnvModeFieldMask & whichField))
01749         _sfEnvMode.syncWith(pOther->_sfEnvMode);
01750 
01751     if(FieldBits::NoField != (EnvColorFieldMask & whichField))
01752         _sfEnvColor.syncWith(pOther->_sfEnvColor);
01753 
01754     if(FieldBits::NoField != (EnvCombineRGBFieldMask & whichField))
01755         _sfEnvCombineRGB.syncWith(pOther->_sfEnvCombineRGB);
01756 
01757     if(FieldBits::NoField != (EnvCombineAlphaFieldMask & whichField))
01758         _sfEnvCombineAlpha.syncWith(pOther->_sfEnvCombineAlpha);
01759 
01760     if(FieldBits::NoField != (EnvScaleRGBFieldMask & whichField))
01761         _sfEnvScaleRGB.syncWith(pOther->_sfEnvScaleRGB);
01762 
01763     if(FieldBits::NoField != (EnvScaleAlphaFieldMask & whichField))
01764         _sfEnvScaleAlpha.syncWith(pOther->_sfEnvScaleAlpha);
01765 
01766     if(FieldBits::NoField != (EnvSource0RGBFieldMask & whichField))
01767         _sfEnvSource0RGB.syncWith(pOther->_sfEnvSource0RGB);
01768 
01769     if(FieldBits::NoField != (EnvSource1RGBFieldMask & whichField))
01770         _sfEnvSource1RGB.syncWith(pOther->_sfEnvSource1RGB);
01771 
01772     if(FieldBits::NoField != (EnvSource2RGBFieldMask & whichField))
01773         _sfEnvSource2RGB.syncWith(pOther->_sfEnvSource2RGB);
01774 
01775     if(FieldBits::NoField != (EnvSource0AlphaFieldMask & whichField))
01776         _sfEnvSource0Alpha.syncWith(pOther->_sfEnvSource0Alpha);
01777 
01778     if(FieldBits::NoField != (EnvSource1AlphaFieldMask & whichField))
01779         _sfEnvSource1Alpha.syncWith(pOther->_sfEnvSource1Alpha);
01780 
01781     if(FieldBits::NoField != (EnvSource2AlphaFieldMask & whichField))
01782         _sfEnvSource2Alpha.syncWith(pOther->_sfEnvSource2Alpha);
01783 
01784     if(FieldBits::NoField != (EnvOperand0RGBFieldMask & whichField))
01785         _sfEnvOperand0RGB.syncWith(pOther->_sfEnvOperand0RGB);
01786 
01787     if(FieldBits::NoField != (EnvOperand1RGBFieldMask & whichField))
01788         _sfEnvOperand1RGB.syncWith(pOther->_sfEnvOperand1RGB);
01789 
01790     if(FieldBits::NoField != (EnvOperand2RGBFieldMask & whichField))
01791         _sfEnvOperand2RGB.syncWith(pOther->_sfEnvOperand2RGB);
01792 
01793     if(FieldBits::NoField != (EnvOperand0AlphaFieldMask & whichField))
01794         _sfEnvOperand0Alpha.syncWith(pOther->_sfEnvOperand0Alpha);
01795 
01796     if(FieldBits::NoField != (EnvOperand1AlphaFieldMask & whichField))
01797         _sfEnvOperand1Alpha.syncWith(pOther->_sfEnvOperand1Alpha);
01798 
01799     if(FieldBits::NoField != (EnvOperand2AlphaFieldMask & whichField))
01800         _sfEnvOperand2Alpha.syncWith(pOther->_sfEnvOperand2Alpha);
01801 
01802     if(FieldBits::NoField != (GLIdFieldMask & whichField))
01803         _sfGLId.syncWith(pOther->_sfGLId);
01804 
01805     if(FieldBits::NoField != (IgnoreGLForAspectFieldMask & whichField))
01806         _sfIgnoreGLForAspect.syncWith(pOther->_sfIgnoreGLForAspect);
01807 
01808     if(FieldBits::NoField != (PointSpriteFieldMask & whichField))
01809         _sfPointSprite.syncWith(pOther->_sfPointSprite);
01810 
01811     if(FieldBits::NoField != (PriorityFieldMask & whichField))
01812         _sfPriority.syncWith(pOther->_sfPriority);
01813 
01814     if(FieldBits::NoField != (ShaderOperationFieldMask & whichField))
01815         _sfShaderOperation.syncWith(pOther->_sfShaderOperation);
01816 
01817     if(FieldBits::NoField != (ShaderInputFieldMask & whichField))
01818         _sfShaderInput.syncWith(pOther->_sfShaderInput);
01819 
01820     if(FieldBits::NoField != (ShaderOffsetMatrixFieldMask & whichField))
01821         _mfShaderOffsetMatrix.syncWith(pOther->_mfShaderOffsetMatrix);
01822 
01823     if(FieldBits::NoField != (ShaderOffsetScaleFieldMask & whichField))
01824         _sfShaderOffsetScale.syncWith(pOther->_sfShaderOffsetScale);
01825 
01826     if(FieldBits::NoField != (ShaderOffsetBiasFieldMask & whichField))
01827         _sfShaderOffsetBias.syncWith(pOther->_sfShaderOffsetBias);
01828 
01829     if(FieldBits::NoField != (ShaderRGBADotProductFieldMask & whichField))
01830         _sfShaderRGBADotProduct.syncWith(pOther->_sfShaderRGBADotProduct);
01831 
01832     if(FieldBits::NoField != (ShaderCullModesFieldMask & whichField))
01833         _sfShaderCullModes.syncWith(pOther->_sfShaderCullModes);
01834 
01835     if(FieldBits::NoField != (ShaderConstEyeFieldMask & whichField))
01836         _sfShaderConstEye.syncWith(pOther->_sfShaderConstEye);
01837 
01838     if(FieldBits::NoField != (LodBiasFieldMask & whichField))
01839         _sfLodBias.syncWith(pOther->_sfLodBias);
01840 
01841     if(FieldBits::NoField != (TargetFieldMask & whichField))
01842         _sfTarget.syncWith(pOther->_sfTarget);
01843 
01844     if(FieldBits::NoField != (DirtyLeftFieldMask & whichField))
01845         _sfDirtyLeft.syncWith(pOther->_sfDirtyLeft);
01846 
01847     if(FieldBits::NoField != (DirtyMinXFieldMask & whichField))
01848         _sfDirtyMinX.syncWith(pOther->_sfDirtyMinX);
01849 
01850     if(FieldBits::NoField != (DirtyMaxXFieldMask & whichField))
01851         _sfDirtyMaxX.syncWith(pOther->_sfDirtyMaxX);
01852 
01853     if(FieldBits::NoField != (DirtyMinYFieldMask & whichField))
01854         _sfDirtyMinY.syncWith(pOther->_sfDirtyMinY);
01855 
01856     if(FieldBits::NoField != (DirtyMaxYFieldMask & whichField))
01857         _sfDirtyMaxY.syncWith(pOther->_sfDirtyMaxY);
01858 
01859     if(FieldBits::NoField != (DirtyMinZFieldMask & whichField))
01860         _sfDirtyMinZ.syncWith(pOther->_sfDirtyMinZ);
01861 
01862     if(FieldBits::NoField != (DirtyMaxZFieldMask & whichField))
01863         _sfDirtyMaxZ.syncWith(pOther->_sfDirtyMaxZ);
01864 
01865     if(FieldBits::NoField != (AnisotropyFieldMask & whichField))
01866         _sfAnisotropy.syncWith(pOther->_sfAnisotropy);
01867 
01868     if(FieldBits::NoField != (BorderColorFieldMask & whichField))
01869         _sfBorderColor.syncWith(pOther->_sfBorderColor);
01870 
01871     if(FieldBits::NoField != (BorderWidthFieldMask & whichField))
01872         _sfBorderWidth.syncWith(pOther->_sfBorderWidth);
01873 
01874     if(FieldBits::NoField != (NPOTMatrixScaleFieldMask & whichField))
01875         _sfNPOTMatrixScale.syncWith(pOther->_sfNPOTMatrixScale);
01876 
01877 
01878 }

void osg::StateChunkBase::executeSyncImpl	(	StateChunkBase *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 219 of file OSGStateChunkBase.cpp.

References osg::StateChunkBase::_sfIgnore, osg::Attachment::executeSyncImpl(), osg::StateChunkBase::IgnoreFieldMask, osg::FieldBits::NoField, and osg::SField< FieldTypeT, fieldNameSpace >::syncWith().

00221 {
00222 
00223     Inherited::executeSyncImpl(pOther, whichField);
00224 
00225     if(FieldBits::NoField != (IgnoreFieldMask & whichField))
00226         _sfIgnore.syncWith(pOther->_sfIgnore);
00227 
00228 
00229 }

void Attachment::executeSyncImpl	(	Attachment *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 306 of file OSGAttachment.cpp.

References osg::Attachment::_parents, osg::Attachment::_sfInternal, osg::FieldContainer::executeSyncImpl(), osg::Attachment::InternalFieldMask, osg::FieldBits::NoField, osg::Attachment::ParentsFieldMask, osg::MField< FieldTypeT, fieldNameSpace >::syncWith(), and osg::SField< FieldTypeT, fieldNameSpace >::syncWith().

Referenced by osg::Attachment::executeSync(), osg::StringAttributeMapBase::executeSyncImpl(), osg::StateChunkBase::executeSyncImpl(), osg::RenderOptionsBase::executeSyncImpl(), osg::FCPtrAttributeMapBase::executeSyncImpl(), osg::DVRVolumeTextureBase::executeSyncImpl(), osg::DVRLookupTableBase::executeSyncImpl(), osg::DVRIsoSurfaceBase::executeSyncImpl(), osg::DVRClipObjectsBase::executeSyncImpl(), and osg::SimpleAttachment< AttachmentDescT >::executeSyncImpl().

00308 {
00309     Inherited::executeSyncImpl(pOther, whichField);
00310 
00311     if(FieldBits::NoField != (InternalFieldMask & whichField))
00312     {
00313         _sfInternal.syncWith(pOther->_sfInternal);
00314     }
00315 
00316     if(FieldBits::NoField != (ParentsFieldMask & whichField))
00317     {
00318         _parents.syncWith(pOther->_parents);
00319     }
00320 }

void osg::FieldContainer::executeSyncImpl	(	FieldContainer *	pOther,
		const BitVector &	whichField
	)			`[inline, protected, inherited]`

Definition at line 333 of file OSGFieldContainerImpl.inl.

Referenced by osg::StateBase::executeSyncImpl(), osg::DVRShaderBase::executeSyncImpl(), osg::DVRClipGeometryBase::executeSyncImpl(), osg::AttachmentContainer::executeSyncImpl(), and osg::Attachment::executeSyncImpl().

00335 {
00336 }

void CubeTextureChunkBase::executeSync	(	FieldContainer &	other,
		const BitVector &	whichField
	)			`[protected, virtual, inherited]`

Reimplemented from osg::TextureChunkBase.

Definition at line 188 of file OSGCubeTextureChunkBase.cpp.

References osg::CubeTextureChunkBase::executeSyncImpl().

00190 {
00191     this->executeSyncImpl((CubeTextureChunkBase *) &other, whichField);
00192 }

bool TextureChunk::isTransparent ( void ) const [virtual, inherited]

Reimplemented from osg::StateChunk.

Definition at line 338 of file OSGTextureChunk.cpp.

00339 {
00340     // Even if the texture has alpha, the Blending makes the sorting
00341     // important, thus textures per se are not transparent
00342     return false;
00343 }

void osg::TextureChunk::imageContentChanged	(	Int32	minx = `-1`,
		Int32	maxx = `-1`,
		Int32	miny = `-1`,
		Int32	maxy = `-1`,
		Int32	minz = `-1`,
		Int32	maxz = `-1`
	)			`[inline, inherited]`

Utility function to be called whenever the contents of the image change. Forces efficient update of the texture. Should not be called when the size of the texture changes, in that case setImage() should be called to renew the texture.

Definition at line 75 of file OSGTextureChunk.inl.

References osg::beginEditCP(), osg::TextureChunkBase::DirtyMaxXFieldMask, osg::TextureChunkBase::DirtyMaxYFieldMask, osg::TextureChunkBase::DirtyMaxZFieldMask, osg::TextureChunkBase::DirtyMinXFieldMask, osg::TextureChunkBase::DirtyMinYFieldMask, osg::TextureChunkBase::DirtyMinZFieldMask, and osg::endEditCP().

Referenced by osg::TextureChunk::changed().

00078 {
00079     TextureChunkPtr tc(*this);
00080     
00081     beginEditCP(tc, DirtyMinXFieldMask | DirtyMaxXFieldMask |
00082                     DirtyMinYFieldMask | DirtyMaxYFieldMask |
00083                     DirtyMinZFieldMask | DirtyMaxZFieldMask);
00084     
00085     tc->setDirtyMinX(minx);
00086     tc->setDirtyMaxX(maxx);
00087     tc->setDirtyMinY(miny);
00088     tc->setDirtyMaxY(maxy);
00089     tc->setDirtyMinZ(minz);
00090     tc->setDirtyMaxZ(maxz);
00091     
00092     endEditCP(  tc, DirtyMinXFieldMask | DirtyMaxXFieldMask |
00093                     DirtyMinYFieldMask | DirtyMaxYFieldMask |
00094                     DirtyMinZFieldMask | DirtyMaxZFieldMask);
00095 }

void osg::TextureChunk::setImage ( ImagePtr & pImage ) [inline, inherited]

Utility function to be called whenever the contents of the image change. Forces efficient update of the texture. Should not be called when the size of the texture changes, in that case setImage() should be called to renew the texture.

Definition at line 59 of file OSGTextureChunk.inl.

References osg::TextureChunkBase::_sfImage, osg::addRefCP(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::SField< FieldTypeT, fieldNameSpace >::setValue(), and osg::subRefCP().

Referenced by osg::TextureChunk::changed().

00060 {
00061      addRefCP(pImage);
00062 
00063      subRefCP(_sfImage.getValue());
00064 
00065     _sfImage.setValue(pImage);
00066 }

void osg::TextureChunkBase::setImage ( const ImagePtr & value ) [inline, inherited]

Definition at line 487 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfImage, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00488 {
00489     _sfImage.setValue(value);
00490 }

void osg::TextureChunk::setShaderOffsetMatrix	(	Real32	m11,
		Real32	m12,
		Real32	m21,
		Real32	m22
	)			`[inline, inherited]`

Utility function to be called whenever the contents of the image change. Forces efficient update of the texture. Should not be called when the size of the texture changes, in that case setImage() should be called to renew the texture.

Definition at line 140 of file OSGTextureChunk.inl.

References osg::TextureChunkBase::getShaderOffsetMatrix(), and osg::MField< FieldTypeT, fieldNameSpace >::resize().

00142 {
00143     getShaderOffsetMatrix().resize(4);
00144 
00145     getShaderOffsetMatrix()[0] = m11;
00146     getShaderOffsetMatrix()[1] = m12;
00147     getShaderOffsetMatrix()[2] = m21;
00148     getShaderOffsetMatrix()[3] = m22;
00149 }

bool osg::TextureChunk::hasMultiTexture ( Window * win ) [inline, static, inherited]

Definition at line 99 of file OSGTextureChunk.inl.

References osg::TextureChunk::_arbMultiTex, and osg::Window::hasExtension().

Referenced by osg::TextureChunk::activateTexture().

00100 {
00101     return win->hasExtension(_arbMultiTex);
00102 }

void osg::TextureChunk::activeTexture	(	Window *	win,
		UInt16	texture
	)			`[inline, static, inherited]`

Definition at line 106 of file OSGTextureChunk.inl.

References osg::TextureChunk::_funcActiveTexture, osg::Window::getFunction(), GL_TEXTURE0_ARB, GLenum, and OSG_APIENTRY.

Referenced by osg::TextureChunk::activateTexture().

00107 {
00108     void (OSG_APIENTRY *ActiveTexture)(GLenum target) = 
00109         (void (OSG_APIENTRY*)(GLenum target))
00110             win->getFunction(_funcActiveTexture);
00111 
00112     ActiveTexture(GL_TEXTURE0_ARB + texture);
00113 }

bool osg::TextureChunk::activateTexture	(	Window *	win,
		UInt16	texture
	)			`[inline, static, inherited]`

call glActiveTexture via the extension mechanism, if MultiTextures are supported. Return false if successful, true if not.

Definition at line 118 of file OSGTextureChunk.inl.

References osg::TextureChunk::activeTexture(), FWARNING, and osg::TextureChunk::hasMultiTexture().

Referenced by osg::TextureTransformChunk::activate(), osg::TextureChunk::activate(), osg::TexGenChunk::activate(), activate(), osg::TextureTransformChunk::changeFrom(), osg::TextureChunk::changeFrom(), osg::TexGenChunk::changeFrom(), changeFrom(), osg::TextureTransformChunk::deactivate(), osg::TextureChunk::deactivate(), osg::TexGenChunk::deactivate(), and deactivate().

00119 {
00120     if(hasMultiTexture(win))
00121     {
00122         activeTexture(win, texture);
00123     }
00124 #ifdef OSG_DEBUG
00125     else
00126     {
00127         if(texture != 0)
00128         {
00129             FWARNING(("TextureChunk::activateTexture: trying to activate "
00130                 "texture %d, but Window %p doesn't support multi-textures!\n",
00131                 texture, win));
00132             return true;
00133         }
00134     }
00135 #endif
00136     return false;
00137 }

void TextureChunk::onCreate ( const TextureChunk * source = NULL ) [protected, inherited]

Definition at line 348 of file OSGTextureChunk.cpp.

References osg::TextureChunkBase::_sfIgnoreGLForAspect, osg::beginEditCP(), osg::endEditCP(), osg::PThreadBase::getAspect(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::TextureChunkBase::GLIdFieldMask, osg::GlobalSystemState, osg::TextureChunk::handleGL(), osg::osgTypedMethodVoidFunctor2ObjCPtrPtr(), osg::Window::registerGLObject(), osg::TextureChunkBase::setGLId(), and osg::Startup.

00349 {
00350     if(GlobalSystemState == Startup)
00351         return;
00352 
00353     // !!! this temporary is needed to work around compiler problems (sgi)
00354     // CHECK CHECK
00355     //  TextureChunkPtr tmpPtr = FieldContainer::getPtr<TextureChunkPtr>(*this);
00356     TextureChunkPtr tmpPtr(*this);
00357 
00358     if(Thread::getAspect() != _sfIgnoreGLForAspect.getValue())
00359     {
00360         beginEditCP(tmpPtr, TextureChunk::GLIdFieldMask);
00361 
00362         setGLId(
00363             Window::registerGLObject(
00364                 osgTypedMethodVoidFunctor2ObjCPtrPtr<TextureChunkPtr,
00365                                                  Window ,
00366                                                  UInt32>(
00367                                                      tmpPtr,
00368                                                      &TextureChunk::handleGL),
00369                 1));
00370 
00371         endEditCP(tmpPtr, TextureChunk::GLIdFieldMask);
00372     }
00373 }

void osg::FieldContainer::onCreate ( const FieldContainer * source = NULL ) [inline, protected, inherited]

Definition at line 318 of file OSGFieldContainerImpl.inl.

Referenced by osg::ShaderParameterChunk::onCreate().

00319 {
00320 }

void TextureChunk::handleTexture	(	Window *	win,
		UInt32	id,
		GLenum	bindtarget,
		GLenum	paramtarget,
		GLenum	imgtarget,
		Window::GLObjectStatusE	mode,
		ImagePtr	img,
		int	side = `0`
	)			`[protected, inherited]`

Definition at line 521 of file OSGTextureChunk.cpp.

Referenced by osg::TextureChunk::handleGL(), and handleGL().

00526 {
00527     if( img==NullFC || ! img->getDimension()) // no image ?
00528         return;
00529 
00530     if(mode == Window::initialize || mode == Window::reinitialize)
00531     {
00532         if(bindtarget == GL_TEXTURE_3D && 
00533             !win->hasExtension(_extTex3D) &&
00534              win->getGLVersion() < 0x0102
00535           )
00536         {
00537             FNOTICE(("3D textures not supported on Window %p!\n", win));
00538             return;
00539         }
00540 
00541         if(imgtarget == GL_TEXTURE_RECTANGLE_ARB &&
00542            !win->hasExtension(_arbTextureRectangle))
00543         {
00544             FNOTICE(("Rectangular textures not supported on Window %p!\n", win));
00545             return;
00546         }
00547 
00548         if(paramtarget == GL_TEXTURE_CUBE_MAP_ARB && 
00549            !win->hasExtension(_arbCubeTex))
00550         {
00551             FNOTICE(("Cube textures not supported on Window %p!\n", win));
00552             return;
00553         }
00554         
00555         if(img->hasCompressedData() && 
00556            !win->hasExtension(_arbTextureCompression))
00557         {
00558             FNOTICE(("Compressed textures not supported on Window %p!\n", win));
00559             return;
00560         }
00561 
00562         if(mode == Window::reinitialize)
00563         {
00564             GLuint tex = id;
00565             glDeleteTextures(1, &tex);
00566         }
00567 
00568         // 3D texture functions
00569         void (OSG_APIENTRY*TexImage3D)(GLenum target, GLint level, GLenum internalformat,
00570                            GLsizei width, GLsizei height, GLsizei depth,
00571                            GLint border, GLenum format, GLenum type,
00572                            const GLvoid *pixels) =
00573             (void (OSG_APIENTRY*)(GLenum target, GLint level, GLenum internalformat,
00574                       GLsizei width, GLsizei height, GLsizei depth,
00575                       GLint border, GLenum format, GLenum type,
00576                       const GLvoid *pixels))
00577             win->getFunction(_funcTexImage3D);
00578 
00579         void (OSG_APIENTRY*TexSubImage3D)
00580                           (GLenum target, GLint level, GLint xoffset,
00581                            GLint yoffset, GLint zoffset, GLsizei width,
00582                            GLsizei height, GLsizei depth, GLenum format,
00583                            GLenum type, const GLvoid *pixels) =
00584             (void (OSG_APIENTRY*)(GLenum target, GLint level, GLint xoffset,
00585                       GLint yoffset, GLint zoffset, GLsizei width,
00586                       GLsizei height, GLsizei depth, GLenum format,
00587                       GLenum type, const GLvoid *pixels))
00588             win->getFunction(_funcTexSubImage3D);
00589 
00590         // Compressed texture functions
00591         void (OSG_APIENTRY*CompressedTexImage1D)(GLenum target, GLint level, 
00592                            GLenum internalformat, GLsizei width, GLint border, 
00593                            GLsizei imageSize, const GLvoid *pixels) =
00594             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
00595                            GLenum internalformat, GLsizei width, GLint border,  
00596                            GLsizei imageSize, const GLvoid *pixels))
00597             win->getFunction(_funcCompressedTexImage1D);
00598 
00599         void (OSG_APIENTRY*CompressedTexSubImage1D)
00600                           (GLenum target, GLint level, GLint xoffset, GLsizei width,
00601                            GLenum format, GLsizei imageSize, const GLvoid *pixels) =
00602             (void (OSG_APIENTRY*)(GLenum target, GLint level, GLint xoffset, GLsizei width,
00603                            GLenum format, GLsizei imageSize, const GLvoid *pixels))
00604             win->getFunction(_funcCompressedTexSubImage1D);
00605 
00606         void (OSG_APIENTRY*CompressedTexImage2D)(GLenum target, GLint level, 
00607                            GLenum internalformat, GLsizei width, GLsizei height, 
00608                            GLint border, 
00609                            GLsizei imageSize, const GLvoid *pixels) =
00610             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
00611                            GLenum internalformat, GLsizei width, GLsizei height, 
00612                            GLint border, 
00613                            GLsizei imageSize, const GLvoid *pixels))
00614             win->getFunction(_funcCompressedTexImage2D);
00615 
00616         void (OSG_APIENTRY*CompressedTexSubImage2D)
00617                           (GLenum target, GLint level, 
00618                            GLint xoffset, GLint yoffset, 
00619                            GLsizei width, GLsizei height, GLenum format,
00620                            GLsizei imageSize, const GLvoid *pixels) =
00621             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
00622                            GLint xoffset, GLint yoffset, 
00623                            GLsizei width, GLsizei height, GLenum format,
00624                            GLsizei imageSize, const GLvoid *pixels))
00625             win->getFunction(_funcCompressedTexSubImage2D);
00626 
00627         void (OSG_APIENTRY*CompressedTexImage3D)(GLenum target, GLint level, 
00628                            GLenum internalformat,
00629                            GLsizei width, GLsizei height, GLsizei depth,
00630                            GLint border,
00631                            GLsizei imageSize, const GLvoid *pixels) =
00632             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
00633                            GLenum internalformat,
00634                            GLsizei width, GLsizei height, GLsizei depth,
00635                            GLint border,
00636                            GLsizei imageSize, const GLvoid *pixels))
00637             win->getFunction(_funcCompressedTexImage3D);
00638 
00639         void (OSG_APIENTRY*CompressedTexSubImage3D)
00640                           (GLenum target, GLint level, 
00641                            GLint xoffset, GLint yoffset, GLint zoffset, 
00642                            GLsizei width, GLsizei height, GLsizei depth, 
00643                            GLenum format, GLsizei imageSize, const GLvoid *pixels) =
00644             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
00645                            GLint xoffset, GLint yoffset, GLint zoffset, 
00646                            GLsizei width, GLsizei height, GLsizei depth, 
00647                            GLenum format, GLsizei imageSize, const GLvoid *pixels))
00648             win->getFunction(_funcCompressedTexSubImage3D);
00649 
00650         // as we're not allocating anything here, the same code can be used
00651         // for reinitialization
00652         if(! img || ! img->getDimension()) // no image ?
00653             return;
00654 
00655         glErr("TextureChunk::initialize precheck");
00656 
00657         FDEBUG(("texture (re-)initialize\n"));
00658         
00659         glBindTexture(bindtarget, id);
00660 
00661         if(paramtarget != GL_NONE)
00662         {
00663             // set the parameters
00664             glTexParameterf(paramtarget, GL_TEXTURE_PRIORITY,   getPriority());
00665             glTexParameteri(paramtarget, GL_TEXTURE_MIN_FILTER, getMinFilter());
00666             glTexParameteri(paramtarget, GL_TEXTURE_MAG_FILTER, getMagFilter());
00667             glTexParameteri(paramtarget, GL_TEXTURE_WRAP_S, getWrapS());
00668             if(paramtarget == GL_TEXTURE_2D ||
00669                paramtarget == GL_TEXTURE_3D ||
00670                paramtarget == GL_TEXTURE_CUBE_MAP_ARB ||
00671                paramtarget == GL_TEXTURE_RECTANGLE_ARB
00672               )
00673                 glTexParameteri(paramtarget, GL_TEXTURE_WRAP_T, getWrapT());
00674             if(paramtarget == GL_TEXTURE_3D ||
00675                paramtarget == GL_TEXTURE_CUBE_MAP_ARB)
00676                 glTexParameteri(paramtarget, GL_TEXTURE_WRAP_R, getWrapR());
00677 
00678             if(getAnisotropy() > 1.0f && win->hasExtension(_extTextureFilterAnisotropic))
00679                 glTexParameterf(paramtarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, getAnisotropy());
00680 
00681             glTexParameterfv(paramtarget, GL_TEXTURE_BORDER_COLOR,
00682                              (GLfloat*)getBorderColor().getValuesRGBA());
00683 
00684             glErr("TextureChunk::initialize params");
00685         }
00686 
00687         // set the image
00688         GLenum internalFormat = getInternalFormat();
00689         GLenum externalFormat = img->getPixelFormat();
00690         GLenum type           = img->getDataType();
00691         UInt32 width          = img->getWidth();
00692         UInt32 height         = img->getHeight();
00693         UInt32 depth          = img->getDepth();
00694         bool   compressedData = img->hasCompressedData();
00695 
00696         bool doScale = getScale(); // scale the texture to 2^?
00697         UInt32 frame = getFrame();
00698 
00699         bool defined = false;   // Texture defined ?
00700         bool needMipmaps =  getMinFilter() == GL_NEAREST_MIPMAP_NEAREST ||
00701                             getMinFilter() == GL_LINEAR_MIPMAP_NEAREST  ||
00702                             getMinFilter() == GL_NEAREST_MIPMAP_LINEAR  ||
00703                             getMinFilter() == GL_LINEAR_MIPMAP_LINEAR   ;
00704 
00705         if(internalFormat == GL_NONE)
00706         {
00707             switch(externalFormat)
00708             {
00709 #if defined(GL_BGR) && defined(GL_BGR_EXT)
00710             case GL_BGR:
00711 #else
00712 #  if defined(GL_BGR)
00713             case GL_BGR:
00714 #  endif
00715 #  if defined(GL_BGR_EXT)
00716             case GL_BGR_EXT:
00717 #  endif
00718 #endif
00719 #if defined(GL_BGR) || defined(GL_BGR_EXT)
00720                             internalFormat = GL_RGB;
00721                             break;
00722 #endif
00723 #if defined(GL_BGRA) && defined(GL_BGRA_EXT)
00724             case GL_BGRA:
00725 #else
00726 #  if defined(GL_BGRA)
00727             case GL_BGRA:
00728 #  endif
00729 #  if defined(GL_BGRA_EXT)
00730             case GL_BGRA_EXT:
00731 #  endif
00732 #endif
00733 #if defined(GL_BGRA) || defined(GL_BGRA_EXT)
00734                             internalFormat = GL_RGBA;
00735                             break;
00736 #endif
00737             case GL_INTENSITY:
00738                             internalFormat = GL_INTENSITY;
00739                             externalFormat = GL_LUMINANCE;
00740                             break;
00741                             
00742             default:    internalFormat = externalFormat;
00743                         break;
00744             }
00745         }
00746          
00747         if(getExternalFormat() != GL_NONE)
00748             externalFormat = getExternalFormat();
00749        
00750         if(imgtarget == GL_TEXTURE_RECTANGLE_ARB && needMipmaps)
00751         {
00752             SWARNING << "TextureChunk::initialize: Can't do mipmaps"
00753                      << "with GL_TEXTURE_RECTANGLE_ARB target! Ignored"
00754                      << std::endl;
00755             needMipmaps= false;
00756         }
00757         
00758         // do we need mipmaps?
00759         if(needMipmaps)
00760         {
00761             // do we have usable mipmaps ?
00762             if(img->getMipMapCount() == img->calcMipmapLevelCount() &&
00763                  osgispower2(width) && osgispower2(height) &&
00764                  osgispower2(depth)
00765               )
00766             {
00767                 for(UInt16 i = 0; i < img->getMipMapCount(); i++)
00768                 {
00769                     UInt32 w, h, d;
00770                     img->calcMipmapGeometry(i, w, h, d);
00771 
00772                     if(compressedData)
00773                     {
00774                         switch (imgtarget)
00775                         {
00776                         case GL_TEXTURE_1D:
00777                             CompressedTexImage1D(GL_TEXTURE_1D, i, internalFormat,
00778                                             w, getBorderWidth(),
00779                                             img->calcMipmapLevelSize(i),
00780                                             img->getData(i, frame, side));
00781                             break;
00782                         case GL_TEXTURE_2D:
00783                             CompressedTexImage2D(imgtarget, i, internalFormat,
00784                                             w, h, getBorderWidth(),
00785                                             img->calcMipmapLevelSize(i),
00786                                             img->getData(i, frame, side));
00787                             break;
00788                         case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
00789                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
00790                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
00791                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
00792                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
00793                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
00794                             CompressedTexImage2D(imgtarget, i, internalFormat,
00795                                             w, h, getBorderWidth(),
00796                                             img->calcMipmapLevelSize(i), 
00797                                             img->getData(i, frame, side));
00798                             break;
00799                         case GL_TEXTURE_3D:
00800                             CompressedTexImage3D(GL_TEXTURE_3D, i, internalFormat,
00801                                             w, h, d, getBorderWidth(),
00802                                             img->calcMipmapLevelSize(i),
00803                                             img->getData(i, frame, side));
00804                             break;
00805                        default:
00806                                 SFATAL << "TextureChunk::initialize1: unknown target "
00807                                        << imgtarget << "!!!" << std::endl;
00808                                 break;
00809                         }
00810                     }
00811                     else
00812                     {
00813                         switch (imgtarget)
00814                         {
00815                         case GL_TEXTURE_1D:
00816                             glTexImage1D(GL_TEXTURE_1D, i, internalFormat,
00817                                             w, getBorderWidth(),
00818                                             externalFormat, type,
00819                                             img->getData(i, frame, side));
00820                             break;
00821                         case GL_TEXTURE_2D:
00822                         case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
00823                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
00824                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
00825                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
00826                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
00827                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
00828                             glTexImage2D(imgtarget, i, internalFormat,
00829                                             w, h, getBorderWidth(),
00830                                             externalFormat, type,
00831                                             img->getData(i, frame, side));
00832                             break;
00833                         case GL_TEXTURE_3D:
00834                               TexImage3D(GL_TEXTURE_3D, i, internalFormat,
00835                                             w, h, d, getBorderWidth(),
00836                                             externalFormat, type,
00837                                             img->getData(i, frame, side));
00838                             break;
00839                        default:
00840                                 SFATAL << "TextureChunk::initialize1: unknown target "
00841                                        << imgtarget << "!!!" << std::endl;
00842                                 break;
00843                         }
00844                     }
00845                 }
00846                 defined = true;
00847             }
00848 
00849             if(! defined)
00850             {
00851                 // Nope, do we have SGIS_generate_mipmaps?
00852                 if(win->hasExtension(_sgisGenerateMipmap))
00853                 {
00854                     if(paramtarget != GL_NONE)
00855                         glTexParameteri(paramtarget, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
00856                         // same as GL_GENERATE_MIPMAP which is part of the standard since 1.4
00857                     glErr("TextureChunk::activate generate_mipmaps");
00858                     needMipmaps = false; // automagic does it
00859                 }
00860                 else
00861                 {
00862                     // Nope, try to use gluBuild?DMipmaps
00863                     void * data = NULL;
00864                     
00865                     // can we use it directly?
00866                     if(! osgispower2(width) ||
00867                          ! osgispower2(height) ||
00868                          ! osgispower2(depth)
00869                       )
00870                     {
00871                         // scale is only implemented for 2D
00872                         if(imgtarget != GL_TEXTURE_2D)
00873                         {
00874                             SWARNING << "TextureChunk::initialize: can't mipmap "
00875                                      << "non-2D textures that are not 2^x !!!"
00876                                      << std::endl;
00877                         }
00878                         else
00879                         {
00880                             UInt32 outw = osgnextpower2(width);
00881                             UInt32 outh = osgnextpower2(height);
00882 
00883                             data = malloc(outw * outh * img->getBpp());
00884                             
00885                             // should we scale to next power of 2?
00886                             if(doScale)
00887                             {
00888                                 GLint res = gluScaleImage(externalFormat,
00889                                                 width, height, type, img->getData(0, frame, side),
00890                                                 outw, outh, type, data);
00891 
00892                                 if(res)
00893                                 {
00894                                     SWARNING << "TextureChunk::initialize: "
00895                                              << "gluScaleImage failed: "
00896                                              << gluErrorString(res) << "("
00897                                              << res << ")!"
00898                                              << std::endl;
00899                                     free(data);
00900                                     data = NULL;
00901                                 }
00902                                 else
00903                                 {
00904                                     width = outw;
00905                                     height = outh;
00906                                 }
00907                             }
00908                             else // nope, just copy the image to the lower left part
00909                             {
00910                                 memset(data, 0, outw * outh * img->getBpp());
00911 
00912                                 UInt16 bpl = width * img->getBpp();
00913                                 UInt8 * src = (UInt8 *) img->getData(0, frame, side);
00914                                 UInt8 * dest= (UInt8 *) data;
00915 
00916                                 for(UInt32 y = 0; y < height; y++)
00917                                 {
00918                                     memcpy(dest, src, bpl);
00919 
00920                                     src  += bpl;
00921                                     dest += outw * img->getBpp();
00922                                 }
00923                                 width = outw;
00924                                 height = outh;
00925                             }
00926                         }
00927                     }
00928                     else
00929                         data = img->getData(0, frame, side);
00930                     
00931                     if(data)
00932                     {
00933                         switch (imgtarget)
00934                         {
00935                         case GL_TEXTURE_1D:
00936                                 gluBuild1DMipmaps(imgtarget, internalFormat, width,
00937                                                     externalFormat, type, data);
00938                                 break;
00939                         case GL_TEXTURE_2D:
00940                         case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
00941                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
00942                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
00943                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
00944                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
00945                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
00946                                 gluBuild2DMipmaps(imgtarget, internalFormat,
00947                                                     width, height,
00948                                                     externalFormat, type, data);
00949                                 break;
00950                         case GL_TEXTURE_3D:
00951 #  ifdef GLU_VERSION_1_3
00952                                 gluBuild3DMipmaps(imgtarget, internalFormat,
00953                                                     width, height, depth,
00954                                                     externalFormat, type, data);
00955 #  else
00956                                 FWARNING(("TextureChunk::initialize: 3d textures "
00957                                           "supported, but GLU version < 1.3, thus "
00958                                           "gluBuild3DMipmaps not supported!\n"));
00959 #  endif
00960                                 break;
00961                         default:
00962                                 SFATAL << "TextureChunk::initialize2: unknown target "
00963                                        << imgtarget << "!!!" << std::endl;
00964                         }
00965 
00966                         
00967                         if(data != img->getData(0, frame, side))
00968                             free(data);
00969                         defined = true;
00970                     } // data
00971                 } // need to use gluBuildMipmaps?
00972             } // got them from the image already?
00973         } // need mipmaps?
00974 
00975         // no mipmaps, or mipmapping failed?
00976         if(! defined)
00977         {
00978             // got here needing mipmaps?
00979             if(needMipmaps && paramtarget != GL_NONE)  // turn them off
00980                 glTexParameteri(paramtarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00981 
00982             void * data = NULL;
00983             UInt32 datasize = 0;
00984 
00985             // Do we need to massage the texture or can we just use it?
00986             if(imgtarget != GL_TEXTURE_RECTANGLE_ARB &&
00987                !win->hasExtension(_arbTextureNonPowerOfTwo) &&
00988                (!osgispower2(width) || !osgispower2(height) || !osgispower2(depth))
00989               )
00990             {
00991                 // No, need to scale or cut
00992                 
00993                 // should we scale to next power of 2?
00994                 if(doScale)
00995                 {
00996                     // scale is only implemented for 2D
00997                     if(imgtarget != GL_TEXTURE_2D &&
00998                        imgtarget != GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
00999                        imgtarget != GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB &&
01000                        imgtarget != GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB &&
01001                        imgtarget != GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB &&
01002                        imgtarget != GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB &&
01003                        imgtarget != GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
01004                       )
01005                     {
01006                         SWARNING << "TextureChunk::initialize: can't scale "
01007                                  << "non-2D textures that are not 2^x !!!"
01008                                  << std::endl;
01009                     }
01010                     else
01011                     {
01012                         UInt32 outw = osgnextpower2(width);
01013                         UInt32 outh = osgnextpower2(height);
01014 
01015                         data = malloc(outw * outh * img->getBpp());
01016                         datasize = outw * outh * img->getBpp();
01017                         
01018                         GLint res = gluScaleImage(externalFormat,
01019                                         width, height, type, 
01020                                         img->getData(0, frame, side),
01021                                         outw, outh, type, data);
01022 
01023                         if(res)
01024                         {
01025                             SWARNING << "TextureChunk::initialize: "
01026                                      << "gluScaleImage failed: "
01027                                      << gluErrorString(res) << "("
01028                                      << res << ")!" << std::endl;
01029                             free(data);
01030                             data = NULL;
01031                         }
01032                         else
01033                         {
01034                             width = outw;
01035                             height = outh;
01036                         }
01037                     }
01038                 
01039                 }
01040                 else // don't scale, just use ll corner
01041                 {
01042                    if(compressedData)
01043                    {
01044                        switch (imgtarget)
01045                        {
01046                        case GL_TEXTURE_1D:
01047                            CompressedTexImage1D(GL_TEXTURE_1D, 0, internalFormat,
01048                                            osgnextpower2(width), getBorderWidth(), 0, NULL);
01049                            CompressedTexSubImage1D(GL_TEXTURE_1D, 0, 0, width,
01050                                            externalFormat, 
01051                                            img->getFrameSize(), 
01052                                            img->getData(0, frame, side));
01053                            break;
01054                        case GL_TEXTURE_2D:
01055                            CompressedTexImage2D(imgtarget, 0, internalFormat,
01056                                            osgnextpower2(width),
01057                                            osgnextpower2(height), getBorderWidth(),
01058                                            0, NULL);
01059                            CompressedTexSubImage2D(imgtarget, 0, 0, 0, width, height,
01060                                            externalFormat,
01061                                            img->getFrameSize(), 
01062                                            img->getData(0, frame, side));
01063                            break;
01064                        case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01065                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01066                        case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01067                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01068                        case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01069                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01070                            CompressedTexImage2D(imgtarget, 0, internalFormat,
01071                                            osgnextpower2(width),
01072                                            osgnextpower2(height), getBorderWidth(),
01073                                            0, NULL);
01074                            CompressedTexSubImage2D(imgtarget, 0, 0, 0, width, height,
01075                                            externalFormat,
01076                                            (img->getSideCount() > 1) ? img->getSideSize() :
01077                                                 img->getFrameSize(), 
01078                                            img->getData(0, frame, side));
01079                            break;
01080                        case GL_TEXTURE_RECTANGLE_ARB:
01081                            CompressedTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, internalFormat,
01082                                            width, height, getBorderWidth(),
01083                                            img->getFrameSize(), 
01084                                            img->getData(0, frame, side));
01085                            break;
01086                        case GL_TEXTURE_3D:
01087                            CompressedTexImage3D(GL_TEXTURE_3D, 0, internalFormat,
01088                                            osgnextpower2(width),
01089                                            osgnextpower2(height),
01090                                            osgnextpower2(depth),
01091                                            getBorderWidth(), 0, NULL);
01092                            CompressedTexSubImage3D(GL_TEXTURE_3D, 0,  0, 0, 0,
01093                                            width, height, depth,
01094                                            externalFormat,
01095                                            img->getFrameSize(), 
01096                                            img->getData(0, frame, side));
01097                            break;
01098                        default:
01099                                SFATAL << "TextureChunk::initialize4: unknown target "
01100                                       << imgtarget << "!!!" << std::endl;
01101                        }
01102                    }
01103                    else
01104                    {
01105                        switch (imgtarget)
01106                        {
01107                        case GL_TEXTURE_1D:
01108                            glTexImage1D(GL_TEXTURE_1D, 0, internalFormat,
01109                                            osgnextpower2(width), getBorderWidth(),
01110                                            externalFormat, type,
01111                                            NULL);
01112                            glTexSubImage1D(GL_TEXTURE_1D, 0, 0, width,
01113                                            externalFormat, type,
01114                                             img->getData(0, frame, side));
01115                            break;
01116                        case GL_TEXTURE_2D:
01117                        case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01118                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01119                        case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01120                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01121                        case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01122                        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01123                            glTexImage2D(imgtarget, 0, internalFormat,
01124                                            osgnextpower2(width),
01125                                            osgnextpower2(height), getBorderWidth(),
01126                                            externalFormat, type,
01127                                            NULL);
01128                            glTexSubImage2D(imgtarget, 0, 0, 0, width, height,
01129                                            externalFormat, type,
01130                                            img->getData(0, frame, side));
01131                            break;
01132                        case GL_TEXTURE_RECTANGLE_ARB:
01133                            glTexImage2D( GL_TEXTURE_RECTANGLE_ARB, 0, internalFormat,
01134                                            width, height, getBorderWidth(),
01135                                            externalFormat, type,
01136                                            img->getData(0, frame, side));
01137                            break;
01138                        case GL_TEXTURE_3D:
01139                              TexImage3D(GL_TEXTURE_3D, 0, internalFormat,
01140                                            osgnextpower2(width),
01141                                            osgnextpower2(height),
01142                                            osgnextpower2(depth),
01143                                            getBorderWidth(), externalFormat, type, NULL);
01144                              TexSubImage3D(GL_TEXTURE_3D, 0,  0, 0, 0,
01145                                            width, height, depth,
01146                                            externalFormat, type,
01147                                            img->getData(0, frame, side));
01148                            break;
01149                        default:
01150                                SFATAL << "TextureChunk::initialize4: unknown target "
01151                                       << imgtarget << "!!!" << std::endl;
01152                        } // switch imgtarget
01153                    } // compressed data?
01154                        
01155                    defined = true;
01156                 } // do scale  
01157             } 
01158             else // can we use it directly?
01159             {
01160                data = img->getData(0, frame, side);
01161                datasize = (img->getSideCount() > 1) ? img->getSideSize() :
01162                                                       img->getFrameSize();
01163             } // can we use it directly?
01164             
01165             if(!defined) // either we can use the texture directly, or it was scaled
01166             {
01167                 // A image without data is quite handy if you need the
01168                 // texture only on the graphics card. So don't check for data here
01169                
01170                  if(compressedData)
01171                  {
01172                      switch (imgtarget)
01173                      {
01174                      case GL_TEXTURE_1D:
01175                          CompressedTexImage1D(GL_TEXTURE_1D, 0, internalFormat,
01176                                          width, getBorderWidth(),
01177                                          datasize, data);
01178                          break;
01179                      case GL_TEXTURE_2D:
01180                      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01181                      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01182                      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01183                      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01184                      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01185                      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01186                          CompressedTexImage2D(imgtarget, 0, internalFormat,
01187                                          width, height, getBorderWidth(),
01188                                           datasize, data);
01189                          break;
01190                      case GL_TEXTURE_RECTANGLE_ARB:
01191                          CompressedTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, internalFormat,
01192                                          width, height, getBorderWidth(),
01193                                          datasize, data);
01194                          break;
01195                      case GL_TEXTURE_3D:
01196                          CompressedTexImage3D(GL_TEXTURE_3D, 0, internalFormat,
01197                                          width, height, depth, getBorderWidth(),
01198                                          datasize, data);
01199                          break;
01200                      default:
01201                          SFATAL << "TextureChunk::initialize3: unknown target "
01202                                 << imgtarget << "!!!" << std::endl;
01203                      }
01204                  }
01205                  else
01206                  {
01207                         switch (imgtarget)
01208                         {
01209                         case GL_TEXTURE_1D:
01210                             glTexImage1D(GL_TEXTURE_1D, 0, internalFormat,
01211                                             width, getBorderWidth(),
01212                                             externalFormat, type,
01213                                             data);
01214                             break;
01215                         case GL_TEXTURE_2D:
01216                         case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01217                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01218                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01219                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01220                         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01221                         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01222                             glTexImage2D(imgtarget, 0, internalFormat,
01223                                             width, height, getBorderWidth(),
01224                                             externalFormat, type,
01225                                             data);
01226                             break;
01227                         case GL_TEXTURE_RECTANGLE_ARB:
01228                             glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, internalFormat,
01229                                             width, height, getBorderWidth(),
01230                                             externalFormat, type,
01231                                             data);
01232                             break;
01233                         case GL_TEXTURE_3D:
01234                               TexImage3D(GL_TEXTURE_3D, 0, internalFormat,
01235                                             width, height, depth, getBorderWidth(),
01236                                             externalFormat, type,
01237                                             data);
01238                             break;
01239                         default:
01240                             SFATAL << "TextureChunk::initialize3: unknown target "
01241                                    << imgtarget << "!!!" << std::endl;
01242                         }
01243                     }
01244                 
01245             }
01246 
01247             if(data != img->getData(0, frame, side))
01248                 free(data);
01249         }
01250 
01251         glErr("TextureChunk::initialize image");
01252     }
01253     else if(mode == Window::needrefresh)
01254     {
01255         void (OSG_APIENTRY*TexSubImage3D)
01256                           (GLenum target, GLint level, GLint xoffset,
01257                            GLint yoffset, GLint zoffset, GLsizei width,
01258                            GLsizei height, GLsizei depth, GLenum format,
01259                            GLenum type, const GLvoid *pixels) =
01260             (void (OSG_APIENTRY*)(GLenum target, GLint level, GLint xoffset,
01261                       GLint yoffset, GLint zoffset, GLsizei width,
01262                       GLsizei height, GLsizei depth, GLenum format,
01263                       GLenum type, const GLvoid *pixels))
01264             win->getFunction(_funcTexSubImage3D);
01265 
01266         void (OSG_APIENTRY*CompressedTexSubImage1D)
01267                           (GLenum target, GLint level, GLint xoffset, GLsizei width,
01268                            GLenum format, GLsizei imageSize, const GLvoid *pixels) =
01269             (void (OSG_APIENTRY*)(GLenum target, GLint level, GLint xoffset, GLsizei width,
01270                            GLenum format, GLsizei imageSize, const GLvoid *pixels))
01271             win->getFunction(_funcCompressedTexSubImage1D);
01272 
01273         void (OSG_APIENTRY*CompressedTexSubImage2D)
01274                           (GLenum target, GLint level, 
01275                            GLint xoffset, GLint yoffset, 
01276                            GLsizei width, GLsizei height, GLenum format,
01277                            GLsizei imageSize, const GLvoid *pixels) =
01278             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
01279                            GLint xoffset, GLint yoffset, 
01280                            GLsizei width, GLsizei height, GLenum format,
01281                            GLsizei imageSize, const GLvoid *pixels))
01282             win->getFunction(_funcCompressedTexSubImage2D);
01283 
01284         void (OSG_APIENTRY*CompressedTexSubImage3D)
01285                           (GLenum target, GLint level, 
01286                            GLint xoffset, GLint yoffset, GLint zoffset, 
01287                            GLsizei width, GLsizei height, GLsizei depth, 
01288                            GLenum format, GLsizei imageSize, const GLvoid *pixels) =
01289             (void (OSG_APIENTRY*)(GLenum target, GLint level, 
01290                            GLint xoffset, GLint yoffset, GLint zoffset, 
01291                            GLsizei width, GLsizei height, GLsizei depth, 
01292                            GLenum format, GLsizei imageSize, const GLvoid *pixels))
01293             win->getFunction(_funcCompressedTexSubImage3D);
01294 
01295         GLenum externalFormat = img->getPixelFormat();
01296         GLenum type           = img->getDataType();
01297         bool   compressedData = img->hasCompressedData();
01298         bool   has3DTex       = win->hasExtension(_extTex3D) ||
01299                                 win->getGLVersion() >= 0x0102;
01300         
01301         if(bindtarget == GL_TEXTURE_3D && !has3DTex)
01302         {
01303             FINFO(("3D textures not supported on Window %p!\n", win));
01304             return;
01305         }
01306 
01307         if(! img) // no image ?
01308             return;
01309 
01310         if(getExternalFormat() != GL_NONE)
01311             externalFormat = getExternalFormat();
01312 
01313         if(!getScale() || imgtarget == GL_TEXTURE_RECTANGLE_ARB
01314                        || win->hasExtension(_arbTextureNonPowerOfTwo) 
01315                        ||  (osgispower2(img->getWidth() ) &&
01316                             osgispower2(img->getHeight()) &&
01317                             osgispower2(img->getDepth() )
01318           )                )
01319         {
01320             // activate the texture
01321             glBindTexture(bindtarget, id);
01322 
01323             // Find out what to update
01324             UInt32 ix, ax, iy, ay, iz, az;
01325             ix = (getDirtyMinX()!=-1) ? getDirtyMinX() : 0;
01326             ax = (getDirtyMaxX()!=-1) ? getDirtyMaxX() : img->getWidth() - 1;
01327             iy = (getDirtyMinY()!=-1) ? getDirtyMinY() : 0;
01328             ay = (getDirtyMaxY()!=-1) ? getDirtyMaxY() : img->getHeight() - 1;
01329             iz = (getDirtyMinZ()!=-1) ? getDirtyMinZ() : 0;
01330             az = (getDirtyMaxZ()!=-1) ? getDirtyMaxZ() : img->getDepth() - 1;
01331             
01332             UInt32 w, h, d;
01333             w = ax - ix + 1;
01334             h = ay - iy + 1;
01335             d = az - iz + 1;
01336 
01337             if(w != img->getWidth())
01338                 glPixelStorei(GL_UNPACK_ROW_LENGTH,  img->getWidth());
01339             if(ix != 0)
01340                 glPixelStorei(GL_UNPACK_SKIP_PIXELS, ix);
01341             if(iy != 0)
01342                 glPixelStorei(GL_UNPACK_SKIP_ROWS,   iy);
01343             if(has3DTex && iz != 0)
01344                 glPixelStorei(GL_UNPACK_SKIP_IMAGES, iz);
01345             
01346             if(compressedData)
01347             {
01348                 switch (imgtarget)
01349                 {
01350                 case GL_TEXTURE_1D:
01351                     CompressedTexSubImage1D(GL_TEXTURE_1D, 0, ix, w,
01352                                     externalFormat, img->getFrameSize(),
01353                                     img->getData( 0, getFrame(), side ) );
01354                     break;
01355                 case GL_TEXTURE_2D:
01356                     CompressedTexSubImage2D(imgtarget, 0, ix, iy, w, h,
01357                                     externalFormat, img->getFrameSize(),
01358                                     img->getData( 0, getFrame(), side ) );
01359                     break;
01360                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01361                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01362                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01363                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01364                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01365                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01366                     CompressedTexSubImage2D(imgtarget, 0, ix, iy, w, h,
01367                                     externalFormat,     
01368                                     (img->getSideCount() > 1) ? img->getSideSize() :
01369                                                                 img->getFrameSize(), 
01370                                     img->getData( 0, getFrame(), side ) );
01371                     break;
01372                 case GL_TEXTURE_RECTANGLE_ARB:
01373                     CompressedTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 
01374                                     ix, iy, w, h,
01375                                     externalFormat, img->getFrameSize(),
01376                                     img->getData( 0, getFrame(), side ) );
01377                     break;
01378                 case GL_TEXTURE_3D:
01379                       CompressedTexSubImage3D(GL_TEXTURE_3D, 0,  ix, iy, iz,
01380                                     w, h, d,
01381                                     externalFormat, img->getFrameSize(),
01382                                     img->getData( 0, getFrame(), side ) );
01383                     break;
01384                 default:
01385                         SFATAL << "TextureChunk::refresh: unknown target "
01386                                << imgtarget << "!!!" << std::endl;
01387                 }
01388             }
01389             else
01390             {
01391                 switch (imgtarget)
01392                 {
01393                 case GL_TEXTURE_1D:
01394                     glTexSubImage1D(GL_TEXTURE_1D, 0, ix, w,
01395                                     externalFormat, type,
01396                                     img->getData( 0, getFrame(), side ) );
01397                     break;
01398                 case GL_TEXTURE_2D:
01399                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
01400                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
01401                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
01402                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
01403                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
01404                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
01405                     glTexSubImage2D(imgtarget, 0, ix, iy, w, h,
01406                                     externalFormat, type,
01407                                     img->getData( 0, getFrame(), side ) );
01408                     break;
01409                 case GL_TEXTURE_RECTANGLE_ARB:
01410                     glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,
01411                                     ix, iy, w, h,
01412                                     externalFormat, type,
01413                                     img->getData( 0, getFrame(), side ) );
01414                     break;
01415                 case GL_TEXTURE_3D:
01416                       TexSubImage3D(GL_TEXTURE_3D, 0,  ix, iy, iz,
01417                                     w, h, d,
01418                                     externalFormat, type,
01419                                     img->getData( 0, getFrame(), side ) );
01420                     break;
01421                 default:
01422                         SFATAL << "TextureChunk::refresh: unknown target "
01423                                << imgtarget << "!!!" << std::endl;
01424                 }
01425             }
01426 
01427 
01428             if(w != img->getWidth())
01429                 glPixelStorei(GL_UNPACK_ROW_LENGTH,  0);
01430             if(ix != 0)
01431                 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
01432             if(iy != 0)
01433                 glPixelStorei(GL_UNPACK_SKIP_ROWS,   0);
01434             if(has3DTex && iz != 0)
01435                 glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
01436            
01437             if(paramtarget != GL_NONE)
01438                 glTexParameterf(paramtarget, GL_TEXTURE_PRIORITY,
01439                                   getPriority());
01440         }
01441         else
01442         {
01443             SWARNING << "TextureChunk::refresh: not implemented yet for "
01444                      << "scaling!!!" << std::endl;
01445         }
01446 
01447         glErr("TextureChunk::refresh image");
01448     }
01449 }

void TextureChunk::handleTextureShader	(	Window *	win,
		GLenum	bindtarget
	)			`[protected, inherited]`

Texture handler. Create/update a single texture. Also used by derived CubeMap chunk.

Definition at line 400 of file OSGTextureChunk.cpp.

References osg::TextureChunk::_nvTextureShader, osg::TextureChunk::_nvTextureShader2, FINFO, FWARNING, osg::TextureChunkBase::getShaderConstEye(), osg::TextureChunkBase::getShaderCullModes(), osg::TextureChunkBase::getShaderInput(), osg::TextureChunkBase::getShaderOffsetBias(), osg::TextureChunkBase::getShaderOffsetMatrix(), osg::TextureChunkBase::getShaderOffsetScale(), osg::TextureChunkBase::getShaderOperation(), osg::TextureChunkBase::getShaderRGBADotProduct(), GL_CONST_EYE_NV, GL_CULL_MODES_NV, GL_OFFSET_TEXTURE_BIAS_NV, GL_OFFSET_TEXTURE_MATRIX_NV, GL_OFFSET_TEXTURE_SCALE_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_SHADER_CONSISTENT_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D, GL_TEXTURE_SHADER_NV, glErr, and osg::Window::hasExtension().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), and changeFrom().

00401 {
00402     if(!win->hasExtension(_nvTextureShader))
00403     {
00404         if(getShaderOperation() != GL_NONE)
00405             FINFO(("NV Texture Shaders not supported on Window %p!\n", win));
00406         return;
00407     }
00408 
00409     glErr("textureShader precheck");
00410 
00411     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV,
00412                 getShaderOperation());
00413 
00414     glErr("textureShader setup: operation");
00415 
00416     if(getShaderOperation() == GL_NONE)
00417         return;
00418 
00419     if(bindtarget == GL_TEXTURE_3D && !win->hasExtension(_nvTextureShader2))
00420     {
00421         FINFO(("NV Texture Shaders 2 not supported on Window %p!\n", win));
00422         return;
00423     }
00424 
00425     if(getShaderInput() != GL_NONE)
00426         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV,
00427                     getShaderInput());
00428 
00429     glErr("textureShader setup: input");
00430 
00431     if(getShaderRGBADotProduct() != GL_NONE)
00432         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV,
00433                     getShaderRGBADotProduct());
00434 
00435     glErr("textureShader setup: rgba dotprod");
00436 
00437     if(getShaderOffsetMatrix().size() == 4)
00438     {
00439         glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV,
00440                     (GLfloat*)&(getShaderOffsetMatrix()[0]));
00441 
00442         glErr("textureShader setup: offset matrix");
00443     }
00444     else if(getShaderOffsetMatrix().size() != 0)
00445     {
00446         FWARNING(("TextureChunk::handleTextureShader: shaderOffsetMatrix has"
00447                     " to have 4 entries, not %d!\n",
00448                     getShaderOffsetMatrix().size() ));
00449     }
00450 
00451     glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_SCALE_NV,
00452                 getShaderOffsetScale());
00453 
00454     glErr("textureShader setup: offset scale");
00455 
00456     glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_BIAS_NV,
00457                 getShaderOffsetBias());
00458 
00459     glErr("textureShader setup: offset bias");
00460 
00461     GLint cullmodes[4];
00462     if(getShaderCullModes() & 0x1)
00463     {
00464         cullmodes[0] = GL_GEQUAL;
00465     }
00466     else
00467     {
00468         cullmodes[0] = GL_LESS;
00469     }
00470 
00471     if(getShaderCullModes() & 0x2)
00472     {
00473         cullmodes[1] = GL_GEQUAL;
00474     }
00475     else
00476     {
00477         cullmodes[1] = GL_LESS;
00478     }
00479 
00480     if(getShaderCullModes() & 0x4)
00481     {
00482         cullmodes[2] = GL_GEQUAL;
00483     }
00484     else
00485     {
00486         cullmodes[2] = GL_LESS;
00487     }
00488 
00489     if(getShaderCullModes() & 0x8)
00490     {
00491         cullmodes[3] = GL_GEQUAL;
00492     }
00493     else
00494     {
00495         cullmodes[3] = GL_LESS;
00496     }
00497 
00498     glTexEnviv(GL_TEXTURE_SHADER_NV, GL_CULL_MODES_NV,
00499                     cullmodes);
00500 
00501     glErr("textureShader setup: cull modes");
00502 
00503     glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_CONST_EYE_NV,
00504                     getShaderConstEye().getValues());
00505 
00506     glErr("textureShader setup: const eye");
00507 
00508 
00509 
00510 #ifdef OSG_DEBUG
00511     GLint consistent;
00512     glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV,
00513           &consistent);
00514     if(!consistent)
00515     {
00516         FWARNING(("Texture shaders not consistent!\n"));
00517     }
00518 #endif
00519 }

void TextureChunk::initMethod ( void ) [static, protected, inherited]

Reimplemented from osg::StateChunk.

Definition at line 149 of file OSGTextureChunk.cpp.

00150 {
00151 }

SFImagePtr * osg::TextureChunkBase::getSFImage ( void ) [inline, inherited]

Definition at line 101 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfImage.

00102 {
00103     return &_sfImage;
00104 }

SFGLenum * osg::TextureChunkBase::getSFInternalFormat ( void ) [inline, inherited]

Definition at line 108 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfInternalFormat.

00109 {
00110     return &_sfInternalFormat;
00111 }

SFGLenum * osg::TextureChunkBase::getSFExternalFormat ( void ) [inline, inherited]

Definition at line 115 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfExternalFormat.

00116 {
00117     return &_sfExternalFormat;
00118 }

SFBool * osg::TextureChunkBase::getSFScale ( void ) [inline, inherited]

Definition at line 122 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfScale.

00123 {
00124     return &_sfScale;
00125 }

SFUInt32 * osg::TextureChunkBase::getSFFrame ( void ) [inline, inherited]

Definition at line 129 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfFrame.

00130 {
00131     return &_sfFrame;
00132 }

SFGLenum * osg::TextureChunkBase::getSFMinFilter ( void ) [inline, inherited]

Definition at line 136 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMinFilter.

00137 {
00138     return &_sfMinFilter;
00139 }

SFGLenum * osg::TextureChunkBase::getSFMagFilter ( void ) [inline, inherited]

Definition at line 143 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMagFilter.

00144 {
00145     return &_sfMagFilter;
00146 }

SFGLenum * osg::TextureChunkBase::getSFWrapS ( void ) [inline, inherited]

Definition at line 150 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapS.

00151 {
00152     return &_sfWrapS;
00153 }

SFGLenum * osg::TextureChunkBase::getSFWrapT ( void ) [inline, inherited]

Definition at line 157 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapT.

00158 {
00159     return &_sfWrapT;
00160 }

SFGLenum * osg::TextureChunkBase::getSFWrapR ( void ) [inline, inherited]

Definition at line 164 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapR.

00165 {
00166     return &_sfWrapR;
00167 }

SFGLenum * osg::TextureChunkBase::getSFEnvMode ( void ) [inline, inherited]

Definition at line 171 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvMode.

00172 {
00173     return &_sfEnvMode;
00174 }

SFColor4f * osg::TextureChunkBase::getSFEnvColor ( void ) [inline, inherited]

Definition at line 178 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvColor.

00179 {
00180     return &_sfEnvColor;
00181 }

SFGLenum * osg::TextureChunkBase::getSFEnvCombineRGB ( void ) [inline, inherited]

Definition at line 185 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineRGB.

00186 {
00187     return &_sfEnvCombineRGB;
00188 }

SFGLenum * osg::TextureChunkBase::getSFEnvCombineAlpha ( void ) [inline, inherited]

Definition at line 192 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineAlpha.

00193 {
00194     return &_sfEnvCombineAlpha;
00195 }

SFReal32 * osg::TextureChunkBase::getSFEnvScaleRGB ( void ) [inline, inherited]

Definition at line 199 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleRGB.

00200 {
00201     return &_sfEnvScaleRGB;
00202 }

SFReal32 * osg::TextureChunkBase::getSFEnvScaleAlpha ( void ) [inline, inherited]

Definition at line 206 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleAlpha.

00207 {
00208     return &_sfEnvScaleAlpha;
00209 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource0RGB ( void ) [inline, inherited]

Definition at line 213 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0RGB.

00214 {
00215     return &_sfEnvSource0RGB;
00216 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource1RGB ( void ) [inline, inherited]

Definition at line 220 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1RGB.

00221 {
00222     return &_sfEnvSource1RGB;
00223 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource2RGB ( void ) [inline, inherited]

Definition at line 227 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2RGB.

00228 {
00229     return &_sfEnvSource2RGB;
00230 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource0Alpha ( void ) [inline, inherited]

Definition at line 234 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0Alpha.

00235 {
00236     return &_sfEnvSource0Alpha;
00237 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource1Alpha ( void ) [inline, inherited]

Definition at line 241 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1Alpha.

00242 {
00243     return &_sfEnvSource1Alpha;
00244 }

SFGLenum * osg::TextureChunkBase::getSFEnvSource2Alpha ( void ) [inline, inherited]

Definition at line 248 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2Alpha.

00249 {
00250     return &_sfEnvSource2Alpha;
00251 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand0RGB ( void ) [inline, inherited]

Definition at line 255 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0RGB.

00256 {
00257     return &_sfEnvOperand0RGB;
00258 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand1RGB ( void ) [inline, inherited]

Definition at line 262 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1RGB.

00263 {
00264     return &_sfEnvOperand1RGB;
00265 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand2RGB ( void ) [inline, inherited]

Definition at line 269 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2RGB.

00270 {
00271     return &_sfEnvOperand2RGB;
00272 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand0Alpha ( void ) [inline, inherited]

Definition at line 276 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0Alpha.

00277 {
00278     return &_sfEnvOperand0Alpha;
00279 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand1Alpha ( void ) [inline, inherited]

Definition at line 283 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1Alpha.

00284 {
00285     return &_sfEnvOperand1Alpha;
00286 }

SFGLenum * osg::TextureChunkBase::getSFEnvOperand2Alpha ( void ) [inline, inherited]

Definition at line 290 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2Alpha.

00291 {
00292     return &_sfEnvOperand2Alpha;
00293 }

SFGLenum * osg::TextureChunkBase::getSFGLId ( void ) [inline, inherited]

Definition at line 297 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfGLId.

00298 {
00299     return &_sfGLId;
00300 }

SFInt32 * osg::TextureChunkBase::getSFIgnoreGLForAspect ( void ) [inline, inherited]

Definition at line 304 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfIgnoreGLForAspect.

00305 {
00306     return &_sfIgnoreGLForAspect;
00307 }

SFBool * osg::TextureChunkBase::getSFPointSprite ( void ) [inline, inherited]

Definition at line 311 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPointSprite.

00312 {
00313     return &_sfPointSprite;
00314 }

SFReal32 * osg::TextureChunkBase::getSFPriority ( void ) [inline, inherited]

Definition at line 318 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPriority.

00319 {
00320     return &_sfPriority;
00321 }

SFGLenum * osg::TextureChunkBase::getSFShaderOperation ( void ) [inline, inherited]

Definition at line 325 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOperation.

00326 {
00327     return &_sfShaderOperation;
00328 }

SFGLenum * osg::TextureChunkBase::getSFShaderInput ( void ) [inline, inherited]

Definition at line 332 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderInput.

00333 {
00334     return &_sfShaderInput;
00335 }

MFReal32 * osg::TextureChunkBase::getMFShaderOffsetMatrix ( void ) [inline, inherited]

Definition at line 339 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_mfShaderOffsetMatrix.

00340 {
00341     return &_mfShaderOffsetMatrix;
00342 }

SFReal32 * osg::TextureChunkBase::getSFShaderOffsetScale ( void ) [inline, inherited]

Definition at line 346 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetScale.

00347 {
00348     return &_sfShaderOffsetScale;
00349 }

SFReal32 * osg::TextureChunkBase::getSFShaderOffsetBias ( void ) [inline, inherited]

Definition at line 353 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetBias.

00354 {
00355     return &_sfShaderOffsetBias;
00356 }

SFGLenum * osg::TextureChunkBase::getSFShaderRGBADotProduct ( void ) [inline, inherited]

Definition at line 360 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderRGBADotProduct.

00361 {
00362     return &_sfShaderRGBADotProduct;
00363 }

SFUInt8 * osg::TextureChunkBase::getSFShaderCullModes ( void ) [inline, inherited]

Definition at line 367 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderCullModes.

00368 {
00369     return &_sfShaderCullModes;
00370 }

SFVec3f * osg::TextureChunkBase::getSFShaderConstEye ( void ) [inline, inherited]

Definition at line 374 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderConstEye.

00375 {
00376     return &_sfShaderConstEye;
00377 }

SFReal32 * osg::TextureChunkBase::getSFLodBias ( void ) [inline, inherited]

Definition at line 381 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfLodBias.

00382 {
00383     return &_sfLodBias;
00384 }

SFGLenum * osg::TextureChunkBase::getSFTarget ( void ) [inline, inherited]

Definition at line 388 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfTarget.

00389 {
00390     return &_sfTarget;
00391 }

SFInt32 * osg::TextureChunkBase::getSFDirtyLeft ( void ) [inline, inherited]

Definition at line 395 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyLeft.

00396 {
00397     return &_sfDirtyLeft;
00398 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMinX ( void ) [inline, inherited]

Definition at line 402 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinX.

00403 {
00404     return &_sfDirtyMinX;
00405 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMaxX ( void ) [inline, inherited]

Definition at line 409 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxX.

00410 {
00411     return &_sfDirtyMaxX;
00412 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMinY ( void ) [inline, inherited]

Definition at line 416 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinY.

00417 {
00418     return &_sfDirtyMinY;
00419 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMaxY ( void ) [inline, inherited]

Definition at line 423 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxY.

00424 {
00425     return &_sfDirtyMaxY;
00426 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMinZ ( void ) [inline, inherited]

Definition at line 430 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinZ.

00431 {
00432     return &_sfDirtyMinZ;
00433 }

SFInt32 * osg::TextureChunkBase::getSFDirtyMaxZ ( void ) [inline, inherited]

Definition at line 437 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxZ.

00438 {
00439     return &_sfDirtyMaxZ;
00440 }

SFReal32 * osg::TextureChunkBase::getSFAnisotropy ( void ) [inline, inherited]

Definition at line 444 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfAnisotropy.

00445 {
00446     return &_sfAnisotropy;
00447 }

SFColor4f * osg::TextureChunkBase::getSFBorderColor ( void ) [inline, inherited]

Definition at line 451 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderColor.

00452 {
00453     return &_sfBorderColor;
00454 }

SFUInt32 * osg::TextureChunkBase::getSFBorderWidth ( void ) [inline, inherited]

Definition at line 458 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderWidth.

00459 {
00460     return &_sfBorderWidth;
00461 }

SFUInt32 * osg::TextureChunkBase::getSFNPOTMatrixScale ( void ) [inline, inherited]

Definition at line 465 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfNPOTMatrixScale.

00466 {
00467     return &_sfNPOTMatrixScale;
00468 }

ImagePtr & osg::TextureChunkBase::getImage ( void ) [inline, inherited]

Definition at line 473 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), osg::TextureChunk::handleGL(), handleGL(), and osg::TextureChunk::operator==().

00474 {
00475     return _sfImage.getValue();
00476 }

const ImagePtr & osg::TextureChunkBase::getImage ( void ) const [inline, inherited]

Definition at line 480 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfImage, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00481 {
00482     return _sfImage.getValue();
00483 }

GLenum & osg::TextureChunkBase::getInternalFormat ( void ) [inline, inherited]

Definition at line 494 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfInternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

00495 {
00496     return _sfInternalFormat.getValue();
00497 }

const GLenum & osg::TextureChunkBase::getInternalFormat ( void ) const [inline, inherited]

Definition at line 501 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfInternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00502 {
00503     return _sfInternalFormat.getValue();
00504 }

GLenum & osg::TextureChunkBase::getExternalFormat ( void ) [inline, inherited]

Definition at line 515 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfExternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

00516 {
00517     return _sfExternalFormat.getValue();
00518 }

const GLenum & osg::TextureChunkBase::getExternalFormat ( void ) const [inline, inherited]

Definition at line 522 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfExternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00523 {
00524     return _sfExternalFormat.getValue();
00525 }

bool & osg::TextureChunkBase::getScale ( void ) [inline, inherited]

Definition at line 536 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), and osg::TextureChunk::handleTexture().

00537 {
00538     return _sfScale.getValue();
00539 }

const bool & osg::TextureChunkBase::getScale ( void ) const [inline, inherited]

Definition at line 543 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00544 {
00545     return _sfScale.getValue();
00546 }

UInt32 & osg::TextureChunkBase::getFrame ( void ) [inline, inherited]

Definition at line 557 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfFrame, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

00558 {
00559     return _sfFrame.getValue();
00560 }

const UInt32 & osg::TextureChunkBase::getFrame ( void ) const [inline, inherited]

Definition at line 564 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfFrame, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00565 {
00566     return _sfFrame.getValue();
00567 }

GLenum & osg::TextureChunkBase::getMinFilter ( void ) [inline, inherited]

Definition at line 578 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMinFilter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::changed(), osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

00579 {
00580     return _sfMinFilter.getValue();
00581 }

const GLenum & osg::TextureChunkBase::getMinFilter ( void ) const [inline, inherited]

Definition at line 585 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMinFilter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00586 {
00587     return _sfMinFilter.getValue();
00588 }

GLenum & osg::TextureChunkBase::getMagFilter ( void ) [inline, inherited]

Definition at line 599 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMagFilter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

00600 {
00601     return _sfMagFilter.getValue();
00602 }

const GLenum & osg::TextureChunkBase::getMagFilter ( void ) const [inline, inherited]

Definition at line 606 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMagFilter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00607 {
00608     return _sfMagFilter.getValue();
00609 }

GLenum & osg::TextureChunkBase::getWrapS ( void ) [inline, inherited]

Definition at line 620 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapS, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

00621 {
00622     return _sfWrapS.getValue();
00623 }

const GLenum & osg::TextureChunkBase::getWrapS ( void ) const [inline, inherited]

Definition at line 627 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapS, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00628 {
00629     return _sfWrapS.getValue();
00630 }

GLenum & osg::TextureChunkBase::getWrapT ( void ) [inline, inherited]

Definition at line 641 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapT, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

00642 {
00643     return _sfWrapT.getValue();
00644 }

const GLenum & osg::TextureChunkBase::getWrapT ( void ) const [inline, inherited]

Definition at line 648 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapT, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00649 {
00650     return _sfWrapT.getValue();
00651 }

GLenum & osg::TextureChunkBase::getWrapR ( void ) [inline, inherited]

Definition at line 662 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapR, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

00663 {
00664     return _sfWrapR.getValue();
00665 }

const GLenum & osg::TextureChunkBase::getWrapR ( void ) const [inline, inherited]

Definition at line 669 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapR, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00670 {
00671     return _sfWrapR.getValue();
00672 }

GLenum & osg::TextureChunkBase::getEnvMode ( void ) [inline, inherited]

Definition at line 683 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvMode, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00684 {
00685     return _sfEnvMode.getValue();
00686 }

const GLenum & osg::TextureChunkBase::getEnvMode ( void ) const [inline, inherited]

Definition at line 690 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvMode, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00691 {
00692     return _sfEnvMode.getValue();
00693 }

Color4f & osg::TextureChunkBase::getEnvColor ( void ) [inline, inherited]

Definition at line 704 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvColor, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), and changeFrom().

00705 {
00706     return _sfEnvColor.getValue();
00707 }

const Color4f & osg::TextureChunkBase::getEnvColor ( void ) const [inline, inherited]

Definition at line 711 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvColor, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00712 {
00713     return _sfEnvColor.getValue();
00714 }

GLenum & osg::TextureChunkBase::getEnvCombineRGB ( void ) [inline, inherited]

Definition at line 725 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineRGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00726 {
00727     return _sfEnvCombineRGB.getValue();
00728 }

const GLenum & osg::TextureChunkBase::getEnvCombineRGB ( void ) const [inline, inherited]

Definition at line 732 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineRGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00733 {
00734     return _sfEnvCombineRGB.getValue();
00735 }

GLenum & osg::TextureChunkBase::getEnvCombineAlpha ( void ) [inline, inherited]

Definition at line 746 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00747 {
00748     return _sfEnvCombineAlpha.getValue();
00749 }

const GLenum & osg::TextureChunkBase::getEnvCombineAlpha ( void ) const [inline, inherited]

Definition at line 753 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00754 {
00755     return _sfEnvCombineAlpha.getValue();
00756 }

Real32 & osg::TextureChunkBase::getEnvScaleRGB ( void ) [inline, inherited]

Definition at line 767 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleRGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00768 {
00769     return _sfEnvScaleRGB.getValue();
00770 }

const Real32 & osg::TextureChunkBase::getEnvScaleRGB ( void ) const [inline, inherited]

Definition at line 774 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleRGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00775 {
00776     return _sfEnvScaleRGB.getValue();
00777 }

Real32 & osg::TextureChunkBase::getEnvScaleAlpha ( void ) [inline, inherited]

Definition at line 788 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00789 {
00790     return _sfEnvScaleAlpha.getValue();
00791 }

const Real32 & osg::TextureChunkBase::getEnvScaleAlpha ( void ) const [inline, inherited]

Definition at line 795 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00796 {
00797     return _sfEnvScaleAlpha.getValue();
00798 }

GLenum & osg::TextureChunkBase::getEnvSource0RGB ( void ) [inline, inherited]

Definition at line 809 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00810 {
00811     return _sfEnvSource0RGB.getValue();
00812 }

const GLenum & osg::TextureChunkBase::getEnvSource0RGB ( void ) const [inline, inherited]

Definition at line 816 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00817 {
00818     return _sfEnvSource0RGB.getValue();
00819 }

GLenum & osg::TextureChunkBase::getEnvSource1RGB ( void ) [inline, inherited]

Definition at line 830 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00831 {
00832     return _sfEnvSource1RGB.getValue();
00833 }

const GLenum & osg::TextureChunkBase::getEnvSource1RGB ( void ) const [inline, inherited]

Definition at line 837 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00838 {
00839     return _sfEnvSource1RGB.getValue();
00840 }

GLenum & osg::TextureChunkBase::getEnvSource2RGB ( void ) [inline, inherited]

Definition at line 851 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00852 {
00853     return _sfEnvSource2RGB.getValue();
00854 }

const GLenum & osg::TextureChunkBase::getEnvSource2RGB ( void ) const [inline, inherited]

Definition at line 858 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00859 {
00860     return _sfEnvSource2RGB.getValue();
00861 }

GLenum & osg::TextureChunkBase::getEnvSource0Alpha ( void ) [inline, inherited]

Definition at line 872 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00873 {
00874     return _sfEnvSource0Alpha.getValue();
00875 }

const GLenum & osg::TextureChunkBase::getEnvSource0Alpha ( void ) const [inline, inherited]

Definition at line 879 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00880 {
00881     return _sfEnvSource0Alpha.getValue();
00882 }

GLenum & osg::TextureChunkBase::getEnvSource1Alpha ( void ) [inline, inherited]

Definition at line 893 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00894 {
00895     return _sfEnvSource1Alpha.getValue();
00896 }

const GLenum & osg::TextureChunkBase::getEnvSource1Alpha ( void ) const [inline, inherited]

Definition at line 900 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00901 {
00902     return _sfEnvSource1Alpha.getValue();
00903 }

GLenum & osg::TextureChunkBase::getEnvSource2Alpha ( void ) [inline, inherited]

Definition at line 914 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00915 {
00916     return _sfEnvSource2Alpha.getValue();
00917 }

const GLenum & osg::TextureChunkBase::getEnvSource2Alpha ( void ) const [inline, inherited]

Definition at line 921 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00922 {
00923     return _sfEnvSource2Alpha.getValue();
00924 }

GLenum & osg::TextureChunkBase::getEnvOperand0RGB ( void ) [inline, inherited]

Definition at line 935 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00936 {
00937     return _sfEnvOperand0RGB.getValue();
00938 }

const GLenum & osg::TextureChunkBase::getEnvOperand0RGB ( void ) const [inline, inherited]

Definition at line 942 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00943 {
00944     return _sfEnvOperand0RGB.getValue();
00945 }

GLenum & osg::TextureChunkBase::getEnvOperand1RGB ( void ) [inline, inherited]

Definition at line 956 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00957 {
00958     return _sfEnvOperand1RGB.getValue();
00959 }

const GLenum & osg::TextureChunkBase::getEnvOperand1RGB ( void ) const [inline, inherited]

Definition at line 963 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00964 {
00965     return _sfEnvOperand1RGB.getValue();
00966 }

GLenum & osg::TextureChunkBase::getEnvOperand2RGB ( void ) [inline, inherited]

Definition at line 977 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00978 {
00979     return _sfEnvOperand2RGB.getValue();
00980 }

const GLenum & osg::TextureChunkBase::getEnvOperand2RGB ( void ) const [inline, inherited]

Definition at line 984 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00985 {
00986     return _sfEnvOperand2RGB.getValue();
00987 }

GLenum & osg::TextureChunkBase::getEnvOperand0Alpha ( void ) [inline, inherited]

Definition at line 998 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

00999 {
01000     return _sfEnvOperand0Alpha.getValue();
01001 }

const GLenum & osg::TextureChunkBase::getEnvOperand0Alpha ( void ) const [inline, inherited]

Definition at line 1005 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01006 {
01007     return _sfEnvOperand0Alpha.getValue();
01008 }

GLenum & osg::TextureChunkBase::getEnvOperand1Alpha ( void ) [inline, inherited]

Definition at line 1019 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

01020 {
01021     return _sfEnvOperand1Alpha.getValue();
01022 }

const GLenum & osg::TextureChunkBase::getEnvOperand1Alpha ( void ) const [inline, inherited]

Definition at line 1026 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01027 {
01028     return _sfEnvOperand1Alpha.getValue();
01029 }

GLenum & osg::TextureChunkBase::getEnvOperand2Alpha ( void ) [inline, inherited]

Definition at line 1040 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::operator==().

01041 {
01042     return _sfEnvOperand2Alpha.getValue();
01043 }

const GLenum & osg::TextureChunkBase::getEnvOperand2Alpha ( void ) const [inline, inherited]

Definition at line 1047 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01048 {
01049     return _sfEnvOperand2Alpha.getValue();
01050 }

GLenum & osg::TextureChunkBase::getGLId ( void ) [inline, inherited]

Definition at line 1061 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfGLId, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changed(), osg::TextureChunk::changeFrom(), changeFrom(), and osg::TextureChunk::onDestroy().

01062 {
01063     return _sfGLId.getValue();
01064 }

const GLenum & osg::TextureChunkBase::getGLId ( void ) const [inline, inherited]

Definition at line 1068 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfGLId, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01069 {
01070     return _sfGLId.getValue();
01071 }

Int32 & osg::TextureChunkBase::getIgnoreGLForAspect ( void ) [inline, inherited]

Definition at line 1082 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfIgnoreGLForAspect, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01083 {
01084     return _sfIgnoreGLForAspect.getValue();
01085 }

const Int32 & osg::TextureChunkBase::getIgnoreGLForAspect ( void ) const [inline, inherited]

Definition at line 1089 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfIgnoreGLForAspect, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01090 {
01091     return _sfIgnoreGLForAspect.getValue();
01092 }

bool & osg::TextureChunkBase::getPointSprite ( void ) [inline, inherited]

Definition at line 1103 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPointSprite, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), and deactivate().

01104 {
01105     return _sfPointSprite.getValue();
01106 }

const bool & osg::TextureChunkBase::getPointSprite ( void ) const [inline, inherited]

Definition at line 1110 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPointSprite, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01111 {
01112     return _sfPointSprite.getValue();
01113 }

Real32 & osg::TextureChunkBase::getPriority ( void ) [inline, inherited]

Definition at line 1124 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPriority, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::operator==().

01125 {
01126     return _sfPriority.getValue();
01127 }

const Real32 & osg::TextureChunkBase::getPriority ( void ) const [inline, inherited]

Definition at line 1131 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPriority, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01132 {
01133     return _sfPriority.getValue();
01134 }

GLenum & osg::TextureChunkBase::getShaderOperation ( void ) [inline, inherited]

Definition at line 1145 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOperation, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), deactivate(), and osg::TextureChunk::handleTextureShader().

01146 {
01147     return _sfShaderOperation.getValue();
01148 }

const GLenum & osg::TextureChunkBase::getShaderOperation ( void ) const [inline, inherited]

Definition at line 1152 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOperation, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01153 {
01154     return _sfShaderOperation.getValue();
01155 }

GLenum & osg::TextureChunkBase::getShaderInput ( void ) [inline, inherited]

Definition at line 1166 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderInput, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01167 {
01168     return _sfShaderInput.getValue();
01169 }

const GLenum & osg::TextureChunkBase::getShaderInput ( void ) const [inline, inherited]

Definition at line 1173 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderInput, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01174 {
01175     return _sfShaderInput.getValue();
01176 }

Real32 & osg::TextureChunkBase::getShaderOffsetScale ( void ) [inline, inherited]

Definition at line 1187 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01188 {
01189     return _sfShaderOffsetScale.getValue();
01190 }

const Real32 & osg::TextureChunkBase::getShaderOffsetScale ( void ) const [inline, inherited]

Definition at line 1194 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01195 {
01196     return _sfShaderOffsetScale.getValue();
01197 }

Real32 & osg::TextureChunkBase::getShaderOffsetBias ( void ) [inline, inherited]

Definition at line 1208 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetBias, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01209 {
01210     return _sfShaderOffsetBias.getValue();
01211 }

const Real32 & osg::TextureChunkBase::getShaderOffsetBias ( void ) const [inline, inherited]

Definition at line 1215 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetBias, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01216 {
01217     return _sfShaderOffsetBias.getValue();
01218 }

GLenum & osg::TextureChunkBase::getShaderRGBADotProduct ( void ) [inline, inherited]

Definition at line 1229 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderRGBADotProduct, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01230 {
01231     return _sfShaderRGBADotProduct.getValue();
01232 }

const GLenum & osg::TextureChunkBase::getShaderRGBADotProduct ( void ) const [inline, inherited]

Definition at line 1236 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderRGBADotProduct, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01237 {
01238     return _sfShaderRGBADotProduct.getValue();
01239 }

UInt8 & osg::TextureChunkBase::getShaderCullModes ( void ) [inline, inherited]

Definition at line 1250 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderCullModes, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01251 {
01252     return _sfShaderCullModes.getValue();
01253 }

const UInt8 & osg::TextureChunkBase::getShaderCullModes ( void ) const [inline, inherited]

Definition at line 1257 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderCullModes, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01258 {
01259     return _sfShaderCullModes.getValue();
01260 }

Vec3f & osg::TextureChunkBase::getShaderConstEye ( void ) [inline, inherited]

Definition at line 1271 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderConstEye, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTextureShader().

01272 {
01273     return _sfShaderConstEye.getValue();
01274 }

const Vec3f & osg::TextureChunkBase::getShaderConstEye ( void ) const [inline, inherited]

Definition at line 1278 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderConstEye, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01279 {
01280     return _sfShaderConstEye.getValue();
01281 }

Real32 & osg::TextureChunkBase::getLodBias ( void ) [inline, inherited]

Definition at line 1292 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfLodBias, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), and deactivate().

01293 {
01294     return _sfLodBias.getValue();
01295 }

const Real32 & osg::TextureChunkBase::getLodBias ( void ) const [inline, inherited]

Definition at line 1299 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfLodBias, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01300 {
01301     return _sfLodBias.getValue();
01302 }

GLenum & osg::TextureChunkBase::getTarget ( void ) [inline, inherited]

Definition at line 1313 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfTarget, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::TextureChunk::deactivate(), and osg::TextureChunk::handleGL().

01314 {
01315     return _sfTarget.getValue();
01316 }

const GLenum & osg::TextureChunkBase::getTarget ( void ) const [inline, inherited]

Definition at line 1320 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfTarget, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01321 {
01322     return _sfTarget.getValue();
01323 }

Int32 & osg::TextureChunkBase::getDirtyLeft ( void ) [inline, inherited]

Definition at line 1334 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyLeft, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01335 {
01336     return _sfDirtyLeft.getValue();
01337 }

const Int32 & osg::TextureChunkBase::getDirtyLeft ( void ) const [inline, inherited]

Definition at line 1341 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyLeft, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01342 {
01343     return _sfDirtyLeft.getValue();
01344 }

Int32 & osg::TextureChunkBase::getDirtyMinX ( void ) [inline, inherited]

Definition at line 1355 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinX, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01356 {
01357     return _sfDirtyMinX.getValue();
01358 }

const Int32 & osg::TextureChunkBase::getDirtyMinX ( void ) const [inline, inherited]

Definition at line 1362 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinX, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01363 {
01364     return _sfDirtyMinX.getValue();
01365 }

Int32 & osg::TextureChunkBase::getDirtyMaxX ( void ) [inline, inherited]

Definition at line 1376 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxX, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01377 {
01378     return _sfDirtyMaxX.getValue();
01379 }

const Int32 & osg::TextureChunkBase::getDirtyMaxX ( void ) const [inline, inherited]

Definition at line 1383 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxX, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01384 {
01385     return _sfDirtyMaxX.getValue();
01386 }

Int32 & osg::TextureChunkBase::getDirtyMinY ( void ) [inline, inherited]

Definition at line 1397 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinY, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01398 {
01399     return _sfDirtyMinY.getValue();
01400 }

const Int32 & osg::TextureChunkBase::getDirtyMinY ( void ) const [inline, inherited]

Definition at line 1404 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinY, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01405 {
01406     return _sfDirtyMinY.getValue();
01407 }

Int32 & osg::TextureChunkBase::getDirtyMaxY ( void ) [inline, inherited]

Definition at line 1418 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxY, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01419 {
01420     return _sfDirtyMaxY.getValue();
01421 }

const Int32 & osg::TextureChunkBase::getDirtyMaxY ( void ) const [inline, inherited]

Definition at line 1425 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxY, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01426 {
01427     return _sfDirtyMaxY.getValue();
01428 }

Int32 & osg::TextureChunkBase::getDirtyMinZ ( void ) [inline, inherited]

Definition at line 1439 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinZ, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01440 {
01441     return _sfDirtyMinZ.getValue();
01442 }

const Int32 & osg::TextureChunkBase::getDirtyMinZ ( void ) const [inline, inherited]

Definition at line 1446 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinZ, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01447 {
01448     return _sfDirtyMinZ.getValue();
01449 }

Int32 & osg::TextureChunkBase::getDirtyMaxZ ( void ) [inline, inherited]

Definition at line 1460 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxZ, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01461 {
01462     return _sfDirtyMaxZ.getValue();
01463 }

const Int32 & osg::TextureChunkBase::getDirtyMaxZ ( void ) const [inline, inherited]

Definition at line 1467 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxZ, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01468 {
01469     return _sfDirtyMaxZ.getValue();
01470 }

Real32 & osg::TextureChunkBase::getAnisotropy ( void ) [inline, inherited]

Definition at line 1481 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfAnisotropy, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01482 {
01483     return _sfAnisotropy.getValue();
01484 }

const Real32 & osg::TextureChunkBase::getAnisotropy ( void ) const [inline, inherited]

Definition at line 1488 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfAnisotropy, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01489 {
01490     return _sfAnisotropy.getValue();
01491 }

Color4f & osg::TextureChunkBase::getBorderColor ( void ) [inline, inherited]

Definition at line 1502 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderColor, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01503 {
01504     return _sfBorderColor.getValue();
01505 }

const Color4f & osg::TextureChunkBase::getBorderColor ( void ) const [inline, inherited]

Definition at line 1509 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderColor, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01510 {
01511     return _sfBorderColor.getValue();
01512 }

UInt32 & osg::TextureChunkBase::getBorderWidth ( void ) [inline, inherited]

Definition at line 1523 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderWidth, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::handleTexture().

01524 {
01525     return _sfBorderWidth.getValue();
01526 }

const UInt32 & osg::TextureChunkBase::getBorderWidth ( void ) const [inline, inherited]

Definition at line 1530 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderWidth, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01531 {
01532     return _sfBorderWidth.getValue();
01533 }

UInt32 & osg::TextureChunkBase::getNPOTMatrixScale ( void ) [inline, inherited]

Definition at line 1544 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfNPOTMatrixScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), and osg::TextureChunk::operator==().

01545 {
01546     return _sfNPOTMatrixScale.getValue();
01547 }

const UInt32 & osg::TextureChunkBase::getNPOTMatrixScale ( void ) const [inline, inherited]

Definition at line 1551 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfNPOTMatrixScale, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

01552 {
01553     return _sfNPOTMatrixScale.getValue();
01554 }

Real32 & osg::TextureChunkBase::getShaderOffsetMatrix ( const UInt32 index ) [inline, inherited]

Definition at line 1566 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_mfShaderOffsetMatrix.

01567 {
01568     return _mfShaderOffsetMatrix[index];
01569 }

MFReal32 & osg::TextureChunkBase::getShaderOffsetMatrix ( void ) [inline, inherited]

Definition at line 1573 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_mfShaderOffsetMatrix.

Referenced by osg::TextureChunk::handleTextureShader(), and osg::TextureChunk::setShaderOffsetMatrix().

01574 {
01575     return _mfShaderOffsetMatrix;
01576 }

const MFReal32 & osg::TextureChunkBase::getShaderOffsetMatrix ( void ) const [inline, inherited]

Definition at line 1580 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_mfShaderOffsetMatrix.

01581 {
01582     return _mfShaderOffsetMatrix;
01583 }

void osg::TextureChunkBase::setInternalFormat ( const GLenum & value ) [inline, inherited]

Definition at line 508 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfInternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00509 {
00510     _sfInternalFormat.setValue(value);
00511 }

void osg::TextureChunkBase::setExternalFormat ( const GLenum & value ) [inline, inherited]

Definition at line 529 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfExternalFormat, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00530 {
00531     _sfExternalFormat.setValue(value);
00532 }

void osg::TextureChunkBase::setScale ( const bool & value ) [inline, inherited]

Definition at line 550 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfScale, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00551 {
00552     _sfScale.setValue(value);
00553 }

void osg::TextureChunkBase::setFrame ( const UInt32 & value ) [inline, inherited]

Definition at line 571 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfFrame, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00572 {
00573     _sfFrame.setValue(value);
00574 }

void osg::TextureChunkBase::setMinFilter ( const GLenum & value ) [inline, inherited]

Definition at line 592 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMinFilter, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00593 {
00594     _sfMinFilter.setValue(value);
00595 }

void osg::TextureChunkBase::setMagFilter ( const GLenum & value ) [inline, inherited]

Definition at line 613 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfMagFilter, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00614 {
00615     _sfMagFilter.setValue(value);
00616 }

void osg::TextureChunkBase::setWrapS ( const GLenum & value ) [inline, inherited]

Definition at line 634 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapS, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00635 {
00636     _sfWrapS.setValue(value);
00637 }

void osg::TextureChunkBase::setWrapT ( const GLenum & value ) [inline, inherited]

Definition at line 655 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapT, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00656 {
00657     _sfWrapT.setValue(value);
00658 }

void osg::TextureChunkBase::setWrapR ( const GLenum & value ) [inline, inherited]

Definition at line 676 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfWrapR, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00677 {
00678     _sfWrapR.setValue(value);
00679 }

void osg::TextureChunkBase::setEnvMode ( const GLenum & value ) [inline, inherited]

Definition at line 697 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvMode, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00698 {
00699     _sfEnvMode.setValue(value);
00700 }

void osg::TextureChunkBase::setEnvColor ( const Color4f & value ) [inline, inherited]

Definition at line 718 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvColor, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00719 {
00720     _sfEnvColor.setValue(value);
00721 }

void osg::TextureChunkBase::setEnvCombineRGB ( const GLenum & value ) [inline, inherited]

Definition at line 739 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineRGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00740 {
00741     _sfEnvCombineRGB.setValue(value);
00742 }

void osg::TextureChunkBase::setEnvCombineAlpha ( const GLenum & value ) [inline, inherited]

Definition at line 760 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvCombineAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00761 {
00762     _sfEnvCombineAlpha.setValue(value);
00763 }

void osg::TextureChunkBase::setEnvScaleRGB ( const Real32 & value ) [inline, inherited]

Definition at line 781 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleRGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00782 {
00783     _sfEnvScaleRGB.setValue(value);
00784 }

void osg::TextureChunkBase::setEnvScaleAlpha ( const Real32 & value ) [inline, inherited]

Definition at line 802 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvScaleAlpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00803 {
00804     _sfEnvScaleAlpha.setValue(value);
00805 }

void osg::TextureChunkBase::setEnvSource0RGB ( const GLenum & value ) [inline, inherited]

Definition at line 823 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00824 {
00825     _sfEnvSource0RGB.setValue(value);
00826 }

void osg::TextureChunkBase::setEnvSource1RGB ( const GLenum & value ) [inline, inherited]

Definition at line 844 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00845 {
00846     _sfEnvSource1RGB.setValue(value);
00847 }

void osg::TextureChunkBase::setEnvSource2RGB ( const GLenum & value ) [inline, inherited]

Definition at line 865 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00866 {
00867     _sfEnvSource2RGB.setValue(value);
00868 }

void osg::TextureChunkBase::setEnvSource0Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 886 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00887 {
00888     _sfEnvSource0Alpha.setValue(value);
00889 }

void osg::TextureChunkBase::setEnvSource1Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 907 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00908 {
00909     _sfEnvSource1Alpha.setValue(value);
00910 }

void osg::TextureChunkBase::setEnvSource2Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 928 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvSource2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00929 {
00930     _sfEnvSource2Alpha.setValue(value);
00931 }

void osg::TextureChunkBase::setEnvOperand0RGB ( const GLenum & value ) [inline, inherited]

Definition at line 949 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00950 {
00951     _sfEnvOperand0RGB.setValue(value);
00952 }

void osg::TextureChunkBase::setEnvOperand1RGB ( const GLenum & value ) [inline, inherited]

Definition at line 970 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00971 {
00972     _sfEnvOperand1RGB.setValue(value);
00973 }

void osg::TextureChunkBase::setEnvOperand2RGB ( const GLenum & value ) [inline, inherited]

Definition at line 991 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2RGB, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00992 {
00993     _sfEnvOperand2RGB.setValue(value);
00994 }

void osg::TextureChunkBase::setEnvOperand0Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 1012 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand0Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01013 {
01014     _sfEnvOperand0Alpha.setValue(value);
01015 }

void osg::TextureChunkBase::setEnvOperand1Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 1033 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand1Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01034 {
01035     _sfEnvOperand1Alpha.setValue(value);
01036 }

void osg::TextureChunkBase::setEnvOperand2Alpha ( const GLenum & value ) [inline, inherited]

Definition at line 1054 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfEnvOperand2Alpha, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01055 {
01056     _sfEnvOperand2Alpha.setValue(value);
01057 }

void osg::TextureChunkBase::setGLId ( const GLenum & value ) [inline, inherited]

Definition at line 1075 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfGLId, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

Referenced by osg::TextureChunk::changed(), osg::TextureChunk::onCreate(), and onCreate().

01076 {
01077     _sfGLId.setValue(value);
01078 }

void osg::TextureChunkBase::setIgnoreGLForAspect ( const Int32 & value ) [inline, inherited]

Definition at line 1096 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfIgnoreGLForAspect, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01097 {
01098     _sfIgnoreGLForAspect.setValue(value);
01099 }

void osg::TextureChunkBase::setPointSprite ( const bool & value ) [inline, inherited]

Definition at line 1117 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPointSprite, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01118 {
01119     _sfPointSprite.setValue(value);
01120 }

void osg::TextureChunkBase::setPriority ( const Real32 & value ) [inline, inherited]

Definition at line 1138 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfPriority, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01139 {
01140     _sfPriority.setValue(value);
01141 }

void osg::TextureChunkBase::setShaderOperation ( const GLenum & value ) [inline, inherited]

Definition at line 1159 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOperation, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01160 {
01161     _sfShaderOperation.setValue(value);
01162 }

void osg::TextureChunkBase::setShaderInput ( const GLenum & value ) [inline, inherited]

Definition at line 1180 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderInput, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01181 {
01182     _sfShaderInput.setValue(value);
01183 }

void osg::TextureChunkBase::setShaderOffsetScale ( const Real32 & value ) [inline, inherited]

Definition at line 1201 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetScale, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01202 {
01203     _sfShaderOffsetScale.setValue(value);
01204 }

void osg::TextureChunkBase::setShaderOffsetBias ( const Real32 & value ) [inline, inherited]

Definition at line 1222 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderOffsetBias, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01223 {
01224     _sfShaderOffsetBias.setValue(value);
01225 }

void osg::TextureChunkBase::setShaderRGBADotProduct ( const GLenum & value ) [inline, inherited]

Definition at line 1243 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderRGBADotProduct, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01244 {
01245     _sfShaderRGBADotProduct.setValue(value);
01246 }

void osg::TextureChunkBase::setShaderCullModes ( const UInt8 & value ) [inline, inherited]

Definition at line 1264 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderCullModes, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01265 {
01266     _sfShaderCullModes.setValue(value);
01267 }

void osg::TextureChunkBase::setShaderConstEye ( const Vec3f & value ) [inline, inherited]

Definition at line 1285 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfShaderConstEye, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01286 {
01287     _sfShaderConstEye.setValue(value);
01288 }

void osg::TextureChunkBase::setLodBias ( const Real32 & value ) [inline, inherited]

Definition at line 1306 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfLodBias, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01307 {
01308     _sfLodBias.setValue(value);
01309 }

void osg::TextureChunkBase::setTarget ( const GLenum & value ) [inline, inherited]

Definition at line 1327 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfTarget, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01328 {
01329     _sfTarget.setValue(value);
01330 }

void osg::TextureChunkBase::setDirtyLeft ( const Int32 & value ) [inline, inherited]

Definition at line 1348 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyLeft, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01349 {
01350     _sfDirtyLeft.setValue(value);
01351 }

void osg::TextureChunkBase::setDirtyMinX ( const Int32 & value ) [inline, inherited]

Definition at line 1369 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinX, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01370 {
01371     _sfDirtyMinX.setValue(value);
01372 }

void osg::TextureChunkBase::setDirtyMaxX ( const Int32 & value ) [inline, inherited]

Definition at line 1390 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxX, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01391 {
01392     _sfDirtyMaxX.setValue(value);
01393 }

void osg::TextureChunkBase::setDirtyMinY ( const Int32 & value ) [inline, inherited]

Definition at line 1411 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinY, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01412 {
01413     _sfDirtyMinY.setValue(value);
01414 }

void osg::TextureChunkBase::setDirtyMaxY ( const Int32 & value ) [inline, inherited]

Definition at line 1432 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxY, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01433 {
01434     _sfDirtyMaxY.setValue(value);
01435 }

void osg::TextureChunkBase::setDirtyMinZ ( const Int32 & value ) [inline, inherited]

Definition at line 1453 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMinZ, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01454 {
01455     _sfDirtyMinZ.setValue(value);
01456 }

void osg::TextureChunkBase::setDirtyMaxZ ( const Int32 & value ) [inline, inherited]

Definition at line 1474 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfDirtyMaxZ, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01475 {
01476     _sfDirtyMaxZ.setValue(value);
01477 }

void osg::TextureChunkBase::setAnisotropy ( const Real32 & value ) [inline, inherited]

Definition at line 1495 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfAnisotropy, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01496 {
01497     _sfAnisotropy.setValue(value);
01498 }

void osg::TextureChunkBase::setBorderColor ( const Color4f & value ) [inline, inherited]

Definition at line 1516 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderColor, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01517 {
01518     _sfBorderColor.setValue(value);
01519 }

void osg::TextureChunkBase::setBorderWidth ( const UInt32 & value ) [inline, inherited]

Definition at line 1537 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfBorderWidth, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01538 {
01539     _sfBorderWidth.setValue(value);
01540 }

void osg::TextureChunkBase::setNPOTMatrixScale ( const UInt32 & value ) [inline, inherited]

Definition at line 1558 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_sfNPOTMatrixScale, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

01559 {
01560     _sfNPOTMatrixScale.setValue(value);
01561 }

UInt32 osg::StateChunk::getClassId ( void ) const [inline, inherited]

Definition at line 48 of file OSGStateChunk.inl.

References osg::StateChunk::getClass(), and osg::StateChunkClass::getId().

00049 {
00050     return getClass()->getId();
00051 }

void StateChunk::update ( DrawActionBase * action ) [virtual, inherited]

Reimplemented in osg::SHLChunk.

Definition at line 311 of file OSGStateChunk.cpp.

00312 {
00313 }

SFBool * osg::StateChunkBase::getSFIgnore ( void ) [inline, inherited]

Definition at line 75 of file OSGStateChunkBase.inl.

References osg::StateChunkBase::_sfIgnore.

00076 {
00077     return &_sfIgnore;
00078 }

bool & osg::StateChunkBase::getIgnore ( void ) [inline, inherited]

Definition at line 83 of file OSGStateChunkBase.inl.

References osg::StateChunkBase::_sfIgnore, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00084 {
00085     return _sfIgnore.getValue();
00086 }

const bool & osg::StateChunkBase::getIgnore ( void ) const [inline, inherited]

Definition at line 90 of file OSGStateChunkBase.inl.

References osg::StateChunkBase::_sfIgnore, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00091 {
00092     return _sfIgnore.getValue();
00093 }

void osg::StateChunkBase::setIgnore ( const bool & value ) [inline, inherited]

Definition at line 97 of file OSGStateChunkBase.inl.

References osg::StateChunkBase::_sfIgnore, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00098 {
00099     _sfIgnore.setValue(value);
00100 }

MFFieldContainerPtr & Attachment::getParents ( void ) [inherited]

Definition at line 95 of file OSGAttachment.cpp.

00096 {
00097     return _parents;
00098 }

const MFFieldContainerPtr & Attachment::getParents ( void ) const [inherited]

Definition at line 100 of file OSGAttachment.cpp.

References osg::Attachment::_parents.

00101 {
00102     return _parents;
00103 }

MFFieldContainerPtr * Attachment::getMFParents ( void ) [inherited]

Definition at line 105 of file OSGAttachment.cpp.

References osg::Attachment::_parents.

Referenced by osg::DVRLookupTable::changed().

00106 {
00107     return &_parents;
00108 }

void Attachment::addParent ( FieldContainerPtr parent ) [inherited]

Definition at line 110 of file OSGAttachment.cpp.

References osg::Attachment::_parents, and osg::MField< FieldTypeT, fieldNameSpace >::push_back().

00111 {
00112     _parents.push_back(parent);
00113 }

void Attachment::subParent ( FieldContainerPtr parent ) [inherited]

Definition at line 115 of file OSGAttachment.cpp.

References osg::Attachment::_parents, osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::MField< FieldTypeT, fieldNameSpace >::erase(), and osg::MField< FieldTypeT, fieldNameSpace >::find().

00116 {
00117     MFFieldContainerPtr::iterator parentIt = _parents.find(parent);
00118 
00119     if(parentIt != _parents.end())
00120     {
00121         _parents.erase(parentIt);
00122     }
00123 }

Int32 Attachment::findParent ( FieldContainerPtr parent ) [inherited]

Definition at line 125 of file OSGAttachment.cpp.

References osg::Attachment::_parents, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::MField< FieldTypeT, fieldNameSpace >::end(), and osg::MField< FieldTypeT, fieldNameSpace >::find().

00126 {
00127     MFFieldContainerPtr::iterator parentIt = _parents.find(parent);
00128 
00129     if(parentIt != _parents.end())
00130     {
00131         return parentIt - _parents.begin();
00132     }
00133     else
00134     {
00135         return -1;
00136     }
00137 }

SFBool & Attachment::getInternal ( void ) [inherited]

Definition at line 142 of file OSGAttachment.cpp.

References osg::Attachment::_sfInternal.

00143 {
00144     return _sfInternal;
00145 }

const SFBool & Attachment::getInternal ( void ) const [inherited]

Definition at line 147 of file OSGAttachment.cpp.

References osg::Attachment::_sfInternal.

00148 {
00149     return _sfInternal;
00150 }

SFBool * Attachment::getSFInternal ( void ) [inherited]

Definition at line 152 of file OSGAttachment.cpp.

References osg::Attachment::_sfInternal.

00153 {
00154     return &_sfInternal;
00155 }

void Attachment::setInternal ( bool bVal ) [inherited]

Definition at line 157 of file OSGAttachment.cpp.

References osg::Attachment::_sfInternal, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00158 {
00159     _sfInternal.setValue(bVal);
00160 }

UInt16 osg::FieldContainer::getClassGroupId ( void ) [inline, static, inherited]

Definition at line 71 of file OSGFieldContainerImpl.inl.

References osg::FieldContainer::_type, and osg::FieldContainerType::getGroupId().

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

UInt32 osg::FieldContainer::getTypeId ( void ) const [inline, inherited]

Definition at line 77 of file OSGFieldContainerImpl.inl.

References osg::TypeBase::getId(), and osg::FieldContainer::getType().

Referenced by osg::TextureChunk::changeFrom(), and changeFrom().

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

UInt16 osg::FieldContainer::getGroupId ( void ) const [inline, inherited]

Definition at line 83 of file OSGFieldContainerImpl.inl.

References osg::FieldContainerType::getGroupId(), and osg::FieldContainer::getType().

Referenced by osg::fcptrAttributeMap(), osg::Image::setAttachmentField(), and osg::stringAttributeMap().

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

const Char8 * osg::FieldContainer::getTypeName ( void ) const [inline, inherited]

Definition at line 89 of file OSGFieldContainerImpl.inl.

References osg::TypeBase::getCName(), and osg::FieldContainer::getType().

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

Field * osg::FieldContainer::getField ( UInt32 fieldId ) [inline, inherited]

Generic Field Access

Definition at line 95 of file OSGFieldContainerImpl.inl.

References osg::FieldDescription::getField(), osg::FieldContainerType::getFieldDescription(), and osg::FieldContainer::getType().

Referenced by osg::QFCItem::expand(), osg::VRMLShapeDesc::getFieldAndDesc(), osg::QFieldViewBase::getFieldPtr(), osg::QFieldEditorBase::getFieldPtr(), osg::getParentsField(), and osg::QFCItem::setup().

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

Field * osg::FieldContainer::getField ( const Char8 * fieldName ) [inline, inherited]

Generic Field Access

Definition at line 103 of file OSGFieldContainerImpl.inl.

References osg::FieldContainerType::findFieldDescription(), osg::FieldDescription::getField(), and osg::FieldContainer::getType().

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

template<class ObjectPtrT>

void osg::FieldContainer::newPtr	(	ObjectPtrT &	result,
		const typename ObjectPtrT::StoredObjectType *	prototypeP
	)			`[inline, static, protected, inherited]`

Definition at line 138 of file OSGFieldContainerImpl.inl.

References osg::ChangeList::addCreated(), osg::PThreadBase::getAspect(), osg::PThreadBase::getCurrentChangeList(), osg::ThreadManager::getNumAspects(), osg::FieldContainerFactory::registerFieldContainer(), and osg::FieldContainerFactory::the().

00141 {
00142     typedef typename ObjectPtrT::StoredObjectType ObjectType;
00143     
00144     UInt8 *pTmp;
00145     
00146     result._containerSize = sizeof(ObjectType);
00147     
00148     pTmp        = 
00149         static_cast<UInt8 *>(operator new(
00150             sizeof(Int32)      + // ReferenceCount
00151             sizeof(UInt32)     + // ContainerId
00152             sizeof(ObjectType) * ThreadManager::getNumAspects()));
00153     
00154     *(reinterpret_cast<Int32 *>(pTmp)) = 0;
00155     
00156     pTmp += sizeof(Int32);
00157     
00158     result._storeP = (pTmp + sizeof(UInt32));
00159 
00160 #ifdef OSG_DEBUG_FCPTR
00161     result._typedStoreP = reinterpret_cast<FieldContainer *>(result._storeP);
00162 #endif
00163 
00164     *(reinterpret_cast<UInt32 *>(pTmp)) = 
00165         FieldContainerFactory::the()->registerFieldContainer(result);
00166     
00167     Thread::getCurrentChangeList()->addCreated(
00168         *(reinterpret_cast<UInt32 *>(pTmp)));
00169     
00170     pTmp += sizeof(UInt32);
00171     
00172     ObjectType *aObject = reinterpret_cast<ObjectType *>(pTmp);
00173 
00174     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00175     {
00176         pTmp = 
00177             reinterpret_cast<UInt8 *>(new (pTmp) ObjectType(*prototypeP));
00178         
00179         pTmp += sizeof(ObjectType);
00180     }
00181     
00182     result->onCreate(prototypeP);
00183 
00184     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00185     {
00186         aObject[i].onCreateAspect(aObject, prototypeP);
00187     }
00188 
00189 #if defined(OSG_GV_BETA) && defined(OSG_DBG_MEM)
00190 
00191     fprintf(stderr, "GV_MEM_FC_DBG : (%u) cc (%p|%u)\n", 
00192             Thread::getAspect(),
00193             result._storeP,
00194 //            ObjectType::getClassType().getCName(),
00195             ObjectType::getClassType().getId());
00196 #endif
00197 
00198 #ifdef OSG_DEBUG_TYPED_FCPTR
00199     result.updateTypedStore();
00200 #endif
00201 }

template<class ObjectPtrT>

void osg::FieldContainer::newPtr ( ObjectPtrT & result ) [inline, static, protected, inherited]

Definition at line 204 of file OSGFieldContainerImpl.inl.

References osg::ChangeList::addCreated(), osg::PThreadBase::getAspect(), osg::PThreadBase::getCurrentChangeList(), osg::ThreadManager::getNumAspects(), osg::FieldContainerFactory::registerFieldContainer(), and osg::FieldContainerFactory::the().

00205 {
00206     typedef typename ObjectPtrT::StoredObjectType ObjectType;
00207     
00208     UInt8 *pTmp;
00209     
00210     result._containerSize = sizeof(ObjectType);
00211     
00212     pTmp        =             
00213         static_cast<UInt8 *>(operator new(
00214             sizeof(Int32)      + // ReferenceCount
00215             sizeof(UInt32)     + // ContainerId
00216             sizeof(ObjectType) * ThreadManager::getNumAspects()));
00217     
00218     *(reinterpret_cast<Int32 *>(pTmp)) = 0;
00219     
00220     pTmp  += sizeof(Int32);
00221     
00222     result._storeP = (pTmp + sizeof(UInt32));
00223     
00224 #ifdef OSG_DEBUG_FCPTR
00225     result._typedStoreP = reinterpret_cast<FieldContainer *>(result._storeP);
00226 #endif
00227 
00228     *(reinterpret_cast<UInt32 *>(pTmp)) = 
00229         FieldContainerFactory::the()->registerFieldContainer(result);
00230     
00231     Thread::getCurrentChangeList()->addCreated(
00232         *(reinterpret_cast<UInt32 *>(pTmp)));
00233     
00234     pTmp += sizeof(UInt32);
00235     
00236     ObjectType *aObject = reinterpret_cast<ObjectType *>(pTmp);
00237 
00238     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00239     {
00240         pTmp = reinterpret_cast<UInt8 *>(new (pTmp) ObjectType());
00241         
00242         pTmp += sizeof(ObjectType);
00243     }
00244     
00245     result->onCreate();
00246     
00247     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00248     {
00249         aObject[i].onCreateAspect(aObject);
00250     }
00251 
00252 #if defined(OSG_GV_BETA) && defined(OSG_DBG_MEM)
00253     fprintf(stderr, "GV_MEM_FC_DBG : (%u) c (%p|%u)\n", 
00254             Thread::getAspect(),
00255             result._storeP,
00256 //            ObjectType::getClassType().getCName(),
00257             ObjectType::getClassType().getId());
00258 #endif
00259     
00260 #ifdef OSG_DEBUG_TYPED_FCPTR
00261     result.updateTypedStore();
00262 #endif
00263 }

template<class FieldTypeT>

void osg::FieldContainer::beginEditX	(	const BitVector &	whichField,
		FieldTypeT &	field
	)			`[inline, protected, inherited]`

Definition at line 285 of file OSGFieldContainerImpl.inl.

00286 {
00287 //    fieldR.beginEdit();
00288 }

template<class FieldTypeT>

void osg::FieldContainer::endEditX	(	const BitVector &	whichField,
		FieldTypeT &	field
	)			`[inline, protected, inherited]`

Definition at line 291 of file OSGFieldContainerImpl.inl.

References osg::endEditCP().

00292 {
00293     FieldContainerPtr tmpPtr(this);
00294     endEditCP(tmpPtr, whichField);
00295 }

void osg::FieldContainer::onCreateAspect	(	const FieldContainer *	aspect0,
		const FieldContainer *	source = `NULL`
	)			`[inline, protected, inherited]`

Definition at line 323 of file OSGFieldContainerImpl.inl.

00325 {
00326 }

Friends And Related Function Documentation

friend class FieldContainer [friend]

Reimplemented from osg::CubeTextureChunkBase.

Definition at line 159 of file OSGCubeTextureChunk.h.

friend class CubeTextureChunkBase [friend]

Definition at line 160 of file OSGCubeTextureChunk.h.

Member Data Documentation

const osg::BitVector CubeTextureChunkBase::PosZImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::PosZImageFieldId)

Definition at line 108 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::PosXImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::PosXImageFieldId)

Definition at line 109 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::NegXImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::NegXImageFieldId)

Definition at line 110 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::PosYImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::PosYImageFieldId)

Definition at line 111 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::NegYImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::NegYImageFieldId)

Definition at line 112 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::IsReflectionMapFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << CubeTextureChunkBase::IsReflectionMapFieldId)

Definition at line 113 of file OSGCubeTextureChunkBase.h.

Referenced by osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), and osg::CubeTextureChunkBase::getBinSize().

const osg::BitVector CubeTextureChunkBase::MTInfluenceMask [static, inherited]

Initial value:

 
    (Inherited::MTInfluenceMask) | 
    (static_cast<BitVector>(0x0) << Inherited::NextFieldId)

Reimplemented from osg::TextureChunkBase.

Definition at line 116 of file OSGCubeTextureChunkBase.h.

ImagePtr CubeTextureChunkBase::_sfPosZImage [protected, inherited]

The image for the positive Z direction for the cube tetxure.

Definition at line 213 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getPosZImage(), osg::CubeTextureChunkBase::getSFPosZImage(), onDestroy(), osg::CubeTextureChunkBase::setPosZImage(), and setPosZImage().

ImagePtr CubeTextureChunkBase::_sfPosXImage [protected, inherited]

The image for the positive X direction for the cube tetxure.

Definition at line 214 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getPosXImage(), osg::CubeTextureChunkBase::getSFPosXImage(), onDestroy(), osg::CubeTextureChunkBase::setPosXImage(), and setPosXImage().

ImagePtr CubeTextureChunkBase::_sfNegXImage [protected, inherited]

The image for the negative X direction for the cube tetxure.

Definition at line 215 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getNegXImage(), osg::CubeTextureChunkBase::getSFNegXImage(), onDestroy(), osg::CubeTextureChunkBase::setNegXImage(), and setNegXImage().

ImagePtr CubeTextureChunkBase::_sfPosYImage [protected, inherited]

The image for the positive Y direction for the cube tetxure.

Definition at line 216 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getPosYImage(), osg::CubeTextureChunkBase::getSFPosYImage(), onDestroy(), osg::CubeTextureChunkBase::setPosYImage(), and setPosYImage().

ImagePtr CubeTextureChunkBase::_sfNegYImage [protected, inherited]

The image for the negative Y direction for the cube tetxure.

Definition at line 217 of file OSGCubeTextureChunkBase.h.

Referenced by changed(), osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getNegYImage(), osg::CubeTextureChunkBase::getSFNegYImage(), onDestroy(), osg::CubeTextureChunkBase::setNegYImage(), and setNegYImage().

bool CubeTextureChunkBase::_sfIsReflectionMap [protected, inherited]

The image for the positive Z direction for the cube tetxure.

Definition at line 218 of file OSGCubeTextureChunkBase.h.

Referenced by osg::CubeTextureChunkBase::copyFromBin(), osg::CubeTextureChunkBase::copyToBin(), osg::CubeTextureChunkBase::executeSyncImpl(), osg::CubeTextureChunkBase::getBinSize(), osg::CubeTextureChunkBase::getIsReflectionMap(), osg::CubeTextureChunkBase::getSFIsReflectionMap(), and osg::CubeTextureChunkBase::setIsReflectionMap().

UInt32 TextureChunk::_extTex3D [static, protected, inherited]

Definition at line 197 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::TextureChunk::deactivate(), osg::TextureChunk::handleGL(), osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_arbMultiTex [static, protected, inherited]

Definition at line 198 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::hasMultiTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_nvPointSprite [static, protected, inherited]

Definition at line 199 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), deactivate(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_nvTextureShader [static, protected, inherited]

Definition at line 200 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), deactivate(), osg::TextureChunk::handleTextureShader(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_nvTextureShader2 [static, protected, inherited]

Definition at line 201 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTextureShader(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_nvTextureShader3 [static, protected, inherited]

Definition at line 202 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_sgisGenerateMipmap [static, protected, inherited]

Definition at line 203 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_extTextureLodBias [static, protected, inherited]

Definition at line 204 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activate(), activate(), osg::TextureChunk::changeFrom(), changeFrom(), osg::TextureChunk::deactivate(), deactivate(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_arbTextureCompression [static, protected, inherited]

Definition at line 205 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_arbTextureRectangle [static, protected, inherited]

Definition at line 206 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_arbTextureNonPowerOfTwo [static, protected, inherited]

Definition at line 207 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_extTextureFilterAnisotropic [static, protected, inherited]

Definition at line 208 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcTexImage3D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 211 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcTexSubImage3D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 212 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcActiveTexture = Window::invalidFunctionID [static, protected, inherited]

Definition at line 213 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::activeTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_arbCubeTex [static, protected, inherited]

Definition at line 214 of file OSGTextureChunk.h.

Referenced by activate(), changeFrom(), deactivate(), handleGL(), osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexImage1D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 215 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage1D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 216 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexImage2D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 217 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage2D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 218 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexImage3D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 219 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage3D = Window::invalidFunctionID [static, protected, inherited]

Definition at line 220 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::handleTexture(), and osg::TextureChunk::TextureChunk().

StateChunkClass TextureChunk::_class [static, protected, inherited]

Definition at line 224 of file OSGTextureChunk.h.

Referenced by osg::TextureChunk::getClass(), osg::TextureChunk::getStaticClass(), and getStaticClass().

const osg::BitVector osg::TextureChunkBase::ImageFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ImageFieldId)

Definition at line 202 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::SimpleTexturedMaterial::changed(), osg::FresnelMaterial::changed(), osg::TextureGrabBackground::clear(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureGrabForeground::draw(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::FBOViewport::render(), and osg::FresnelMaterial::updateFresnel().

const osg::BitVector osg::TextureChunkBase::InternalFormatFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::InternalFormatFieldId)

Definition at line 203 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ExternalFormatFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ExternalFormatFieldId)

Definition at line 204 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ScaleFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ScaleFieldId)

Definition at line 205 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::FrameFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::FrameFieldId)

Definition at line 206 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::MinFilterFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::MinFilterFieldId)

Definition at line 207 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::SimpleTexturedMaterial::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::MagFilterFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::MagFilterFieldId)

Definition at line 208 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::SimpleTexturedMaterial::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::WrapSFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::WrapSFieldId)

Definition at line 209 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::WrapTFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::WrapTFieldId)

Definition at line 210 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::WrapRFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::WrapRFieldId)

Definition at line 211 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvModeFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvModeFieldId)

Definition at line 212 of file OSGTextureChunkBase.h.

Referenced by osg::SimpleTexturedMaterial::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and modifyMaterial().

const osg::BitVector osg::TextureChunkBase::EnvColorFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvColorFieldId)

Definition at line 213 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvCombineRGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvCombineRGBFieldId)

Definition at line 214 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvCombineAlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvCombineAlphaFieldId)

Definition at line 215 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvScaleRGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvScaleRGBFieldId)

Definition at line 216 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvScaleAlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvScaleAlphaFieldId)

Definition at line 217 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource0RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource0RGBFieldId)

Definition at line 218 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource1RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource1RGBFieldId)

Definition at line 219 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource2RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource2RGBFieldId)

Definition at line 220 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource0AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource0AlphaFieldId)

Definition at line 221 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource1AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource1AlphaFieldId)

Definition at line 222 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvSource2AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvSource2AlphaFieldId)

Definition at line 223 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand0RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand0RGBFieldId)

Definition at line 224 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand1RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand1RGBFieldId)

Definition at line 225 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand2RGBFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand2RGBFieldId)

Definition at line 226 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand0AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand0AlphaFieldId)

Definition at line 227 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand1AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand1AlphaFieldId)

Definition at line 228 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::EnvOperand2AlphaFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::EnvOperand2AlphaFieldId)

Definition at line 229 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::GLIdFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::GLIdFieldId)

Definition at line 230 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunk::onCreate(), onCreate(), and osg::RemoteAspect::RemoteAspect().

const osg::BitVector osg::TextureChunkBase::IgnoreGLForAspectFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::IgnoreGLForAspectFieldId)

Definition at line 231 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::PointSpriteFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::PointSpriteFieldId)

Definition at line 232 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::PriorityFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::PriorityFieldId)

Definition at line 233 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderOperationFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderOperationFieldId)

Definition at line 234 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderInputFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderInputFieldId)

Definition at line 235 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderOffsetMatrixFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderOffsetMatrixFieldId)

Definition at line 236 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderOffsetScaleFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderOffsetScaleFieldId)

Definition at line 237 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderOffsetBiasFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderOffsetBiasFieldId)

Definition at line 238 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderRGBADotProductFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderRGBADotProductFieldId)

Definition at line 239 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderCullModesFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderCullModesFieldId)

Definition at line 240 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::ShaderConstEyeFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::ShaderConstEyeFieldId)

Definition at line 241 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::LodBiasFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::LodBiasFieldId)

Definition at line 242 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::TargetFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::TargetFieldId)

Definition at line 243 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::DirtyLeftFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyLeftFieldId)

Definition at line 244 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::DirtyMinXFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMinXFieldId)

Definition at line 245 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::DirtyMaxXFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMaxXFieldId)

Definition at line 246 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::DirtyMinYFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMinYFieldId)

Definition at line 247 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::DirtyMaxYFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMaxYFieldId)

Definition at line 248 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::DirtyMinZFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMinZFieldId)

Definition at line 249 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::DirtyMaxZFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::DirtyMaxZFieldId)

Definition at line 250 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and osg::TextureChunk::imageContentChanged().

const osg::BitVector osg::TextureChunkBase::AnisotropyFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::AnisotropyFieldId)

Definition at line 251 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::BorderColorFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::BorderColorFieldId)

Definition at line 252 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::BorderWidthFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::BorderWidthFieldId)

Definition at line 253 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

const osg::BitVector osg::TextureChunkBase::NPOTMatrixScaleFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << TextureChunkBase::NPOTMatrixScaleFieldId)

Definition at line 254 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), and osg::TextureChunkBase::getBinSize().

ImagePtr osg::TextureChunkBase::_sfImage [protected, inherited]

The texture.

Definition at line 542 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getImage(), osg::TextureChunkBase::getSFImage(), osg::TextureChunk::onDestroy(), osg::TextureChunkBase::setImage(), and osg::TextureChunk::setImage().

GLenum osg::TextureChunkBase::_sfInternalFormat [protected, inherited]

The internal texture format.

Definition at line 543 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getInternalFormat(), osg::TextureChunkBase::getSFInternalFormat(), and osg::TextureChunkBase::setInternalFormat().

GLenum osg::TextureChunkBase::_sfExternalFormat [protected, inherited]

The external texture format - overwrites external format of image when set to a value not equal to GL_NONE (which is the default).

Definition at line 544 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getExternalFormat(), osg::TextureChunkBase::getSFExternalFormat(), and osg::TextureChunkBase::setExternalFormat().

bool osg::TextureChunkBase::_sfScale [protected, inherited]

Specifies whether the image should be scaled to the next power of two, thus filling the whole texture coordinate range, or if it should be put in the lower left corner, leaving the rest of the texture undefined. This is mainly used for rapidly changing non power of two textures, to get around the scaling overhead. If set to false, NPOTMatrixScale can be used to use the texture matrix to correct the texture coordinates to show the used part of the texture.

Definition at line 545 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getScale(), osg::TextureChunkBase::getSFScale(), and osg::TextureChunkBase::setScale().

UInt32 osg::TextureChunkBase::_sfFrame [protected, inherited]

Select the frame of the image to be used. See osg::Image about details concerning multi-frame images. Hint! For fast update use GL_LINEAR or GL_NEAREST filters, as mipmap creation is slow right now.

Definition at line 546 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getFrame(), osg::TextureChunkBase::getSFFrame(), and osg::TextureChunkBase::setFrame().

GLenum osg::TextureChunkBase::_sfMinFilter [protected, inherited]

The minimisation filter, default GL_LINEAR_MIPMAP_LINEAR.

Definition at line 547 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getMinFilter(), osg::TextureChunkBase::getSFMinFilter(), and osg::TextureChunkBase::setMinFilter().

GLenum osg::TextureChunkBase::_sfMagFilter [protected, inherited]

The magnification filter, default GL_LINEAR.

Definition at line 548 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getMagFilter(), osg::TextureChunkBase::getSFMagFilter(), and osg::TextureChunkBase::setMagFilter().

GLenum osg::TextureChunkBase::_sfWrapS [protected, inherited]

Texture coordinate S wrapping, default GL_REPEAT.

Definition at line 549 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFWrapS(), osg::TextureChunkBase::getWrapS(), and osg::TextureChunkBase::setWrapS().

GLenum osg::TextureChunkBase::_sfWrapT [protected, inherited]

Texture coordinate T wrapping, default GL_REPEAT.

Definition at line 550 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFWrapT(), osg::TextureChunkBase::getWrapT(), and osg::TextureChunkBase::setWrapT().

GLenum osg::TextureChunkBase::_sfWrapR [protected, inherited]

Texture coordinate R wrapping, default GL_REPEAT.

Definition at line 551 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFWrapR(), osg::TextureChunkBase::getWrapR(), and osg::TextureChunkBase::setWrapR().

GLenum osg::TextureChunkBase::_sfEnvMode [protected, inherited]

Texture environment mode, default GL_REPLACE

Definition at line 552 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvMode(), osg::TextureChunkBase::getSFEnvMode(), and osg::TextureChunkBase::setEnvMode().

Color4f osg::TextureChunkBase::_sfEnvColor [protected, inherited]

Texture environment color default transparent black.

Definition at line 553 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvColor(), osg::TextureChunkBase::getSFEnvColor(), and osg::TextureChunkBase::setEnvColor().

GLenum osg::TextureChunkBase::_sfEnvCombineRGB [protected, inherited]

Texture environment rgb combine mode, default GL_MODULATE

Definition at line 554 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvCombineRGB(), osg::TextureChunkBase::getSFEnvCombineRGB(), and osg::TextureChunkBase::setEnvCombineRGB().

GLenum osg::TextureChunkBase::_sfEnvCombineAlpha [protected, inherited]

Texture environment alpha combine mode, default GL_MODULATE

Definition at line 555 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvCombineAlpha(), osg::TextureChunkBase::getSFEnvCombineAlpha(), and osg::TextureChunkBase::setEnvCombineAlpha().

Real32 osg::TextureChunkBase::_sfEnvScaleRGB [protected, inherited]

Texture environment combine rgb scale factor, default 1.f

Definition at line 556 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvScaleRGB(), osg::TextureChunkBase::getSFEnvScaleRGB(), and osg::TextureChunkBase::setEnvScaleRGB().

Real32 osg::TextureChunkBase::_sfEnvScaleAlpha [protected, inherited]

Texture environment combine alpha scale factor, default 1.f

Definition at line 557 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvScaleAlpha(), osg::TextureChunkBase::getSFEnvScaleAlpha(), and osg::TextureChunkBase::setEnvScaleAlpha().

GLenum osg::TextureChunkBase::_sfEnvSource0RGB [protected, inherited]

Texture environment combine source 0 rgb, default GL_TEXTURE

Definition at line 558 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource0RGB(), osg::TextureChunkBase::getSFEnvSource0RGB(), and osg::TextureChunkBase::setEnvSource0RGB().

GLenum osg::TextureChunkBase::_sfEnvSource1RGB [protected, inherited]

Texture environment combine source 1 rgb, default GL_PREVIOUS_EXT

Definition at line 559 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource1RGB(), osg::TextureChunkBase::getSFEnvSource1RGB(), and osg::TextureChunkBase::setEnvSource1RGB().

GLenum osg::TextureChunkBase::_sfEnvSource2RGB [protected, inherited]

Texture environment combine source 2 rgb, default GL_CONSTANT_EXT

Definition at line 560 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource2RGB(), osg::TextureChunkBase::getSFEnvSource2RGB(), and osg::TextureChunkBase::setEnvSource2RGB().

GLenum osg::TextureChunkBase::_sfEnvSource0Alpha [protected, inherited]

Texture environment combine source 0 alpha, default GL_TEXTURE

Definition at line 561 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource0Alpha(), osg::TextureChunkBase::getSFEnvSource0Alpha(), and osg::TextureChunkBase::setEnvSource0Alpha().

GLenum osg::TextureChunkBase::_sfEnvSource1Alpha [protected, inherited]

Texture environment combine source 1 alpha, default GL_PREVIOUS_EXT

Definition at line 562 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource1Alpha(), osg::TextureChunkBase::getSFEnvSource1Alpha(), and osg::TextureChunkBase::setEnvSource1Alpha().

GLenum osg::TextureChunkBase::_sfEnvSource2Alpha [protected, inherited]

Texture environment combine source 2 alpha, default GL_CONSTANT_EXT

Definition at line 563 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvSource2Alpha(), osg::TextureChunkBase::getSFEnvSource2Alpha(), and osg::TextureChunkBase::setEnvSource2Alpha().

GLenum osg::TextureChunkBase::_sfEnvOperand0RGB [protected, inherited]

Texture environment combine operand 0 rgb, default GL_SRC_COLOR

Definition at line 564 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand0RGB(), osg::TextureChunkBase::getSFEnvOperand0RGB(), and osg::TextureChunkBase::setEnvOperand0RGB().

GLenum osg::TextureChunkBase::_sfEnvOperand1RGB [protected, inherited]

Texture environment combine operand 1 rgb, default GL_SRC_COLOR

Definition at line 565 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand1RGB(), osg::TextureChunkBase::getSFEnvOperand1RGB(), and osg::TextureChunkBase::setEnvOperand1RGB().

GLenum osg::TextureChunkBase::_sfEnvOperand2RGB [protected, inherited]

Texture environment combine operand 2 rgb, default GL_SRC_ALPHA

Definition at line 566 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand2RGB(), osg::TextureChunkBase::getSFEnvOperand2RGB(), and osg::TextureChunkBase::setEnvOperand2RGB().

GLenum osg::TextureChunkBase::_sfEnvOperand0Alpha [protected, inherited]

Texture environment combine operand 0 alpha, default GL_SRC_ALPHA

Definition at line 567 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand0Alpha(), osg::TextureChunkBase::getSFEnvOperand0Alpha(), and osg::TextureChunkBase::setEnvOperand0Alpha().

GLenum osg::TextureChunkBase::_sfEnvOperand1Alpha [protected, inherited]

Texture environment combine operand 1 alpha, default GL_SRC_ALPHA

Definition at line 568 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand1Alpha(), osg::TextureChunkBase::getSFEnvOperand1Alpha(), and osg::TextureChunkBase::setEnvOperand1Alpha().

GLenum osg::TextureChunkBase::_sfEnvOperand2Alpha [protected, inherited]

Texture environment combine operand 2 alpha, default GL_SRC_ALPHA

Definition at line 569 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getEnvOperand2Alpha(), osg::TextureChunkBase::getSFEnvOperand2Alpha(), and osg::TextureChunkBase::setEnvOperand2Alpha().

GLenum osg::TextureChunkBase::_sfGLId [protected, inherited]

The OpenGL texture id for this texture.

Definition at line 570 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getGLId(), osg::TextureChunkBase::getSFGLId(), and osg::TextureChunkBase::setGLId().

Int32 osg::TextureChunkBase::_sfIgnoreGLForAspect [protected, inherited]

The dlist id, if used.

Definition at line 571 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunk::changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getIgnoreGLForAspect(), osg::TextureChunkBase::getSFIgnoreGLForAspect(), osg::TextureChunk::onCreate(), and osg::TextureChunkBase::setIgnoreGLForAspect().

bool osg::TextureChunkBase::_sfPointSprite [protected, inherited]

Flag to use this texture for Point Sprites.

Definition at line 572 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getPointSprite(), osg::TextureChunkBase::getSFPointSprite(), and osg::TextureChunkBase::setPointSprite().

Real32 osg::TextureChunkBase::_sfPriority [protected, inherited]

Priority of this texture, between 0 and 1, the default is 1.

Definition at line 573 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getPriority(), osg::TextureChunkBase::getSFPriority(), and osg::TextureChunkBase::setPriority().

GLenum osg::TextureChunkBase::_sfShaderOperation [protected, inherited]

Shader operation of this texture unit, default GL_NONE. If unit 0 uses GL_NONE, shading is switched off.

Definition at line 574 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderOperation(), osg::TextureChunkBase::getShaderOperation(), and osg::TextureChunkBase::setShaderOperation().

GLenum osg::TextureChunkBase::_sfShaderInput [protected, inherited]

Input texture unit for this shader's operation.

Definition at line 575 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderInput(), osg::TextureChunkBase::getShaderInput(), and osg::TextureChunkBase::setShaderInput().

Real32 osg::TextureChunkBase::_mfShaderOffsetMatrix [protected, inherited]

The 2x2 transformation matrix for offset textures.

Definition at line 576 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getMFShaderOffsetMatrix(), and osg::TextureChunkBase::getShaderOffsetMatrix().

Real32 osg::TextureChunkBase::_sfShaderOffsetScale [protected, inherited]

The scaling factor for scaled offset textures.

Definition at line 577 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderOffsetScale(), osg::TextureChunkBase::getShaderOffsetScale(), and osg::TextureChunkBase::setShaderOffsetScale().

Real32 osg::TextureChunkBase::_sfShaderOffsetBias [protected, inherited]

The bias factor for scaled offset textures.

Definition at line 578 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderOffsetBias(), osg::TextureChunkBase::getShaderOffsetBias(), and osg::TextureChunkBase::setShaderOffsetBias().

GLenum osg::TextureChunkBase::_sfShaderRGBADotProduct [protected, inherited]

The RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV value.

Definition at line 579 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderRGBADotProduct(), osg::TextureChunkBase::getShaderRGBADotProduct(), and osg::TextureChunkBase::setShaderRGBADotProduct().

UInt8 osg::TextureChunkBase::_sfShaderCullModes [protected, inherited]

The CULL_MODES_NV value, coded into a single byte. The first 4 bits of the byte are used to indicate the wnated cull modes, a value of 0 signifies GL_LESS, a value of 1 GL_GEQUAL. Bit 0 (mask 1) is used for the S coordinate, bit 1 (mask 2) for T, bit 2 (mask 4) for R and bit 4 (mask 8) for Q.

Definition at line 580 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderCullModes(), osg::TextureChunkBase::getShaderCullModes(), and osg::TextureChunkBase::setShaderCullModes().

Vec3f osg::TextureChunkBase::_sfShaderConstEye [protected, inherited]

The CONST_EYE_NV value, i.e. the constant eye position used by the DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV shader.

Definition at line 581 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFShaderConstEye(), osg::TextureChunkBase::getShaderConstEye(), and osg::TextureChunkBase::setShaderConstEye().

Real32 osg::TextureChunkBase::_sfLodBias [protected, inherited]

Bias of LOD calculation for texture access.

Definition at line 582 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getLodBias(), osg::TextureChunkBase::getSFLodBias(), and osg::TextureChunkBase::setLodBias().

GLenum osg::TextureChunkBase::_sfTarget [protected, inherited]

Texture target. Overwrite automatically determined texture target based on the parameters of the assigned image if set to anything else than GL_NONE. Used for nVidia's rectangle textures. Be careful when using it!

Definition at line 583 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFTarget(), osg::TextureChunkBase::getTarget(), and osg::TextureChunkBase::setTarget().

Int32 osg::TextureChunkBase::_sfDirtyLeft [protected, inherited]

Left coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 584 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyLeft(), osg::TextureChunkBase::getSFDirtyLeft(), and osg::TextureChunkBase::setDirtyLeft().

Int32 osg::TextureChunkBase::_sfDirtyMinX [protected, inherited]

Minimum X coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 585 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMinX(), osg::TextureChunkBase::getSFDirtyMinX(), and osg::TextureChunkBase::setDirtyMinX().

Int32 osg::TextureChunkBase::_sfDirtyMaxX [protected, inherited]

Maximum X coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 586 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMaxX(), osg::TextureChunkBase::getSFDirtyMaxX(), and osg::TextureChunkBase::setDirtyMaxX().

Int32 osg::TextureChunkBase::_sfDirtyMinY [protected, inherited]

Minimum Y coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 587 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMinY(), osg::TextureChunkBase::getSFDirtyMinY(), and osg::TextureChunkBase::setDirtyMinY().

Int32 osg::TextureChunkBase::_sfDirtyMaxY [protected, inherited]

Maximum Y coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 588 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMaxY(), osg::TextureChunkBase::getSFDirtyMaxY(), and osg::TextureChunkBase::setDirtyMaxY().

Int32 osg::TextureChunkBase::_sfDirtyMinZ [protected, inherited]

Minimum Z coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 589 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMinZ(), osg::TextureChunkBase::getSFDirtyMinZ(), and osg::TextureChunkBase::setDirtyMinZ().

Int32 osg::TextureChunkBase::_sfDirtyMaxZ [protected, inherited]

Maximum Z coordinate of the dirty rectangle to use for imageContentChanged(). This doesn't make sense to be stored in files, it does make sense on a cluster, though, that's why it's external.

Definition at line 590 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getDirtyMaxZ(), osg::TextureChunkBase::getSFDirtyMaxZ(), and osg::TextureChunkBase::setDirtyMaxZ().

Real32 osg::TextureChunkBase::_sfAnisotropy [protected, inherited]

Texture anisotropy filtering, the default 1.0f means isotropic filtering.

Definition at line 591 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getAnisotropy(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getSFAnisotropy(), and osg::TextureChunkBase::setAnisotropy().

Color4f osg::TextureChunkBase::_sfBorderColor [protected, inherited]

Texture border color.

Definition at line 592 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getBorderColor(), osg::TextureChunkBase::getSFBorderColor(), and osg::TextureChunkBase::setBorderColor().

UInt32 osg::TextureChunkBase::_sfBorderWidth [protected, inherited]

Texture border width in pixels.

Definition at line 593 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getBorderWidth(), osg::TextureChunkBase::getSFBorderWidth(), and osg::TextureChunkBase::setBorderWidth().

UInt32 osg::TextureChunkBase::_sfNPOTMatrixScale [protected, inherited]

Use the texture matrix to scale the texture coordinates for NPOT images. Only used if neither rectangular nor NPOT textures are supported. If set to false, the image is scaled to the next power of two before being used as a texture. For convenience xFlip/ yFlip can also be set. Note that this will interfere with other TextureTransform and TexGen chunks. Do not use it if you need to use those chunks!

Definition at line 594 of file OSGTextureChunkBase.h.

Referenced by osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getNPOTMatrixScale(), osg::TextureChunkBase::getSFNPOTMatrixScale(), and osg::TextureChunkBase::setNPOTMatrixScale().

const osg::BitVector osg::StateChunkBase::IgnoreFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << StateChunkBase::IgnoreFieldId)

Definition at line 98 of file OSGStateChunkBase.h.

Referenced by osg::StateChunkBase::copyFromBin(), osg::StateChunkBase::copyToBin(), osg::StateChunkBase::executeSyncImpl(), and osg::StateChunkBase::getBinSize().

bool osg::StateChunkBase::_sfIgnore [protected, inherited]

Enables / disables a chunk

Definition at line 162 of file OSGStateChunkBase.h.

Referenced by osg::StateChunkBase::copyFromBin(), osg::StateChunkBase::copyToBin(), osg::StateChunkBase::executeSyncImpl(), osg::StateChunkBase::getBinSize(), osg::StateChunkBase::getIgnore(), osg::StateChunkBase::getSFIgnore(), and osg::StateChunkBase::setIgnore().

const BitVector Attachment::InternalFieldMask = (1 << Attachment::InternalFieldId) [static, inherited]

Definition at line 93 of file OSGAttachmentImpl.h.

Referenced by osg::Attachment::copyFromBin(), osg::Attachment::copyToBin(), osg::Attachment::executeSyncImpl(), and osg::Attachment::getBinSize().

const BitVector Attachment::ParentsFieldMask = (1 << Attachment::ParentsFieldId) [static, inherited]

Definition at line 94 of file OSGAttachmentImpl.h.

SFBool osg::Attachment::_sfInternal [protected, inherited]

Definition at line 165 of file OSGAttachmentImpl.h.

Referenced by osg::Attachment::copyFromBin(), osg::Attachment::copyToBin(), osg::Attachment::executeSyncImpl(), osg::Attachment::getBinSize(), osg::Attachment::getInternal(), osg::Attachment::getSFInternal(), and osg::Attachment::setInternal().

MFFieldContainerPtr osg::Attachment::_parents [protected, inherited]

Definition at line 166 of file OSGAttachmentImpl.h.

Referenced by osg::Attachment::addParent(), osg::Attachment::copyFromBin(), osg::Attachment::copyToBin(), osg::Attachment::dump(), osg::Attachment::executeSyncImpl(), osg::Attachment::findParent(), osg::Attachment::getBinSize(), osg::Attachment::getMFParents(), osg::Attachment::getParents(), and osg::Attachment::subParent().

const BitVector osg::FieldContainer::NextFieldMask [static, inherited]

Initial value:

 
                    (TypeTraits<BitVector>::One << NextFieldId)

Definition at line 75 of file OSGFieldContainerImpl.h.

const bool osg::FieldContainer::isNodeCore = false [static, inherited]

Reimplemented in osg::NodeCore.

Definition at line 181 of file OSGFieldContainerImpl.h.

UInt32 osg::FieldContainer::_shares [protected, inherited]

Definition at line 199 of file OSGFieldContainerImpl.h.

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


Public Types
enum	{ PosZImageFieldId = Inherited::NextFieldId, PosXImageFieldId = PosZImageFieldId + 1, NegXImageFieldId = PosXImageFieldId + 1, PosYImageFieldId = NegXImageFieldId + 1, NegYImageFieldId = PosYImageFieldId + 1, IsReflectionMapFieldId = NegYImageFieldId + 1, NextFieldId = IsReflectionMapFieldId + 1 }
typedef CubeTextureChunkPtr	Ptr
enum	NPOTMatrixScaleE { None_TT = 0, NPotTexScale_TT = 1, XFlip_TT = 2, YFlip_TT = 4, ZFlip_TT = 8 }
	Flags can be OR-ed, e.g. NPotTexScale for old gpu and YFlip for videos. More...
enum	{ ImageFieldId = Inherited::NextFieldId, InternalFormatFieldId = ImageFieldId + 1, ExternalFormatFieldId = InternalFormatFieldId + 1, ScaleFieldId = ExternalFormatFieldId + 1, FrameFieldId = ScaleFieldId + 1, MinFilterFieldId = FrameFieldId + 1, MagFilterFieldId = MinFilterFieldId + 1, WrapSFieldId = MagFilterFieldId + 1, WrapTFieldId = WrapSFieldId + 1, WrapRFieldId = WrapTFieldId + 1, EnvModeFieldId = WrapRFieldId + 1, EnvColorFieldId = EnvModeFieldId + 1, EnvCombineRGBFieldId = EnvColorFieldId + 1, EnvCombineAlphaFieldId = EnvCombineRGBFieldId + 1, EnvScaleRGBFieldId = EnvCombineAlphaFieldId + 1, EnvScaleAlphaFieldId = EnvScaleRGBFieldId + 1, EnvSource0RGBFieldId = EnvScaleAlphaFieldId + 1, EnvSource1RGBFieldId = EnvSource0RGBFieldId + 1, EnvSource2RGBFieldId = EnvSource1RGBFieldId + 1, EnvSource0AlphaFieldId = EnvSource2RGBFieldId + 1, EnvSource1AlphaFieldId = EnvSource0AlphaFieldId + 1, EnvSource2AlphaFieldId = EnvSource1AlphaFieldId + 1, EnvOperand0RGBFieldId = EnvSource2AlphaFieldId + 1, EnvOperand1RGBFieldId = EnvOperand0RGBFieldId + 1, EnvOperand2RGBFieldId = EnvOperand1RGBFieldId + 1, EnvOperand0AlphaFieldId = EnvOperand2RGBFieldId + 1, EnvOperand1AlphaFieldId = EnvOperand0AlphaFieldId + 1, EnvOperand2AlphaFieldId = EnvOperand1AlphaFieldId + 1, GLIdFieldId = EnvOperand2AlphaFieldId + 1, IgnoreGLForAspectFieldId = GLIdFieldId + 1, PointSpriteFieldId = IgnoreGLForAspectFieldId + 1, PriorityFieldId = PointSpriteFieldId + 1, ShaderOperationFieldId = PriorityFieldId + 1, ShaderInputFieldId = ShaderOperationFieldId + 1, ShaderOffsetMatrixFieldId = ShaderInputFieldId + 1, ShaderOffsetScaleFieldId = ShaderOffsetMatrixFieldId + 1, ShaderOffsetBiasFieldId = ShaderOffsetScaleFieldId + 1, ShaderRGBADotProductFieldId = ShaderOffsetBiasFieldId + 1, ShaderCullModesFieldId = ShaderRGBADotProductFieldId + 1, ShaderConstEyeFieldId = ShaderCullModesFieldId + 1, LodBiasFieldId = ShaderConstEyeFieldId + 1, TargetFieldId = LodBiasFieldId + 1, DirtyLeftFieldId = TargetFieldId + 1, DirtyMinXFieldId = DirtyLeftFieldId + 1, DirtyMaxXFieldId = DirtyMinXFieldId + 1, DirtyMinYFieldId = DirtyMaxXFieldId + 1, DirtyMaxYFieldId = DirtyMinYFieldId + 1, DirtyMinZFieldId = DirtyMaxYFieldId + 1, DirtyMaxZFieldId = DirtyMinZFieldId + 1, AnisotropyFieldId = DirtyMaxZFieldId + 1, BorderColorFieldId = AnisotropyFieldId + 1, BorderWidthFieldId = BorderColorFieldId + 1, NPOTMatrixScaleFieldId = BorderWidthFieldId + 1, NextFieldId = NPOTMatrixScaleFieldId + 1 }
enum	{ IgnoreFieldId = Inherited::NextFieldId, NextFieldId = IgnoreFieldId + 1 }
enum	{ ParentsFieldId = Inherited::NextFieldId, InternalFieldId = ParentsFieldId + 1, NextFieldId = InternalFieldId + 1 }
enum	{ NextFieldId = 1 }
Public Member Functions
Chunk Class Access

virtual const StateChunkClass *	getClass (void) const
Sync

virtual void	changed (BitVector whichField, UInt32 origin)
Output

virtual void	dump (UInt32 uiIndent=0, const BitVector bvFlags=0) const
State

virtual void	activate (DrawActionBase *action, UInt32 index=0)
virtual void	changeFrom (DrawActionBase action, StateChunk old, UInt32 index=0)
virtual void	deactivate (DrawActionBase *action, UInt32 index=0)
Comparison

virtual Real32	switchCost (StateChunk *chunk)
virtual bool	operator< (const StateChunk &other) const
virtual bool	operator== (const StateChunk &other) const
virtual bool	operator!= (const StateChunk &other) const
Cube Texture specific

void	setPosZImage (ImagePtr &value)
void	setPosXImage (ImagePtr &value)
void	setNegXImage (ImagePtr &value)
void	setPosYImage (ImagePtr &value)
void	setNegYImage (ImagePtr &value)
FieldContainer Get

osg::CubeTextureChunk Class Reference [OpenGL State Handling]

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

osg::CubeTextureChunk Class Reference
[OpenGL State Handling]