osg::TextureChunk Class Reference
[OpenGL State Handling]

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

TextureChunk::TextureChunk ( void ) [protected]

Definition at line 164 of file OSGTextureChunk.cpp.

References _arbCubeTex, _arbMultiTex, _arbTextureCompression, _arbTextureNonPowerOfTwo, _arbTextureRectangle, _extTex3D, _extTextureFilterAnisotropic, _extTextureLodBias, _funcActiveTexture, _funcCompressedTexImage1D, _funcCompressedTexImage2D, _funcCompressedTexImage3D, _funcCompressedTexSubImage1D, _funcCompressedTexSubImage2D, _funcCompressedTexSubImage3D, _funcTexImage3D, _funcTexSubImage3D, _nvPointSprite, _nvTextureShader, _nvTextureShader2, _nvTextureShader3, _sgisGenerateMipmap, GL_FUNC_TEXIMAGE3D, GL_FUNC_TEXSUBIMAGE3D, GL_MAX_TEXTURE_COORDS_ARB, GL_MAX_TEXTURE_IMAGE_UNITS_ARB, GL_MAX_TEXTURE_UNITS_ARB, OSG_DLSYM_UNDERSCORE, osg::Window::registerConstant(), osg::Window::registerExtension(), and osg::Window::registerFunction().

00164                                :
00165     Inherited()
00166 {
00167     _extTex3D               =
00168         Window::registerExtension("GL_EXT_texture3D"                );
00169     _arbMultiTex            =
00170         Window::registerExtension("GL_ARB_multitexture"             );
00171     _arbCubeTex             =
00172         Window::registerExtension("GL_ARB_texture_cube_map"         );
00173     _nvPointSprite          =
00174         Window::registerExtension("GL_NV_point_sprite"              );
00175     _nvTextureShader        =
00176         Window::registerExtension("GL_NV_texture_shader"            );
00177     _nvTextureShader2       =
00178         Window::registerExtension("GL_NV_texture_shader2"           );
00179     _nvTextureShader3       =
00180         Window::registerExtension("GL_NV_texture_shader3"           );
00181     _sgisGenerateMipmap     =
00182         Window::registerExtension("GL_SGIS_generate_mipmap"         );
00183     _extTextureLodBias      = 
00184         Window::registerExtension("GL_EXT_texture_lod_bias"         );
00185     _arbTextureCompression  = 
00186         Window::registerExtension("GL_ARB_texture_compression"      );
00187     _arbTextureRectangle  = 
00188         Window::registerExtension("GL_ARB_texture_rectangle"        );
00189     _arbTextureNonPowerOfTwo  = 
00190         Window::registerExtension("GL_ARB_texture_non_power_of_two" );
00191     _extTextureFilterAnisotropic = 
00192         Window::registerExtension("GL_EXT_texture_filter_anisotropic" );
00193 
00194     _funcTexImage3D    =
00195         Window::registerFunction (GL_FUNC_TEXIMAGE3D                        , 
00196             _extTex3D, 0x0102);
00197     _funcTexSubImage3D =
00198         Window::registerFunction (GL_FUNC_TEXSUBIMAGE3D                     , 
00199             _extTex3D, 0x0102);
00200     _funcActiveTexture =
00201         Window::registerFunction (OSG_DLSYM_UNDERSCORE"glActiveTextureARB"  , 
00202             _arbMultiTex);
00203     _funcCompressedTexImage1D    =
00204         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00205                                     "glCompressedTexImage1DARB"             , 
00206             _arbTextureCompression);
00207     _funcCompressedTexSubImage1D    =
00208         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00209                                     "glCompressedTexSubImage1DARB"          , 
00210             _arbTextureCompression);
00211     _funcCompressedTexImage2D    =
00212         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00213                                     "glCompressedTexImage2DARB"             , 
00214             _arbTextureCompression);
00215     _funcCompressedTexSubImage2D    =
00216         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00217                                     "glCompressedTexSubImage2DARB"          , 
00218             _arbTextureCompression);
00219     _funcCompressedTexImage3D    =
00220         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00221                                     "glCompressedTexImage3DARB"             , 
00222             _arbTextureCompression);
00223     _funcCompressedTexSubImage3D    =
00224         Window::registerFunction(OSG_DLSYM_UNDERSCORE
00225                                     "glCompressedTexSubImage3DARB"          , 
00226             _arbTextureCompression);
00227 
00228     Window::registerConstant(GL_MAX_TEXTURE_UNITS_ARB);
00229     Window::registerConstant(GL_MAX_TEXTURE_IMAGE_UNITS_ARB);
00230     Window::registerConstant(GL_MAX_TEXTURE_COORDS_ARB);    
00231 }

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

Definition at line 233 of file OSGTextureChunk.cpp.

00233                                                      :
00234     Inherited(source)
00235 {
00236 }

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

Definition at line 238 of file OSGTextureChunk.cpp.

00239 {
00240 }

Member Function Documentation

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 244 of file OSGTextureChunk.cpp.

References _class.

Referenced by osg::CubeTextureChunk::getClass().

00245 {
00246     return &_class;
00247 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 47 of file OSGTextureChunk.inl.

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

Referenced by osg::TextureTransformChunk::checkTexChunkOrder(), and osg::VRMLWriteAction::writeMaterial().

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

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 53 of file OSGTextureChunk.inl.

References _class.

Referenced by osg::TextureTransformChunk::checkTexChunkOrder(), and getStaticClassId().

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

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

React to field changes. Note: this function also handles CubeTexture changes, make sure to keep it consistent with the cubeTexture specifics

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 256 of file OSGTextureChunk.cpp.

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

00257 {
00258     if(Thread::getAspect() != _sfIgnoreGLForAspect.getValue())
00259     {
00260         if(getGLId() == 0)
00261         {
00262             TextureChunkPtr tmpPtr(*this);
00263 
00264             beginEditCP(tmpPtr, TextureChunk::GLIdFieldMask);
00265             
00266             setGLId(
00267                 Window::registerGLObject(
00268                     osgTypedMethodVoidFunctor2ObjCPtrPtr<TextureChunkPtr,
00269                                                  Window ,
00270                                                  UInt32>(
00271                                                      tmpPtr,
00272                                                      &TextureChunk::handleGL),
00273                     1));
00274             
00275             endEditCP(tmpPtr, TextureChunk::GLIdFieldMask);
00276         }
00277     }
00278 
00279     // Only filter changed? Mipmaps need reinit.
00280     if((whichField & ~(MinFilterFieldMask | MagFilterFieldMask)) == 0)
00281     {
00282         if((getMinFilter() != GL_NEAREST) &&
00283            (getMinFilter() != GL_LINEAR))
00284         {
00285             if(Thread::getAspect() != _sfIgnoreGLForAspect.getValue())
00286             {
00287                 Window::reinitializeGLObject(getGLId());
00288             }
00289         }
00290         else
00291         {
00292             imageContentChanged();
00293         }
00294     } // Only priority changed? Refresh is fine.
00295     else if((whichField & ~(PriorityFieldMask | FrameFieldMask)) == 0)
00296     {
00297         imageContentChanged();
00298     } // Only dirty rectangle changed? Refresh is fine.
00299     else if ((whichField & ~(DirtyMinXFieldMask | DirtyMaxXFieldMask |
00300                              DirtyMinYFieldMask | DirtyMaxYFieldMask |
00301                              DirtyMinZFieldMask | DirtyMaxZFieldMask)) == 0)
00302     {
00303         if(Thread::getAspect() != _sfIgnoreGLForAspect.getValue())
00304         {
00305             Window::refreshGLObject(getGLId());
00306         }
00307     }
00308     else // Play it safe, do a reinit
00309     {
00310         if(Thread::getAspect() != _sfIgnoreGLForAspect.getValue())
00311         {
00312             Window::reinitializeGLObject(getGLId());
00313         }
00314     }
00315 
00316     if(whichField & ImageFieldMask)
00317     {
00318         if(origin & ChangedOrigin::Abstract)
00319         {
00320             if(origin & ChangedOrigin::AbstrIncRefCount)
00321             {
00322                 addRefCP(_sfImage.getValue());
00323             }
00324             else
00325             {
00326                 ImagePtr pImage = _sfImage.getValue();
00327 
00328                 _sfImage.setValue(NullFC);
00329 
00330                 setImage(pImage);
00331             }
00332         }
00333     }
00334 
00335     Inherited::changed(whichField, origin);
00336 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 387 of file OSGTextureChunk.cpp.

References SLOG.

00389 {
00390     SLOG << "Dump TextureChunk NI" << std::endl;
00391 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 1559 of file OSGTextureChunk.cpp.

Referenced by changeFrom().

01560 {    
01561     Window *win = action->getWindow();
01562     
01563     Real32 nteximages, ntexcoords;
01564     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
01565        Window::unknownConstant
01566       )
01567     {
01568         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
01569         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
01570         if(nteximages == Window::unknownConstant)
01571             nteximages = 1.0f;
01572     }
01573     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
01574        Window::unknownConstant
01575       )
01576     {
01577         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
01578         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
01579         if(ntexcoords == Window::unknownConstant)
01580             ntexcoords = 1.0f;
01581     }
01582 
01583     if(idx >= static_cast<UInt32>(nteximages))
01584     {
01585 #ifdef OSG_DEBUG
01586         FWARNING(("TextureChunk::activate: Trying to bind image unit %d,"
01587                   " but Window %p only supports %d!\n",
01588                   idx, win, nteximages));
01589 #endif
01590         return;        
01591     }
01592 
01593     if(activateTexture(win, idx))
01594         return; // trying to access too many textures
01595 
01596     win->validateGLObject(getGLId());
01597 
01598     ImagePtr img = getImage();
01599     GLenum target = getTarget();
01600 
01601     if( img == NullFC || ! img->getDimension()) // no image ?
01602         return;
01603 
01604     glErr("TextureChunk::activate precheck");
01605 
01606     if(img->getSideCount() == 1)
01607     {
01608         if ( target == GL_NONE )
01609         {
01610             if ( img->getDepth() > 1 )
01611             {
01612                     if(win->hasExtension(_extTex3D) ||
01613                        win->getGLVersion() >= 0x0102
01614                       )
01615                         target = GL_TEXTURE_3D;
01616                     else
01617                     {
01618                         FWARNING(("TextureChunk::activate: 3D textures not "
01619                                     "supported for this window!\n"));
01620                         return;
01621                     }
01622             }
01623             else if(img->getHeight() > 1)   target = GL_TEXTURE_2D;
01624             else                            target = GL_TEXTURE_1D;
01625         }
01626     }
01627     else
01628     {
01629         target = GL_TEXTURE_CUBE_MAP_ARB;
01630     }
01631 
01632     FDEBUG(("TextureChunk::activate - %d\n", getGLId()));
01633 
01634     action->getStatistics()->getElem(RenderAction::statNTextures)->inc(getGLId());
01635     action->getStatistics()->getElem(RenderAction::statNTexBytes)->add(
01636                                      getGLId(), getImage()->getSize());
01637 
01638     glBindTexture(target, win->getGLObjectId(getGLId()));
01639 
01640 #ifdef GL_NV_point_sprite
01641     if(idx < static_cast<UInt32>(ntexcoords))
01642     {
01643         if(getPointSprite() &&
01644            win->hasExtension(_nvPointSprite))
01645         {
01646             glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_TRUE);
01647         }
01648     }
01649 #endif
01650 
01651     if(idx < static_cast<UInt32>(nteximages))
01652     {
01653         if(getLodBias() != 0.0f &&
01654            win->hasExtension(_extTextureLodBias))
01655         {
01656             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
01657                   getLodBias());
01658         }
01659     }
01660 
01661     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
01662 
01663     // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
01664     if(ntexunits == Window::unknownConstant)
01665         ntexunits = 1.0f;
01666 
01667     if(idx < static_cast<UInt32>(ntexunits))
01668     {
01669         // texture env
01670         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
01671         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
01672                     (GLfloat*)getEnvColor().getValuesRGBA());
01673 
01674         if(getEnvMode() == GL_COMBINE_EXT)
01675         {
01676             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT,  getEnvCombineRGB ());
01677             glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,    getEnvScaleRGB   ());
01678             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT,  getEnvSource0RGB ());
01679             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT,  getEnvSource1RGB ());
01680             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT,  getEnvSource2RGB ());
01681             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, getEnvOperand0RGB());
01682             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, getEnvOperand1RGB());
01683             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, getEnvOperand2RGB());
01684 
01685             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, getEnvCombineAlpha ());
01686             glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE,       getEnvScaleAlpha   ());
01687             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, getEnvSource0Alpha ());
01688             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, getEnvSource1Alpha ());
01689             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, getEnvSource2Alpha ());
01690             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT,getEnvOperand0Alpha());
01691             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT,getEnvOperand1Alpha());
01692             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT,getEnvOperand2Alpha());
01693         }
01694 
01695         handleTextureShader(win, target);
01696 
01697         if(getShaderOperation() != GL_NONE &&
01698            win->hasExtension(_nvTextureShader) &&
01699            idx == 0)
01700         {
01701             glEnable(GL_TEXTURE_SHADER_NV);
01702         }
01703         glEnable(target);
01704     }
01705     
01706     // Use texture matrix for scaling
01707     UInt32 NpotMatScale = getNPOTMatrixScale();
01708     bool setMatrix = false;
01709     
01710     if ( idx < static_cast<UInt32>(ntexcoords) &&
01711         !getScale() && NpotMatScale )
01712     {
01713         ImagePtr i = getImage();
01714         
01715         if (i != NullFC)
01716         {
01717             Real32 sw=1.f, sh=1.f, sd=1.f,
01718                    tw=0.f, th=0.f, td=0.f;
01719             
01720             if ( (NpotMatScale & NPotTexScale_TT) &&
01721                   getTarget() != GL_TEXTURE_RECTANGLE_ARB &&
01722                  !win->hasExtension(_arbTextureNonPowerOfTwo) )
01723             {
01724                 UInt32 w,h,d,nw,nh,nd;
01725                 
01726                 w = i->getWidth();
01727                 h = i->getHeight();
01728                 d = i->getDepth();
01729                 
01730                 nw = osgnextpower2(w);
01731                 nh = osgnextpower2(h);
01732                 nd = osgnextpower2(d);
01733                 
01734                 sw = w / static_cast<Real32>(nw);
01735                 sh = h / static_cast<Real32>(nh);
01736                 sd = d / static_cast<Real32>(nd);
01737                 
01738                 setMatrix = true;
01739             }
01740             if ( (NpotMatScale & XFlip_TT) )
01741             {
01742                 tw = sw - 1.f;
01743                 sw *= -1.f;
01744                 
01745                 setMatrix = true;
01746             }
01747             if ( (NpotMatScale & YFlip_TT) )
01748             {
01749                 th = sh - 1.f;
01750                 sh *= -1.f;
01751                 
01752                 setMatrix = true;
01753             }
01754             if ( (NpotMatScale & ZFlip_TT) )
01755             {
01756                 td = sd - 1.f;
01757                 sd *= -1.f;
01758                 
01759                 setMatrix = true;
01760             }
01761             
01762             if (setMatrix)
01763             {
01764                 Matrix m;
01765                 
01766                 m.setIdentity();
01767                 m.setScale( Vec3f(sw, sh, sd) );
01768                 m.setTranslate( Vec3f(tw, th, td) );
01769 
01770                 glPushAttrib(GL_TRANSFORM_BIT);
01771                 glMatrixMode(GL_TEXTURE);
01772                 glLoadMatrixf(m.getValues());
01773                 glPopAttrib();
01774             }
01775         }
01776     }
01777     
01778     if (!setMatrix && idx < static_cast<UInt32>(ntexcoords))
01779     {
01780         glPushAttrib(GL_TRANSFORM_BIT);
01781         glMatrixMode(GL_TEXTURE);
01782         glLoadIdentity();
01783         glPopAttrib();
01784     }
01785     
01786     glErr("TextureChunk::activate");
01787 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 1790 of file OSGTextureChunk.cpp.

01793 {
01794     // change from me to me?
01795     // this assumes I haven't changed in the meantime.
01796     // is that a valid assumption?
01797     if(old == this)
01798         return;
01799 
01800     // If the old one is not a texture chunk, deactivate it and activate
01801     // ourselves
01802     // Need to check for exact type, as derived chunks might change
01803     // different state (e.g. CubeTexture)
01804     if(getTypeId() != old->getTypeId())
01805     {
01806         old->deactivate(action, idx);
01807         activate(action, idx);
01808         return;
01809     }
01810 
01811     TextureChunk *oldp      = dynamic_cast<TextureChunk *>(old);
01812 
01813     ImagePtr      img       = getImage();
01814     GLenum        target    = getTarget();
01815     GLenum        oldtarget = oldp->getTarget();
01816     bool          oldused   = (oldp->getImage() != NullFC &&
01817                                oldp->getImage()->getDimension());
01818     
01819     if(img == NullFC || img->getDimension() == 0)
01820     {
01821         oldp->deactivate(action, idx);
01822         return;
01823     }
01824 
01825     glErr("TextureChunk::changeFrom precheck");
01826 
01827     Window *win = action->getWindow();   
01828 
01829     if(activateTexture(win, idx))
01830         return; // trying to use too many textures
01831 
01832     UInt32 nteximages, ntexcoords, ntexunits;
01833     
01834     Real32 dummy = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
01835     
01836     if(dummy == Window::unknownConstant)
01837     {
01838         ntexunits = 1;
01839     }
01840     else
01841     {
01842         ntexunits = static_cast<UInt32>(dummy);
01843     }
01844 
01845     if((dummy = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
01846        Window::unknownConstant
01847       )
01848     {
01849         nteximages = ntexunits;
01850     }
01851     else
01852     {
01853         nteximages = static_cast<UInt32>(dummy);
01854     }
01855     
01856     if((dummy = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
01857        Window::unknownConstant
01858       )
01859     {
01860         ntexcoords = ntexunits;
01861     }
01862     else
01863     {
01864         ntexcoords = static_cast<UInt32>(dummy);
01865     }
01866 
01867     if(idx >= nteximages)
01868     {
01869 #ifdef OSG_DEBUG
01870         FWARNING(("TextureChunk::activate: Trying to bind image unit %d,"
01871                   " but Window %p only supports %d!\n",
01872                   idx, win, nteximages));
01873 #endif
01874         return;        
01875     }
01876 
01877     if(img->getSideCount() == 1)
01878     {
01879         if ( target == GL_NONE )
01880         {
01881             if ( img->getDepth() > 1 )
01882             {
01883                     if(win->hasExtension(_extTex3D) ||
01884                        win->getGLVersion() >= 0x0102
01885                       )
01886                         target = GL_TEXTURE_3D;
01887                     else
01888                     {
01889                         FWARNING(("TextureChunk::activate: 3D textures not "
01890                                     "supported for this window!\n"));
01891                         return;
01892                     }
01893             }
01894             else if(img->getHeight() > 1)   target = GL_TEXTURE_2D;
01895             else                            target = GL_TEXTURE_1D;
01896         }
01897     }
01898     else
01899     {
01900         target = GL_TEXTURE_CUBE_MAP_ARB;
01901     }
01902 
01903     if(oldused)
01904     {
01905         if(oldp->getImage()->getSideCount() == 1)
01906         {
01907             if(oldtarget == GL_NONE)
01908             {
01909                 if(oldp->getImage()->getDepth() > 1)
01910                 {
01911                     if(win->hasExtension(_extTex3D) ||
01912                        win->getGLVersion() >= 0x0102
01913                       )
01914                         oldtarget = GL_TEXTURE_3D;
01915                     else
01916                     {
01917                         FWARNING(("TextureChunk::changeFrom: 3D textures not "
01918                                     "supported for this window!\n"));
01919                         oldp->deactivate(action, idx);
01920                         return;
01921                     }
01922                 }
01923                 else if(oldp->getImage()->getHeight() > 1)
01924                 {
01925                     oldtarget = GL_TEXTURE_2D;
01926                 }
01927                 else
01928                 {
01929                     oldtarget = GL_TEXTURE_1D;
01930                 }
01931             }
01932         }
01933         else
01934         {
01935             oldtarget = GL_TEXTURE_CUBE_MAP_ARB;
01936         }
01937 
01938         if(target != oldtarget && idx < ntexunits)
01939         {
01940             glDisable(oldtarget);
01941         }
01942     }
01943 
01944     win->validateGLObject(getGLId());
01945 
01946     action->getStatistics()->getElem(RenderAction::statNTextures)->inc(getGLId());
01947     action->getStatistics()->getElem(RenderAction::statNTexBytes)->add(
01948         getGLId(), getImage()->getSize());
01949 
01950     glBindTexture(target, win->getGLObjectId(getGLId()));
01951  
01952 #ifdef GL_NV_point_sprite
01953     if(idx < ntexcoords)
01954     {
01955         if((!oldused || oldp->getPointSprite() != getPointSprite()) &&
01956            win->hasExtension(_nvPointSprite)
01957           )
01958         {
01959             glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, getPointSprite());
01960         }
01961     }
01962 #endif
01963 
01964     if(idx < nteximages)
01965     {
01966         if((!oldused || oldp->getLodBias() != getLodBias()) &&
01967            win->hasExtension(_extTextureLodBias)
01968           )
01969         {
01970             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
01971                   getLodBias());
01972         }
01973     }
01974 
01975     if(idx < ntexunits)
01976     {
01977         if(!oldused || oldp->getEnvMode() != getEnvMode())
01978             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
01979 
01980         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,
01981                         (GLfloat*)getEnvColor().getValuesRGBA());
01982 
01983         if(getEnvMode() == GL_COMBINE_EXT)
01984         {
01985             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT,  getEnvCombineRGB ());
01986             glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,    getEnvScaleRGB   ());
01987             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT,  getEnvSource0RGB ());
01988             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT,  getEnvSource1RGB ());
01989             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT,  getEnvSource2RGB ());
01990             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, getEnvOperand0RGB());
01991             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, getEnvOperand1RGB());
01992             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, getEnvOperand2RGB());
01993 
01994             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, getEnvCombineAlpha ());
01995             glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE,       getEnvScaleAlpha   ());
01996             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, getEnvSource0Alpha ());
01997             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, getEnvSource1Alpha ());
01998             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT, getEnvSource2Alpha ());
01999             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT,getEnvOperand0Alpha());
02000             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT,getEnvOperand1Alpha());
02001             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT,getEnvOperand2Alpha());
02002         }
02003 
02004         if(target != oldtarget)
02005         {
02006             glEnable(target);
02007         }
02008 
02009         if(win->hasExtension(_nvTextureShader))
02010         {
02011             if(      getShaderOperation() != GL_NONE &&
02012                (!oldused || oldp->getShaderOperation() == GL_NONE)
02013               )
02014             {
02015                 handleTextureShader(win, target);
02016                 if(idx == 0)
02017                     glEnable(GL_TEXTURE_SHADER_NV);
02018             }
02019             else if(      getShaderOperation() == GL_NONE &&
02020                     (!oldused || oldp->getShaderOperation() != GL_NONE)
02021                    )
02022             {
02023                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
02024                 if(idx == 0)
02025                     glDisable(GL_TEXTURE_SHADER_NV);
02026             }
02027         }
02028     }
02029     
02030     // Use texture matrix for scaling
02031     UInt32 NpotMatScale = getNPOTMatrixScale();
02032     bool setMatrix = false;
02033     
02034     if ( idx < static_cast<UInt32>(ntexcoords) &&
02035         !getScale() && NpotMatScale )
02036     {
02037         ImagePtr i = getImage();
02038         
02039         if (i != NullFC)
02040         {
02041             Real32 sw=1.f, sh=1.f, sd=1.f,
02042                    tw=0.f, th=0.f, td=0.f;
02043             
02044             if ( (NpotMatScale & NPotTexScale_TT) &&
02045                   getTarget() != GL_TEXTURE_RECTANGLE_ARB &&
02046                  !win->hasExtension(_arbTextureNonPowerOfTwo) )
02047             {
02048                 UInt32 w,h,d,nw,nh,nd;
02049                 
02050                 w = i->getWidth();
02051                 h = i->getHeight();
02052                 d = i->getDepth();
02053                 
02054                 nw = osgnextpower2(w);
02055                 nh = osgnextpower2(h);
02056                 nd = osgnextpower2(d);
02057                 
02058                 sw = w / static_cast<Real32>(nw);
02059                 sh = h / static_cast<Real32>(nh);
02060                 sd = d / static_cast<Real32>(nd);
02061                 
02062                 setMatrix = true;
02063             }
02064             if ( (NpotMatScale & XFlip_TT) )
02065             {
02066                 tw = sw - 1.f;
02067                 sw *= -1.f;
02068                 
02069                 setMatrix = true;
02070             }
02071             if ( (NpotMatScale & YFlip_TT) )
02072             {
02073                 th = sh - 1.f;
02074                 sh *= -1.f;
02075                 
02076                 setMatrix = true;
02077             }
02078             if ( (NpotMatScale & ZFlip_TT) )
02079             {
02080                 td = sd - 1.f;
02081                 sd *= -1.f;
02082                 
02083                 setMatrix = true;
02084             }
02085             
02086             if (setMatrix)
02087             {
02088                 Matrix m;
02089                 
02090                 m.setIdentity();
02091                 m.setScale( Vec3f(sw, sh, sd) );
02092                 m.setTranslate( Vec3f(tw, th, td) );
02093                 
02094                 glPushAttrib(GL_TRANSFORM_BIT);
02095                 glMatrixMode(GL_TEXTURE);
02096                 glLoadMatrixf(m.getValues());
02097                 glPopAttrib();
02098             }
02099         }
02100     }
02101 
02102     if (!setMatrix && idx < static_cast<UInt32>(ntexcoords))
02103     {
02104         glPushAttrib(GL_TRANSFORM_BIT);
02105         glMatrixMode(GL_TEXTURE);
02106         glLoadIdentity();
02107         glPopAttrib();
02108     }
02109     
02110     glErr("TextureChunk::changeFrom");
02111 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 2113 of file OSGTextureChunk.cpp.

References _extTex3D, _extTextureLodBias, _nvPointSprite, _nvTextureShader, activateTexture(), FWARNING, osg::Window::getConstantValue(), osg::Window::getGLVersion(), osg::TextureChunkBase::getImage(), osg::TextureChunkBase::getLodBias(), osg::TextureChunkBase::getPointSprite(), osg::TextureChunkBase::getShaderOperation(), osg::TextureChunkBase::getTarget(), 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_3D, GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, GL_TEXTURE_SHADER_NV, GLenum, glErr, osg::Window::hasExtension(), osg::NullFC, and osg::Window::unknownConstant.

Referenced by changeFrom().

02114 {
02115     Window *win = action->getWindow();   
02116 
02117     Real32 nteximages, ntexcoords;
02118     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
02119        Window::unknownConstant
02120       )
02121     {
02122         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
02123         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
02124         if(nteximages == Window::unknownConstant)
02125             nteximages = 1.0f;
02126     }
02127     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
02128        Window::unknownConstant
02129       )
02130     {
02131         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
02132         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
02133         if(ntexcoords == Window::unknownConstant)
02134             ntexcoords = 1.0f;
02135     }
02136 
02137     if(idx >= static_cast<UInt32>(nteximages))
02138     {
02139 #ifdef OSG_DEBUG
02140         FWARNING(("TextureChunk::deactivate: Trying to bind image unit %d,"
02141                   " but Window %p only supports %d!\n",
02142                   idx, win, nteximages));
02143 #endif
02144         return;        
02145     }
02146 
02147     ImagePtr img = getImage();
02148     GLenum target = getTarget();
02149 
02150     if(img == NullFC || ! img->getDimension())
02151       return;
02152 
02153     glErr("TextureChunk::deactivate precheck");
02154 
02155     bool isActive = false;
02156 
02157 #ifdef GL_NV_point_sprite
02158     if(getPointSprite() &&
02159        win->hasExtension(_nvPointSprite) &&
02160        idx < static_cast<UInt32>(ntexcoords)
02161       )
02162     {
02163         if(!isActive)
02164         {
02165             activateTexture(win, idx);
02166             isActive = true;
02167         }
02168         glTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_FALSE);
02169     }
02170 #endif
02171 
02172     if(getLodBias() != 0.0f &&
02173        win->hasExtension(_extTextureLodBias))
02174     {
02175         if(!isActive)
02176             activateTexture(win, idx);
02177         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT,
02178                 0.0f);
02179     }
02180     
02181     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
02182     if(ntexunits == Window::unknownConstant)
02183         ntexunits = 1.0f;
02184 
02185     if(idx >= static_cast<UInt32>(ntexunits))
02186         return; // textures >= MTU are not enabled and don't have an env
02187         
02188     if(!isActive)
02189         activateTexture(win, idx);
02190 
02191     if(img->getSideCount() == 1)
02192     {
02193         if ( target == GL_NONE )
02194         {
02195             if ( img->getDepth() > 1 )
02196             {
02197                     if(win->hasExtension(_extTex3D) ||
02198                        win->getGLVersion() >= 0x0102
02199                       )
02200                         target = GL_TEXTURE_3D;
02201                     else
02202                     {
02203                         FWARNING(("TextureChunk::activate: 3D textures not "
02204                                     "supported for this window!\n"));
02205                         return;
02206                     }
02207             }
02208             else if(img->getHeight() > 1)   target = GL_TEXTURE_2D;
02209             else                            target = GL_TEXTURE_1D;
02210         }
02211     }
02212     else
02213     {
02214         target = GL_TEXTURE_CUBE_MAP_ARB;
02215     }
02216 
02217     if(getShaderOperation() != GL_NONE &&
02218        win->hasExtension(_nvTextureShader))
02219     {
02220         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
02221 
02222         if(idx == 0)
02223             glDisable(GL_TEXTURE_SHADER_NV);
02224     }
02225     
02226     // be consistent with TextureTransform which has to multiply
02227     //UInt32 NpotMatScale = getNPOTMatrixScale();
02228     
02229     if ( idx < static_cast<UInt32>(ntexcoords) )
02230     {
02231         glPushAttrib(GL_TRANSFORM_BIT);
02232         glMatrixMode(GL_TEXTURE);
02233         glLoadIdentity();
02234         glPopAttrib();
02235     }
02236     
02237     glDisable(target);
02238 
02239     glErr("TextureChunk::deactivate");
02240 }

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

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 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 2244 of file OSGTextureChunk.cpp.

02245 {
02246     return 0;
02247 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 2249 of file OSGTextureChunk.cpp.

02250 {
02251     return this < &other;
02252 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 2254 of file OSGTextureChunk.cpp.

02255 {
02256     TextureChunk const *tother = dynamic_cast<TextureChunk const*>(&other);
02257 
02258     if(!tother)
02259         return false;
02260 
02261     if(tother == this)
02262         return true;
02263 
02264     bool returnValue =
02265         getImage    () == tother->getImage    () &&
02266         getMinFilter() == tother->getMinFilter() &&
02267         getMagFilter() == tother->getMagFilter() &&
02268         getWrapS    () == tother->getWrapS    () &&
02269         getWrapT    () == tother->getWrapT    () &&
02270         getWrapR    () == tother->getWrapR    () &&
02271         getPriority () == tother->getPriority () &&
02272         getEnvMode  () == tother->getEnvMode  () &&
02273         getNPOTMatrixScale() == tother->getNPOTMatrixScale();
02274 
02275     if(returnValue == true && getEnvMode() == GL_COMBINE_EXT)
02276     {
02277         returnValue =
02278             getEnvCombineRGB ()   == tother->getEnvCombineRGB   () &&
02279 
02280             getEnvSource0RGB ()   == tother->getEnvSource0RGB   () &&
02281             getEnvSource1RGB ()   == tother->getEnvSource1RGB   () &&
02282             getEnvSource2RGB ()   == tother->getEnvSource2RGB   () &&
02283 
02284             getEnvOperand0RGB()   == tother->getEnvOperand0RGB  () &&
02285             getEnvOperand1RGB()   == tother->getEnvOperand1RGB  () &&
02286             getEnvOperand2RGB()   == tother->getEnvOperand2RGB  () &&
02287 
02288             getEnvCombineAlpha () == tother->getEnvCombineAlpha () &&
02289 
02290             getEnvSource0Alpha () == tother->getEnvSource0Alpha () &&
02291             getEnvSource1Alpha () == tother->getEnvSource1Alpha () &&
02292             getEnvSource2Alpha () == tother->getEnvSource2Alpha () &&
02293 
02294             getEnvOperand0Alpha() == tother->getEnvOperand0Alpha() &&
02295             getEnvOperand1Alpha() == tother->getEnvOperand1Alpha() &&
02296             getEnvOperand2Alpha() == tother->getEnvOperand2Alpha();
02297 
02298         returnValue &=
02299            ((        getEnvScaleRGB  () - tother->getEnvScaleRGB  ()) < Eps) &&
02300            ((tother->getEnvScaleRGB  () -         getEnvScaleRGB  ()) < Eps) &&
02301            ((        getEnvScaleAlpha() - tother->getEnvScaleAlpha()) < Eps) &&
02302            ((tother->getEnvScaleAlpha() -         getEnvScaleAlpha()) < Eps);
02303     }
02304 
02305     return returnValue;
02306 }

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

Reimplemented from osg::StateChunk.

Reimplemented in osg::CubeTextureChunk.

Definition at line 2308 of file OSGTextureChunk.cpp.

02309 {
02310     return ! (*this == other);
02311 }

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

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 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]

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 changed().

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

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

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]

Definition at line 99 of file OSGTextureChunk.inl.

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

Referenced by activateTexture().

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

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

Definition at line 106 of file OSGTextureChunk.inl.

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

Referenced by 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]`

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 activeTexture(), FWARNING, and hasMultiTexture().

Referenced by osg::TextureTransformChunk::activate(), activate(), osg::TexGenChunk::activate(), osg::CubeTextureChunk::activate(), osg::TextureTransformChunk::changeFrom(), changeFrom(), osg::TexGenChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::TextureTransformChunk::deactivate(), deactivate(), osg::TexGenChunk::deactivate(), and osg::CubeTextureChunk::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]

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, 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 TextureChunk::onDestroy ( void ) [protected, virtual]

Reimplemented from osg::Attachment.

Reimplemented in osg::CubeTextureChunk.

Definition at line 375 of file OSGTextureChunk.cpp.

References osg::TextureChunkBase::_sfImage, osg::Window::destroyGLObject(), osg::TextureChunkBase::getGLId(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::NullFC, osg::Attachment::onDestroy(), and osg::subRefCP().

Referenced by osg::CubeTextureChunk::onDestroy().

00376 {
00377     Inherited::onDestroy();
00378 
00379     if(_sfImage.getValue() != NullFC)
00380         subRefCP(_sfImage.getValue());
00381     if(getGLId() > 0)
00382         Window::destroyGLObject(getGLId(), 1);
00383 }

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

Definition at line 521 of file OSGTextureChunk.cpp.

Referenced by handleGL(), and osg::CubeTextureChunk::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]`

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

Definition at line 400 of file OSGTextureChunk.cpp.

Referenced by activate(), osg::CubeTextureChunk::activate(), changeFrom(), and osg::CubeTextureChunk::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]

Reimplemented from osg::StateChunk.

Definition at line 149 of file OSGTextureChunk.cpp.

00150 {
00151 }

void TextureChunk::handleGL	(	Window *	win,
		UInt32	idstatus
	)			`[private]`

GL object handler create the texture and destroy it

Reimplemented in osg::CubeTextureChunk.

Definition at line 1455 of file OSGTextureChunk.cpp.

References _extTex3D, osg::Window::destroy, osg::Window::finaldestroy, FWARNING, osg::Window::getGLObjectId(), osg::Window::getGLVersion(), osg::TextureChunkBase::getImage(), osg::TextureChunkBase::getTarget(), GL_TEXTURE_3D, 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, GLenum, GLuint(), handleTexture(), osg::Window::hasExtension(), osg::Window::initialize, osg::Window::needrefresh, osg::NullFC, osg::Window::reinitialize, osg::Window::setGLObjectId(), SWARNING, and osg::Window::unpackIdStatus().

Referenced by changed(), and onCreate().

01456 {
01457     Window::GLObjectStatusE mode;
01458     UInt32 osgid;
01459     GLuint id;
01460 
01461     Window::unpackIdStatus(idstatus, osgid, mode);
01462 
01463     id = win->getGLObjectId(osgid);
01464     
01465     if(mode == Window::destroy)
01466     {
01467         glDeleteTextures(1, &id);
01468         win->setGLObjectId(osgid, 0);
01469     }
01470     else if(mode == Window::finaldestroy)
01471     {
01472         //SWARNING << "Last texture user destroyed" << std::endl;
01473     }
01474     else if(mode == Window::initialize || mode == Window::reinitialize ||
01475             mode == Window::needrefresh )
01476     {
01477         if(mode == Window::initialize)
01478         {
01479             glGenTextures(1, &id);
01480             win->setGLObjectId(osgid, id);
01481         }
01482         
01483         GLenum target;
01484 
01485         ImagePtr img = getImage();
01486 
01487         if (img != NullFC)
01488         {
01489             if(img->getSideCount() == 1)
01490             {
01491                 target = getTarget();
01492                 if ( target == GL_NONE )
01493                 {
01494                     if(img->getDepth() > 1)
01495                     {
01496                         if(win->hasExtension(_extTex3D) ||
01497                            win->getGLVersion() >= 0x0102
01498                           )
01499                             target = GL_TEXTURE_3D;
01500                         else
01501                         {
01502                             FWARNING(("TextureChunk::initialize: 3D textures not "
01503                                         "supported for this window!\n"));
01504                             return;
01505                         }
01506                     }
01507                     else if(img->getHeight() > 1)        target = GL_TEXTURE_2D;
01508                     else                                 target = GL_TEXTURE_1D;
01509                 }
01510 
01511                 handleTexture(win, id, target, target, target, mode, img);
01512             }
01513             else // Got a cubemap...
01514             {
01515                 handleTexture(win, id, 
01516                               GL_TEXTURE_CUBE_MAP_ARB, 
01517                               GL_TEXTURE_CUBE_MAP_ARB, 
01518                               GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 
01519                               mode, getImage(), 5); 
01520                 // Have to use initialize mode here, otherwise the
01521                 // texture is destroyed for every side      
01522                 handleTexture(win, id, 
01523                               GL_TEXTURE_CUBE_MAP_ARB, 
01524                               GL_NONE, 
01525                               GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 
01526                               Window::initialize, getImage(), 4);        
01527                 handleTexture(win, id, 
01528                               GL_TEXTURE_CUBE_MAP_ARB, 
01529                               GL_NONE, 
01530                               GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 
01531                               Window::initialize, getImage(), 3);        
01532                 handleTexture(win, id, 
01533                               GL_TEXTURE_CUBE_MAP_ARB, 
01534                               GL_NONE, 
01535                               GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 
01536                               Window::initialize, getImage(), 2);        
01537                 handleTexture(win, id, 
01538                               GL_TEXTURE_CUBE_MAP_ARB, 
01539                               GL_NONE, 
01540                               GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 
01541                               Window::initialize, getImage(), 1);        
01542                 handleTexture(win, id, 
01543                               GL_TEXTURE_CUBE_MAP_ARB, 
01544                               GL_NONE, 
01545                               GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 
01546                               Window::initialize, getImage(), 0);        
01547 
01548             }
01549         }
01550     }
01551     else
01552     {
01553         SWARNING << "TextureChunk(" << this << "::handleGL: Illegal mode: "
01554              << mode << " for id " << id << std::endl;
01555     }
01556 
01557 }

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

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 58 of file OSGTextureChunkBase.inl.

References osg::TextureChunkBase::_type.

Referenced by osg::TextureChunkBase::create(), osg::VRMLAppearanceDesc::endNode(), modifyMaterial(), and osg::RemoteAspect::RemoteAspect().

00059 {
00060     return _type; 
00061 }

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 65 of file OSGTextureChunkBase.inl.

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

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

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 705 of file OSGTextureChunkBase.cpp.

References osg::TextureChunkBase::_type.

00706 {
00707     return _type; 
00708 }

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 710 of file OSGTextureChunkBase.cpp.

References osg::TextureChunkBase::_type.

00711 {
00712     return _type;
00713 }

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 725 of file OSGTextureChunkBase.cpp.

00726 { 
00727     return sizeof(TextureChunk); 
00728 }

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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), deactivate(), handleGL(), osg::CubeTextureChunk::handleGL(), and 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 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 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 activate(), changeFrom(), and 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 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 changed(), handleTexture(), and 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 handleTexture(), and 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 handleTexture(), and 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 handleTexture(), and 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 handleTexture(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), and osg::CubeTextureChunk::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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changed(), changeFrom(), osg::CubeTextureChunk::changeFrom(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), deactivate(), and osg::CubeTextureChunk::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 handleTexture(), and 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), deactivate(), osg::CubeTextureChunk::deactivate(), and 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 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 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 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 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 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 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 activate(), osg::CubeTextureChunk::activate(), changeFrom(), osg::CubeTextureChunk::changeFrom(), deactivate(), and osg::CubeTextureChunk::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 activate(), changeFrom(), deactivate(), and 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 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 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 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 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 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 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 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 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 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 activate(), changeFrom(), and 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 handleTextureShader(), and 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::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::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 changed(), onCreate(), and osg::CubeTextureChunk::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::TextureChunkBase::getBinSize ( const BitVector & whichField ) [virtual, inherited]

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 892 of file OSGTextureChunkBase.cpp.

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

00893 {
00894     UInt32 returnValue = Inherited::getBinSize(whichField);
00895 
00896     if(FieldBits::NoField != (ImageFieldMask & whichField))
00897     {
00898         returnValue += _sfImage.getBinSize();
00899     }
00900 
00901     if(FieldBits::NoField != (InternalFormatFieldMask & whichField))
00902     {
00903         returnValue += _sfInternalFormat.getBinSize();
00904     }
00905 
00906     if(FieldBits::NoField != (ExternalFormatFieldMask & whichField))
00907     {
00908         returnValue += _sfExternalFormat.getBinSize();
00909     }
00910 
00911     if(FieldBits::NoField != (ScaleFieldMask & whichField))
00912     {
00913         returnValue += _sfScale.getBinSize();
00914     }
00915 
00916     if(FieldBits::NoField != (FrameFieldMask & whichField))
00917     {
00918         returnValue += _sfFrame.getBinSize();
00919     }
00920 
00921     if(FieldBits::NoField != (MinFilterFieldMask & whichField))
00922     {
00923         returnValue += _sfMinFilter.getBinSize();
00924     }
00925 
00926     if(FieldBits::NoField != (MagFilterFieldMask & whichField))
00927     {
00928         returnValue += _sfMagFilter.getBinSize();
00929     }
00930 
00931     if(FieldBits::NoField != (WrapSFieldMask & whichField))
00932     {
00933         returnValue += _sfWrapS.getBinSize();
00934     }
00935 
00936     if(FieldBits::NoField != (WrapTFieldMask & whichField))
00937     {
00938         returnValue += _sfWrapT.getBinSize();
00939     }
00940 
00941     if(FieldBits::NoField != (WrapRFieldMask & whichField))
00942     {
00943         returnValue += _sfWrapR.getBinSize();
00944     }
00945 
00946     if(FieldBits::NoField != (EnvModeFieldMask & whichField))
00947     {
00948         returnValue += _sfEnvMode.getBinSize();
00949     }
00950 
00951     if(FieldBits::NoField != (EnvColorFieldMask & whichField))
00952     {
00953         returnValue += _sfEnvColor.getBinSize();
00954     }
00955 
00956     if(FieldBits::NoField != (EnvCombineRGBFieldMask & whichField))
00957     {
00958         returnValue += _sfEnvCombineRGB.getBinSize();
00959     }
00960 
00961     if(FieldBits::NoField != (EnvCombineAlphaFieldMask & whichField))
00962     {
00963         returnValue += _sfEnvCombineAlpha.getBinSize();
00964     }
00965 
00966     if(FieldBits::NoField != (EnvScaleRGBFieldMask & whichField))
00967     {
00968         returnValue += _sfEnvScaleRGB.getBinSize();
00969     }
00970 
00971     if(FieldBits::NoField != (EnvScaleAlphaFieldMask & whichField))
00972     {
00973         returnValue += _sfEnvScaleAlpha.getBinSize();
00974     }
00975 
00976     if(FieldBits::NoField != (EnvSource0RGBFieldMask & whichField))
00977     {
00978         returnValue += _sfEnvSource0RGB.getBinSize();
00979     }
00980 
00981     if(FieldBits::NoField != (EnvSource1RGBFieldMask & whichField))
00982     {
00983         returnValue += _sfEnvSource1RGB.getBinSize();
00984     }
00985 
00986     if(FieldBits::NoField != (EnvSource2RGBFieldMask & whichField))
00987     {
00988         returnValue += _sfEnvSource2RGB.getBinSize();
00989     }
00990 
00991     if(FieldBits::NoField != (EnvSource0AlphaFieldMask & whichField))
00992     {
00993         returnValue += _sfEnvSource0Alpha.getBinSize();
00994     }
00995 
00996     if(FieldBits::NoField != (EnvSource1AlphaFieldMask & whichField))
00997     {
00998         returnValue += _sfEnvSource1Alpha.getBinSize();
00999     }
01000 
01001     if(FieldBits::NoField != (EnvSource2AlphaFieldMask & whichField))
01002     {
01003         returnValue += _sfEnvSource2Alpha.getBinSize();
01004     }
01005 
01006     if(FieldBits::NoField != (EnvOperand0RGBFieldMask & whichField))
01007     {
01008         returnValue += _sfEnvOperand0RGB.getBinSize();
01009     }
01010 
01011     if(FieldBits::NoField != (EnvOperand1RGBFieldMask & whichField))
01012     {
01013         returnValue += _sfEnvOperand1RGB.getBinSize();
01014     }
01015 
01016     if(FieldBits::NoField != (EnvOperand2RGBFieldMask & whichField))
01017     {
01018         returnValue += _sfEnvOperand2RGB.getBinSize();
01019     }
01020 
01021     if(FieldBits::NoField != (EnvOperand0AlphaFieldMask & whichField))
01022     {
01023         returnValue += _sfEnvOperand0Alpha.getBinSize();
01024     }
01025 
01026     if(FieldBits::NoField != (EnvOperand1AlphaFieldMask & whichField))
01027     {
01028         returnValue += _sfEnvOperand1Alpha.getBinSize();
01029     }
01030 
01031     if(FieldBits::NoField != (EnvOperand2AlphaFieldMask & whichField))
01032     {
01033         returnValue += _sfEnvOperand2Alpha.getBinSize();
01034     }
01035 
01036     if(FieldBits::NoField != (GLIdFieldMask & whichField))
01037     {
01038         returnValue += _sfGLId.getBinSize();
01039     }
01040 
01041     if(FieldBits::NoField != (IgnoreGLForAspectFieldMask & whichField))
01042     {
01043         returnValue += _sfIgnoreGLForAspect.getBinSize();
01044     }
01045 
01046     if(FieldBits::NoField != (PointSpriteFieldMask & whichField))
01047     {
01048         returnValue += _sfPointSprite.getBinSize();
01049     }
01050 
01051     if(FieldBits::NoField != (PriorityFieldMask & whichField))
01052     {
01053         returnValue += _sfPriority.getBinSize();
01054     }
01055 
01056     if(FieldBits::NoField != (ShaderOperationFieldMask & whichField))
01057     {
01058         returnValue += _sfShaderOperation.getBinSize();
01059     }
01060 
01061     if(FieldBits::NoField != (ShaderInputFieldMask & whichField))
01062     {
01063         returnValue += _sfShaderInput.getBinSize();
01064     }
01065 
01066     if(FieldBits::NoField != (ShaderOffsetMatrixFieldMask & whichField))
01067     {
01068         returnValue += _mfShaderOffsetMatrix.getBinSize();
01069     }
01070 
01071     if(FieldBits::NoField != (ShaderOffsetScaleFieldMask & whichField))
01072     {
01073         returnValue += _sfShaderOffsetScale.getBinSize();
01074     }
01075 
01076     if(FieldBits::NoField != (ShaderOffsetBiasFieldMask & whichField))
01077     {
01078         returnValue += _sfShaderOffsetBias.getBinSize();
01079     }
01080 
01081     if(FieldBits::NoField != (ShaderRGBADotProductFieldMask & whichField))
01082     {
01083         returnValue += _sfShaderRGBADotProduct.getBinSize();
01084     }
01085 
01086     if(FieldBits::NoField != (ShaderCullModesFieldMask & whichField))
01087     {
01088         returnValue += _sfShaderCullModes.getBinSize();
01089     }
01090 
01091     if(FieldBits::NoField != (ShaderConstEyeFieldMask & whichField))
01092     {
01093         returnValue += _sfShaderConstEye.getBinSize();
01094     }
01095 
01096     if(FieldBits::NoField != (LodBiasFieldMask & whichField))
01097     {
01098         returnValue += _sfLodBias.getBinSize();
01099     }
01100 
01101     if(FieldBits::NoField != (TargetFieldMask & whichField))
01102     {
01103         returnValue += _sfTarget.getBinSize();
01104     }
01105 
01106     if(FieldBits::NoField != (DirtyLeftFieldMask & whichField))
01107     {
01108         returnValue += _sfDirtyLeft.getBinSize();
01109     }
01110 
01111     if(FieldBits::NoField != (DirtyMinXFieldMask & whichField))
01112     {
01113         returnValue += _sfDirtyMinX.getBinSize();
01114     }
01115 
01116     if(FieldBits::NoField != (DirtyMaxXFieldMask & whichField))
01117     {
01118         returnValue += _sfDirtyMaxX.getBinSize();
01119     }
01120 
01121     if(FieldBits::NoField != (DirtyMinYFieldMask & whichField))
01122     {
01123         returnValue += _sfDirtyMinY.getBinSize();
01124     }
01125 
01126     if(FieldBits::NoField != (DirtyMaxYFieldMask & whichField))
01127     {
01128         returnValue += _sfDirtyMaxY.getBinSize();
01129     }
01130 
01131     if(FieldBits::NoField != (DirtyMinZFieldMask & whichField))
01132     {
01133         returnValue += _sfDirtyMinZ.getBinSize();
01134     }
01135 
01136     if(FieldBits::NoField != (DirtyMaxZFieldMask & whichField))
01137     {
01138         returnValue += _sfDirtyMaxZ.getBinSize();
01139     }
01140 
01141     if(FieldBits::NoField != (AnisotropyFieldMask & whichField))
01142     {
01143         returnValue += _sfAnisotropy.getBinSize();
01144     }
01145 
01146     if(FieldBits::NoField != (BorderColorFieldMask & whichField))
01147     {
01148         returnValue += _sfBorderColor.getBinSize();
01149     }
01150 
01151     if(FieldBits::NoField != (BorderWidthFieldMask & whichField))
01152     {
01153         returnValue += _sfBorderWidth.getBinSize();
01154     }
01155 
01156     if(FieldBits::NoField != (NPOTMatrixScaleFieldMask & whichField))
01157     {
01158         returnValue += _sfNPOTMatrixScale.getBinSize();
01159     }
01160 
01161 
01162     return returnValue;
01163 }

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 1165 of file OSGTextureChunkBase.cpp.

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

01167 {
01168     Inherited::copyToBin(pMem, whichField);
01169 
01170     if(FieldBits::NoField != (ImageFieldMask & whichField))
01171     {
01172         _sfImage.copyToBin(pMem);
01173     }
01174 
01175     if(FieldBits::NoField != (InternalFormatFieldMask & whichField))
01176     {
01177         _sfInternalFormat.copyToBin(pMem);
01178     }
01179 
01180     if(FieldBits::NoField != (ExternalFormatFieldMask & whichField))
01181     {
01182         _sfExternalFormat.copyToBin(pMem);
01183     }
01184 
01185     if(FieldBits::NoField != (ScaleFieldMask & whichField))
01186     {
01187         _sfScale.copyToBin(pMem);
01188     }
01189 
01190     if(FieldBits::NoField != (FrameFieldMask & whichField))
01191     {
01192         _sfFrame.copyToBin(pMem);
01193     }
01194 
01195     if(FieldBits::NoField != (MinFilterFieldMask & whichField))
01196     {
01197         _sfMinFilter.copyToBin(pMem);
01198     }
01199 
01200     if(FieldBits::NoField != (MagFilterFieldMask & whichField))
01201     {
01202         _sfMagFilter.copyToBin(pMem);
01203     }
01204 
01205     if(FieldBits::NoField != (WrapSFieldMask & whichField))
01206     {
01207         _sfWrapS.copyToBin(pMem);
01208     }
01209 
01210     if(FieldBits::NoField != (WrapTFieldMask & whichField))
01211     {
01212         _sfWrapT.copyToBin(pMem);
01213     }
01214 
01215     if(FieldBits::NoField != (WrapRFieldMask & whichField))
01216     {
01217         _sfWrapR.copyToBin(pMem);
01218     }
01219 
01220     if(FieldBits::NoField != (EnvModeFieldMask & whichField))
01221     {
01222         _sfEnvMode.copyToBin(pMem);
01223     }
01224 
01225     if(FieldBits::NoField != (EnvColorFieldMask & whichField))
01226     {
01227         _sfEnvColor.copyToBin(pMem);
01228     }
01229 
01230     if(FieldBits::NoField != (EnvCombineRGBFieldMask & whichField))
01231     {
01232         _sfEnvCombineRGB.copyToBin(pMem);
01233     }
01234 
01235     if(FieldBits::NoField != (EnvCombineAlphaFieldMask & whichField))
01236     {
01237         _sfEnvCombineAlpha.copyToBin(pMem);
01238     }
01239 
01240     if(FieldBits::NoField != (EnvScaleRGBFieldMask & whichField))
01241     {
01242         _sfEnvScaleRGB.copyToBin(pMem);
01243     }
01244 
01245     if(FieldBits::NoField != (EnvScaleAlphaFieldMask & whichField))
01246     {
01247         _sfEnvScaleAlpha.copyToBin(pMem);
01248     }
01249 
01250     if(FieldBits::NoField != (EnvSource0RGBFieldMask & whichField))
01251     {
01252         _sfEnvSource0RGB.copyToBin(pMem);
01253     }
01254 
01255     if(FieldBits::NoField != (EnvSource1RGBFieldMask & whichField))
01256     {
01257         _sfEnvSource1RGB.copyToBin(pMem);
01258     }
01259 
01260     if(FieldBits::NoField != (EnvSource2RGBFieldMask & whichField))
01261     {
01262         _sfEnvSource2RGB.copyToBin(pMem);
01263     }
01264 
01265     if(FieldBits::NoField != (EnvSource0AlphaFieldMask & whichField))
01266     {
01267         _sfEnvSource0Alpha.copyToBin(pMem);
01268     }
01269 
01270     if(FieldBits::NoField != (EnvSource1AlphaFieldMask & whichField))
01271     {
01272         _sfEnvSource1Alpha.copyToBin(pMem);
01273     }
01274 
01275     if(FieldBits::NoField != (EnvSource2AlphaFieldMask & whichField))
01276     {
01277         _sfEnvSource2Alpha.copyToBin(pMem);
01278     }
01279 
01280     if(FieldBits::NoField != (EnvOperand0RGBFieldMask & whichField))
01281     {
01282         _sfEnvOperand0RGB.copyToBin(pMem);
01283     }
01284 
01285     if(FieldBits::NoField != (EnvOperand1RGBFieldMask & whichField))
01286     {
01287         _sfEnvOperand1RGB.copyToBin(pMem);
01288     }
01289 
01290     if(FieldBits::NoField != (EnvOperand2RGBFieldMask & whichField))
01291     {
01292         _sfEnvOperand2RGB.copyToBin(pMem);
01293     }
01294 
01295     if(FieldBits::NoField != (EnvOperand0AlphaFieldMask & whichField))
01296     {
01297         _sfEnvOperand0Alpha.copyToBin(pMem);
01298     }
01299 
01300     if(FieldBits::NoField != (EnvOperand1AlphaFieldMask & whichField))
01301     {
01302         _sfEnvOperand1Alpha.copyToBin(pMem);
01303     }
01304 
01305     if(FieldBits::NoField != (EnvOperand2AlphaFieldMask & whichField))
01306     {
01307         _sfEnvOperand2Alpha.copyToBin(pMem);
01308     }
01309 
01310     if(FieldBits::NoField != (GLIdFieldMask & whichField))
01311     {
01312         _sfGLId.copyToBin(pMem);
01313     }
01314 
01315     if(FieldBits::NoField != (IgnoreGLForAspectFieldMask & whichField))
01316     {
01317         _sfIgnoreGLForAspect.copyToBin(pMem);
01318     }
01319 
01320     if(FieldBits::NoField != (PointSpriteFieldMask & whichField))
01321     {
01322         _sfPointSprite.copyToBin(pMem);
01323     }
01324 
01325     if(FieldBits::NoField != (PriorityFieldMask & whichField))
01326     {
01327         _sfPriority.copyToBin(pMem);
01328     }
01329 
01330     if(FieldBits::NoField != (ShaderOperationFieldMask & whichField))
01331     {
01332         _sfShaderOperation.copyToBin(pMem);
01333     }
01334 
01335     if(FieldBits::NoField != (ShaderInputFieldMask & whichField))
01336     {
01337         _sfShaderInput.copyToBin(pMem);
01338     }
01339 
01340     if(FieldBits::NoField != (ShaderOffsetMatrixFieldMask & whichField))
01341     {
01342         _mfShaderOffsetMatrix.copyToBin(pMem);
01343     }
01344 
01345     if(FieldBits::NoField != (ShaderOffsetScaleFieldMask & whichField))
01346     {
01347         _sfShaderOffsetScale.copyToBin(pMem);
01348     }
01349 
01350     if(FieldBits::NoField != (ShaderOffsetBiasFieldMask & whichField))
01351     {
01352         _sfShaderOffsetBias.copyToBin(pMem);
01353     }
01354 
01355     if(FieldBits::NoField != (ShaderRGBADotProductFieldMask & whichField))
01356     {
01357         _sfShaderRGBADotProduct.copyToBin(pMem);
01358     }
01359 
01360     if(FieldBits::NoField != (ShaderCullModesFieldMask & whichField))
01361     {
01362         _sfShaderCullModes.copyToBin(pMem);
01363     }
01364 
01365     if(FieldBits::NoField != (ShaderConstEyeFieldMask & whichField))
01366     {
01367         _sfShaderConstEye.copyToBin(pMem);
01368     }
01369 
01370     if(FieldBits::NoField != (LodBiasFieldMask & whichField))
01371     {
01372         _sfLodBias.copyToBin(pMem);
01373     }
01374 
01375     if(FieldBits::NoField != (TargetFieldMask & whichField))
01376     {
01377         _sfTarget.copyToBin(pMem);
01378     }
01379 
01380     if(FieldBits::NoField != (DirtyLeftFieldMask & whichField))
01381     {
01382         _sfDirtyLeft.copyToBin(pMem);
01383     }
01384 
01385     if(FieldBits::NoField != (DirtyMinXFieldMask & whichField))
01386     {
01387         _sfDirtyMinX.copyToBin(pMem);
01388     }
01389 
01390     if(FieldBits::NoField != (DirtyMaxXFieldMask & whichField))
01391     {
01392         _sfDirtyMaxX.copyToBin(pMem);
01393     }
01394 
01395     if(FieldBits::NoField != (DirtyMinYFieldMask & whichField))
01396     {
01397         _sfDirtyMinY.copyToBin(pMem);
01398     }
01399 
01400     if(FieldBits::NoField != (DirtyMaxYFieldMask & whichField))
01401     {
01402         _sfDirtyMaxY.copyToBin(pMem);
01403     }
01404 
01405     if(FieldBits::NoField != (DirtyMinZFieldMask & whichField))
01406     {
01407         _sfDirtyMinZ.copyToBin(pMem);
01408     }
01409 
01410     if(FieldBits::NoField != (DirtyMaxZFieldMask & whichField))
01411     {
01412         _sfDirtyMaxZ.copyToBin(pMem);
01413     }
01414 
01415     if(FieldBits::NoField != (AnisotropyFieldMask & whichField))
01416     {
01417         _sfAnisotropy.copyToBin(pMem);
01418     }
01419 
01420     if(FieldBits::NoField != (BorderColorFieldMask & whichField))
01421     {
01422         _sfBorderColor.copyToBin(pMem);
01423     }
01424 
01425     if(FieldBits::NoField != (BorderWidthFieldMask & whichField))
01426     {
01427         _sfBorderWidth.copyToBin(pMem);
01428     }
01429 
01430     if(FieldBits::NoField != (NPOTMatrixScaleFieldMask & whichField))
01431     {
01432         _sfNPOTMatrixScale.copyToBin(pMem);
01433     }
01434 
01435 
01436 }

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

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 1438 of file OSGTextureChunkBase.cpp.

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

01440 {
01441     Inherited::copyFromBin(pMem, whichField);
01442 
01443     if(FieldBits::NoField != (ImageFieldMask & whichField))
01444     {
01445         _sfImage.copyFromBin(pMem);
01446     }
01447 
01448     if(FieldBits::NoField != (InternalFormatFieldMask & whichField))
01449     {
01450         _sfInternalFormat.copyFromBin(pMem);
01451     }
01452 
01453     if(FieldBits::NoField != (ExternalFormatFieldMask & whichField))
01454     {
01455         _sfExternalFormat.copyFromBin(pMem);
01456     }
01457 
01458     if(FieldBits::NoField != (ScaleFieldMask & whichField))
01459     {
01460         _sfScale.copyFromBin(pMem);
01461     }
01462 
01463     if(FieldBits::NoField != (FrameFieldMask & whichField))
01464     {
01465         _sfFrame.copyFromBin(pMem);
01466     }
01467 
01468     if(FieldBits::NoField != (MinFilterFieldMask & whichField))
01469     {
01470         _sfMinFilter.copyFromBin(pMem);
01471     }
01472 
01473     if(FieldBits::NoField != (MagFilterFieldMask & whichField))
01474     {
01475         _sfMagFilter.copyFromBin(pMem);
01476     }
01477 
01478     if(FieldBits::NoField != (WrapSFieldMask & whichField))
01479     {
01480         _sfWrapS.copyFromBin(pMem);
01481     }
01482 
01483     if(FieldBits::NoField != (WrapTFieldMask & whichField))
01484     {
01485         _sfWrapT.copyFromBin(pMem);
01486     }
01487 
01488     if(FieldBits::NoField != (WrapRFieldMask & whichField))
01489     {
01490         _sfWrapR.copyFromBin(pMem);
01491     }
01492 
01493     if(FieldBits::NoField != (EnvModeFieldMask & whichField))
01494     {
01495         _sfEnvMode.copyFromBin(pMem);
01496     }
01497 
01498     if(FieldBits::NoField != (EnvColorFieldMask & whichField))
01499     {
01500         _sfEnvColor.copyFromBin(pMem);
01501     }
01502 
01503     if(FieldBits::NoField != (EnvCombineRGBFieldMask & whichField))
01504     {
01505         _sfEnvCombineRGB.copyFromBin(pMem);
01506     }
01507 
01508     if(FieldBits::NoField != (EnvCombineAlphaFieldMask & whichField))
01509     {
01510         _sfEnvCombineAlpha.copyFromBin(pMem);
01511     }
01512 
01513     if(FieldBits::NoField != (EnvScaleRGBFieldMask & whichField))
01514     {
01515         _sfEnvScaleRGB.copyFromBin(pMem);
01516     }
01517 
01518     if(FieldBits::NoField != (EnvScaleAlphaFieldMask & whichField))
01519     {
01520         _sfEnvScaleAlpha.copyFromBin(pMem);
01521     }
01522 
01523     if(FieldBits::NoField != (EnvSource0RGBFieldMask & whichField))
01524     {
01525         _sfEnvSource0RGB.copyFromBin(pMem);
01526     }
01527 
01528     if(FieldBits::NoField != (EnvSource1RGBFieldMask & whichField))
01529     {
01530         _sfEnvSource1RGB.copyFromBin(pMem);
01531     }
01532 
01533     if(FieldBits::NoField != (EnvSource2RGBFieldMask & whichField))
01534     {
01535         _sfEnvSource2RGB.copyFromBin(pMem);
01536     }
01537 
01538     if(FieldBits::NoField != (EnvSource0AlphaFieldMask & whichField))
01539     {
01540         _sfEnvSource0Alpha.copyFromBin(pMem);
01541     }
01542 
01543     if(FieldBits::NoField != (EnvSource1AlphaFieldMask & whichField))
01544     {
01545         _sfEnvSource1Alpha.copyFromBin(pMem);
01546     }
01547 
01548     if(FieldBits::NoField != (EnvSource2AlphaFieldMask & whichField))
01549     {
01550         _sfEnvSource2Alpha.copyFromBin(pMem);
01551     }
01552 
01553     if(FieldBits::NoField != (EnvOperand0RGBFieldMask & whichField))
01554     {
01555         _sfEnvOperand0RGB.copyFromBin(pMem);
01556     }
01557 
01558     if(FieldBits::NoField != (EnvOperand1RGBFieldMask & whichField))
01559     {
01560         _sfEnvOperand1RGB.copyFromBin(pMem);
01561     }
01562 
01563     if(FieldBits::NoField != (EnvOperand2RGBFieldMask & whichField))
01564     {
01565         _sfEnvOperand2RGB.copyFromBin(pMem);
01566     }
01567 
01568     if(FieldBits::NoField != (EnvOperand0AlphaFieldMask & whichField))
01569     {
01570         _sfEnvOperand0Alpha.copyFromBin(pMem);
01571     }
01572 
01573     if(FieldBits::NoField != (EnvOperand1AlphaFieldMask & whichField))
01574     {
01575         _sfEnvOperand1Alpha.copyFromBin(pMem);
01576     }
01577 
01578     if(FieldBits::NoField != (EnvOperand2AlphaFieldMask & whichField))
01579     {
01580         _sfEnvOperand2Alpha.copyFromBin(pMem);
01581     }
01582 
01583     if(FieldBits::NoField != (GLIdFieldMask & whichField))
01584     {
01585         _sfGLId.copyFromBin(pMem);
01586     }
01587 
01588     if(FieldBits::NoField != (IgnoreGLForAspectFieldMask & whichField))
01589     {
01590         _sfIgnoreGLForAspect.copyFromBin(pMem);
01591     }
01592 
01593     if(FieldBits::NoField != (PointSpriteFieldMask & whichField))
01594     {
01595         _sfPointSprite.copyFromBin(pMem);
01596     }
01597 
01598     if(FieldBits::NoField != (PriorityFieldMask & whichField))
01599     {
01600         _sfPriority.copyFromBin(pMem);
01601     }
01602 
01603     if(FieldBits::NoField != (ShaderOperationFieldMask & whichField))
01604     {
01605         _sfShaderOperation.copyFromBin(pMem);
01606     }
01607 
01608     if(FieldBits::NoField != (ShaderInputFieldMask & whichField))
01609     {
01610         _sfShaderInput.copyFromBin(pMem);
01611     }
01612 
01613     if(FieldBits::NoField != (ShaderOffsetMatrixFieldMask & whichField))
01614     {
01615         _mfShaderOffsetMatrix.copyFromBin(pMem);
01616     }
01617 
01618     if(FieldBits::NoField != (ShaderOffsetScaleFieldMask & whichField))
01619     {
01620         _sfShaderOffsetScale.copyFromBin(pMem);
01621     }
01622 
01623     if(FieldBits::NoField != (ShaderOffsetBiasFieldMask & whichField))
01624     {
01625         _sfShaderOffsetBias.copyFromBin(pMem);
01626     }
01627 
01628     if(FieldBits::NoField != (ShaderRGBADotProductFieldMask & whichField))
01629     {
01630         _sfShaderRGBADotProduct.copyFromBin(pMem);
01631     }
01632 
01633     if(FieldBits::NoField != (ShaderCullModesFieldMask & whichField))
01634     {
01635         _sfShaderCullModes.copyFromBin(pMem);
01636     }
01637 
01638     if(FieldBits::NoField != (ShaderConstEyeFieldMask & whichField))
01639     {
01640         _sfShaderConstEye.copyFromBin(pMem);
01641     }
01642 
01643     if(FieldBits::NoField != (LodBiasFieldMask & whichField))
01644     {
01645         _sfLodBias.copyFromBin(pMem);
01646     }
01647 
01648     if(FieldBits::NoField != (TargetFieldMask & whichField))
01649     {
01650         _sfTarget.copyFromBin(pMem);
01651     }
01652 
01653     if(FieldBits::NoField != (DirtyLeftFieldMask & whichField))
01654     {
01655         _sfDirtyLeft.copyFromBin(pMem);
01656     }
01657 
01658     if(FieldBits::NoField != (DirtyMinXFieldMask & whichField))
01659     {
01660         _sfDirtyMinX.copyFromBin(pMem);
01661     }
01662 
01663     if(FieldBits::NoField != (DirtyMaxXFieldMask & whichField))
01664     {
01665         _sfDirtyMaxX.copyFromBin(pMem);
01666     }
01667 
01668     if(FieldBits::NoField != (DirtyMinYFieldMask & whichField))
01669     {
01670         _sfDirtyMinY.copyFromBin(pMem);
01671     }
01672 
01673     if(FieldBits::NoField != (DirtyMaxYFieldMask & whichField))
01674     {
01675         _sfDirtyMaxY.copyFromBin(pMem);
01676     }
01677 
01678     if(FieldBits::NoField != (DirtyMinZFieldMask & whichField))
01679     {
01680         _sfDirtyMinZ.copyFromBin(pMem);
01681     }
01682 
01683     if(FieldBits::NoField != (DirtyMaxZFieldMask & whichField))
01684     {
01685         _sfDirtyMaxZ.copyFromBin(pMem);
01686     }
01687 
01688     if(FieldBits::NoField != (AnisotropyFieldMask & whichField))
01689     {
01690         _sfAnisotropy.copyFromBin(pMem);
01691     }
01692 
01693     if(FieldBits::NoField != (BorderColorFieldMask & whichField))
01694     {
01695         _sfBorderColor.copyFromBin(pMem);
01696     }
01697 
01698     if(FieldBits::NoField != (BorderWidthFieldMask & whichField))
01699     {
01700         _sfBorderWidth.copyFromBin(pMem);
01701     }
01702 
01703     if(FieldBits::NoField != (NPOTMatrixScaleFieldMask & whichField))
01704     {
01705         _sfNPOTMatrixScale.copyFromBin(pMem);
01706     }
01707 
01708 
01709 }

TextureChunkPtr osg::TextureChunkBase::create ( void ) [inline, static, inherited]

Reimplemented from osg::Attachment.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 72 of file OSGTextureChunkBase.inl.

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

Referenced by osg::VRMLPixelTextureDesc::beginNode(), osg::VRMLImageTextureDesc::beginNode(), osg::DisplayCalibration::createCMViewports(), osg::ColorDisplayFilter::createFilter(), osg::DisplayFilterForeground::DisplayFilterGroup::DisplayFilterGroup(), osg::DVRSimpleLUTShader::initDependentTexture(), osg::SimpleStatisticsForeground::initText(), osg::BrickSet::makeTexture(), osg::SimpleTexturedMaterial::prepareLocalChunks(), and osg::FresnelMaterial::prepareLocalChunks().

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

TextureChunkPtr osg::TextureChunkBase::createEmpty ( void ) [inline, static, inherited]

Reimplemented from osg::Attachment.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 87 of file OSGTextureChunkBase.inl.

References osg::FieldContainer::newPtr().

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

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

Reimplemented from osg::Attachment.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 716 of file OSGTextureChunkBase.cpp.

References osg::FieldContainer::newPtr().

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

00717 { 
00718     TextureChunkPtr returnValue; 
00719 
00720     newPtr(returnValue, dynamic_cast<const TextureChunk *>(this)); 
00721 
00722     return returnValue; 
00723 }

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 osg::TextureChunkBase::executeSync	(	FieldContainer &	other,
		const BitVector &	whichField
	)			`[protected, virtual, inherited]`

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 732 of file OSGTextureChunkBase.cpp.

References osg::TextureChunkBase::executeSyncImpl().

00734 {
00735     this->executeSyncImpl((TextureChunkBase *) &other, whichField);
00736 }

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 changeFrom(), and osg::CubeTextureChunk::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::onCreate ( const FieldContainer * source = NULL ) [inline, protected, inherited]

Definition at line 318 of file OSGFieldContainerImpl.inl.

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

00319 {
00320 }

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::TextureChunkBase.

Reimplemented in osg::CubeTextureChunk, and osg::CubeTextureChunkBase.

Definition at line 234 of file OSGTextureChunk.h.

friend class TextureChunkBase [friend]

Definition at line 235 of file OSGTextureChunk.h.

Member Data Documentation

UInt32 TextureChunk::_extTex3D [static, protected]

Definition at line 197 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_arbMultiTex [static, protected]

Definition at line 198 of file OSGTextureChunk.h.

Referenced by hasMultiTexture(), and TextureChunk().

UInt32 TextureChunk::_nvPointSprite [static, protected]

Definition at line 199 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_nvTextureShader [static, protected]

Definition at line 200 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_nvTextureShader2 [static, protected]

Definition at line 201 of file OSGTextureChunk.h.

Referenced by handleTextureShader(), and TextureChunk().

UInt32 TextureChunk::_nvTextureShader3 [static, protected]

Definition at line 202 of file OSGTextureChunk.h.

Referenced by TextureChunk().

UInt32 TextureChunk::_sgisGenerateMipmap [static, protected]

Definition at line 203 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_extTextureLodBias [static, protected]

Definition at line 204 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_arbTextureCompression [static, protected]

Definition at line 205 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_arbTextureRectangle [static, protected]

Definition at line 206 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_arbTextureNonPowerOfTwo [static, protected]

Definition at line 207 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_extTextureFilterAnisotropic [static, protected]

Definition at line 208 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcTexImage3D = Window::invalidFunctionID [static, protected]

Definition at line 211 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcTexSubImage3D = Window::invalidFunctionID [static, protected]

Definition at line 212 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcActiveTexture = Window::invalidFunctionID [static, protected]

Definition at line 213 of file OSGTextureChunk.h.

Referenced by activeTexture(), and TextureChunk().

UInt32 TextureChunk::_arbCubeTex [static, protected]

Definition at line 214 of file OSGTextureChunk.h.

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

UInt32 TextureChunk::_funcCompressedTexImage1D = Window::invalidFunctionID [static, protected]

Definition at line 215 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage1D = Window::invalidFunctionID [static, protected]

Definition at line 216 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcCompressedTexImage2D = Window::invalidFunctionID [static, protected]

Definition at line 217 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage2D = Window::invalidFunctionID [static, protected]

Definition at line 218 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcCompressedTexImage3D = Window::invalidFunctionID [static, protected]

Definition at line 219 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

UInt32 TextureChunk::_funcCompressedTexSubImage3D = Window::invalidFunctionID [static, protected]

Definition at line 220 of file OSGTextureChunk.h.

Referenced by handleTexture(), and TextureChunk().

StateChunkClass TextureChunk::_class [static, protected]

Definition at line 224 of file OSGTextureChunk.h.

Referenced by getClass(), getStaticClass(), and osg::CubeTextureChunk::getStaticClass().

char TextureChunk::cvsid = "@(#)$Id: OSGTextureChunk.cpp,v 1.41 2002/06/17 12:27:14 jbehr Exp $" [static, private]

Reimplemented from osg::StateChunk.

Definition at line 237 of file OSGTextureChunk.h.

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 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 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 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 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), onCreate(), osg::CubeTextureChunk::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 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), and 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().

const osg::BitVector osg::TextureChunkBase::MTInfluenceMask [static, inherited]

Initial value:

 
    (Inherited::MTInfluenceMask) | 
    (static_cast<BitVector>(0x0) << Inherited::NextFieldId)

Reimplemented from osg::StateChunkBase.

Reimplemented in osg::CubeTextureChunkBase.

Definition at line 257 of file OSGTextureChunkBase.h.

ImagePtr osg::TextureChunkBase::_sfImage [protected, inherited]

The texture.

Definition at line 542 of file OSGTextureChunkBase.h.

Referenced by changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getImage(), osg::TextureChunkBase::getSFImage(), onDestroy(), osg::TextureChunkBase::setImage(), and 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 changed(), osg::TextureChunkBase::copyFromBin(), osg::TextureChunkBase::copyToBin(), osg::TextureChunkBase::executeSyncImpl(), osg::TextureChunkBase::getBinSize(), osg::TextureChunkBase::getIgnoreGLForAspect(), osg::TextureChunkBase::getSFIgnoreGLForAspect(), 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	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 }
typedef TextureChunkPtr	Ptr
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)
virtual bool	isTransparent (void) const
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
Texture specific

void	imageContentChanged (Int32 minx=-1, Int32 maxx=-1, Int32 miny=-1, Int32 maxy=-1, Int32 minz=-1, Int32 maxz=-1)
void	setImage (ImagePtr &pImage)
void	setShaderOffsetMatrix (Real32 m11, Real32 m12, Real32 m21, Real32 m22)
FieldContainer Get

virtual FieldContainerType &	getType (void)
virtual const FieldContainerType &	getType (void) const

osg::TextureChunk 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

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

osg::TextureChunk Class Reference
[OpenGL State Handling]