FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Work on supporting multitexturing in State/StateSet/StateAttribute/Geoemtry.

Browse Source
This commit is contained in:
Robert Osfield
2002-07-07 14:40:41 +00:00
parent 9787641512
commit 0801b363f5
18 changed files with 923 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/osg/Drawable
View File

@@ -268,9 +268,9 @@ class SG_EXPORT Drawable : public Object
virtual void setVertexArray(unsigned int count,Vec3* vertices) = 0;
virtual void drawArrays(GLenum mode,GLint first,GLsizei count) = 0;
virtual void drawElements(GLenum mode,GLsizei count,unsigned char* indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,unsigned short* indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,unsigned int* indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,GLubyte* indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,GLushort* indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,GLuint* indices) = 0;
virtual void begin(GLenum mode) = 0;
virtual void vertex(const Vec3& vert) = 0;
@@ -460,7 +460,7 @@ public:
}
}
virtual void drawElements(GLenum mode,GLsizei count,unsigned char* indices)
virtual void drawElements(GLenum mode,GLsizei count,GLubyte* indices)
{
if (indices==0 || count==0) return;
@@ -527,7 +527,7 @@ public:
}
}
virtual void drawElements(GLenum mode,GLsizei count,unsigned short* indices)
virtual void drawElements(GLenum mode,GLsizei count,GLushort* indices)
{
if (indices==0 || count==0) return;
@@ -596,7 +596,7 @@ public:
}
}
virtual void drawElements(GLenum mode,GLsizei count,unsigned int* indices)
virtual void drawElements(GLenum mode,GLsizei count,GLuint* indices)
{
if (indices==0 || count==0) return;

182
include/osg/Primitive
View File

@@ -17,9 +17,10 @@ class Primitive : public Object
{
PrimitiveType,
DrawArraysPrimitiveType,
UByteDrawElementsPrimitiveType,
UShortDrawElementsPrimitiveType,
UIntDrawElementsPrimitiveType
DrawArrayLengthsPrimitiveType,
DrawElementsUBytePrimitiveType,
DrawElementsUShortPrimitiveType,
DrawElementsUIntPrimitiveType
};
enum Mode
@@ -69,8 +70,9 @@ class SG_EXPORT DrawArrays : public Primitive
public:
DrawArrays(GLenum mode=0):
Primitive(DrawArraysPrimitiveType,mode)
{}
Primitive(DrawArraysPrimitiveType,mode),
_first(0),
_count(0) {}
DrawArrays(GLenum mode, GLint first, GLsizei count):
Primitive(DrawArraysPrimitiveType,mode),
@@ -112,36 +114,85 @@ class SG_EXPORT DrawArrays : public Primitive
GLsizei _count;
};
typedef std::vector<GLubyte> UByteVector;
class SG_EXPORT UByteDrawElements : public Primitive, public UByteVector
typedef std::vector<GLsizei> VectorSizei;
class SG_EXPORT DrawArrayLengths : public Primitive, public VectorSizei
{
public:
UByteDrawElements(GLenum mode=0):
Primitive(UByteDrawElementsPrimitiveType,mode) {}
DrawArrayLengths(GLenum mode=0):
Primitive(DrawArrayLengthsPrimitiveType,mode),
_first(0) {}
UByteDrawElements(const UByteDrawElements& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Primitive(array,copyop),
UByteVector(array) {}
DrawArrayLengths(const DrawArrayLengths& dal,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Primitive(dal,copyop),
VectorSizei(dal),
_first(dal._first) {}
UByteDrawElements(GLenum mode,unsigned int no,unsigned char* ptr) :
Primitive(UByteDrawElementsPrimitiveType,mode),
UByteVector(ptr,ptr+no) {}
DrawArrayLengths(GLenum mode, GLint first, unsigned int no, GLsizei* ptr) :
Primitive(DrawArrayLengthsPrimitiveType,mode),
VectorSizei(ptr,ptr+no),
_first(first) {}
UByteDrawElements(GLenum mode,unsigned int no) :
Primitive(UByteDrawElementsPrimitiveType,mode),
UByteVector(no) {}
DrawArrayLengths(GLenum mode,GLint first, unsigned int no) :
Primitive(DrawArrayLengthsPrimitiveType,mode),
VectorSizei(no),
_first(first) {}
template <class InputIterator>
UByteDrawElements(GLenum mode, InputIterator first,InputIterator last) :
Primitive(UByteDrawElementsPrimitiveType,mode),
UByteVector(first,last) {}
DrawArrayLengths(GLenum mode, GLint first, InputIterator firstItr,InputIterator lastItr) :
Primitive(DrawArrayLengthsPrimitiveType,mode),
VectorSizei(firstItr,lastItr),
_first(first) {}
virtual Object* cloneType() const { return osgNew UByteDrawElements(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew UByteDrawElements(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const UByteDrawElements*>(obj)!=NULL; }
virtual Object* cloneType() const { return osgNew DrawArrayLengths(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew DrawArrayLengths(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const DrawArrayLengths*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "UByteDrawElements"; }
virtual const char* className() const { return "DrawArrayLengths"; }
void setFirst(GLint first) { _first = first; }
GLint getFirst() const { return _first; }
virtual void draw() const;
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
protected:
GLint _first;
};
typedef std::vector<GLubyte> VectorUByte;
class SG_EXPORT DrawElementsUByte : public Primitive, public VectorUByte
{
public:
DrawElementsUByte(GLenum mode=0):
Primitive(DrawElementsUBytePrimitiveType,mode) {}
DrawElementsUByte(const DrawElementsUByte& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Primitive(array,copyop),
VectorUByte(array) {}
DrawElementsUByte(GLenum mode,unsigned int no,unsigned char* ptr) :
Primitive(DrawElementsUBytePrimitiveType,mode),
VectorUByte(ptr,ptr+no) {}
DrawElementsUByte(GLenum mode,unsigned int no) :
Primitive(DrawElementsUBytePrimitiveType,mode),
VectorUByte(no) {}
template <class InputIterator>
DrawElementsUByte(GLenum mode, InputIterator first,InputIterator last) :
Primitive(DrawElementsUBytePrimitiveType,mode),
VectorUByte(first,last) {}
virtual Object* cloneType() const { return osgNew DrawElementsUByte(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew DrawElementsUByte(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const DrawElementsUByte*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawElementsUByte"; }
virtual void draw() const ;
@@ -149,72 +200,72 @@ class SG_EXPORT UByteDrawElements : public Primitive, public UByteVector
};
typedef std::vector<GLushort> UShortVector;
class SG_EXPORT UShortDrawElements : public Primitive, public UShortVector
typedef std::vector<GLushort> VectorUShort;
class SG_EXPORT DrawElementsUShort : public Primitive, public VectorUShort
{
public:
UShortDrawElements(GLenum mode=0):
Primitive(UShortDrawElementsPrimitiveType,mode) {}
DrawElementsUShort(GLenum mode=0):
Primitive(DrawElementsUShortPrimitiveType,mode) {}
UShortDrawElements(const UShortDrawElements& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
DrawElementsUShort(const DrawElementsUShort& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Primitive(array,copyop),
UShortVector(array) {}
VectorUShort(array) {}
UShortDrawElements(GLenum mode,unsigned int no,unsigned short* ptr) :
Primitive(UShortDrawElementsPrimitiveType,mode),
UShortVector(ptr,ptr+no) {}
DrawElementsUShort(GLenum mode,unsigned int no,unsigned short* ptr) :
Primitive(DrawElementsUShortPrimitiveType,mode),
VectorUShort(ptr,ptr+no) {}
UShortDrawElements(GLenum mode,unsigned int no) :
Primitive(UShortDrawElementsPrimitiveType,mode),
UShortVector(no) {}
DrawElementsUShort(GLenum mode,unsigned int no) :
Primitive(DrawElementsUShortPrimitiveType,mode),
VectorUShort(no) {}
template <class InputIterator>
UShortDrawElements(GLenum mode, InputIterator first,InputIterator last) :
Primitive(UShortDrawElementsPrimitiveType,mode),
UShortVector(first,last) {}
DrawElementsUShort(GLenum mode, InputIterator first,InputIterator last) :
Primitive(DrawElementsUShortPrimitiveType,mode),
VectorUShort(first,last) {}
virtual Object* cloneType() const { return osgNew UShortDrawElements(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew UShortDrawElements(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const UShortDrawElements*>(obj)!=NULL; }
virtual Object* cloneType() const { return osgNew DrawElementsUShort(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew DrawElementsUShort(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const DrawElementsUShort*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "UShortDrawElements"; }
virtual const char* className() const { return "DrawElementsUShort"; }
virtual void draw() const;
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
};
typedef std::vector<GLuint> UIntVector;
class SG_EXPORT UIntDrawElements : public Primitive, public UIntVector
typedef std::vector<GLuint> VectorUInt;
class SG_EXPORT DrawElementsUInt : public Primitive, public VectorUInt
{
public:
UIntDrawElements(GLenum mode=0):
Primitive(UIntDrawElementsPrimitiveType,mode) {}
DrawElementsUInt(GLenum mode=0):
Primitive(DrawElementsUIntPrimitiveType,mode) {}
UIntDrawElements(const UIntDrawElements& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
DrawElementsUInt(const DrawElementsUInt& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Primitive(array,copyop),
UIntVector(array) {}
VectorUInt(array) {}
UIntDrawElements(GLenum mode,unsigned int no,unsigned int* ptr) :
Primitive(UIntDrawElementsPrimitiveType,mode),
UIntVector(ptr,ptr+no) {}
DrawElementsUInt(GLenum mode,unsigned int no,unsigned int* ptr) :
Primitive(DrawElementsUIntPrimitiveType,mode),
VectorUInt(ptr,ptr+no) {}
UIntDrawElements(GLenum mode,unsigned int no) :
Primitive(UIntDrawElementsPrimitiveType,mode),
UIntVector(no) {}
DrawElementsUInt(GLenum mode,unsigned int no) :
Primitive(DrawElementsUIntPrimitiveType,mode),
VectorUInt(no) {}
template <class InputIterator>
UIntDrawElements(GLenum mode, InputIterator first,InputIterator last) :
Primitive(UIntDrawElementsPrimitiveType,mode),
UIntVector(first,last) {}
DrawElementsUInt(GLenum mode, InputIterator first,InputIterator last) :
Primitive(DrawElementsUIntPrimitiveType,mode),
VectorUInt(first,last) {}
virtual Object* cloneType() const { return osgNew UIntDrawElements(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew UIntDrawElements(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const UIntDrawElements*>(obj)!=NULL; }
virtual Object* cloneType() const { return osgNew DrawElementsUInt(); }
virtual Object* clone(const CopyOp& copyop) const { return osgNew DrawElementsUInt(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const DrawElementsUInt*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "UIntDrawElements"; }
virtual const char* className() const { return "DrawElementsUInt"; }
virtual void draw() const;
@@ -222,6 +273,11 @@ class SG_EXPORT UIntDrawElements : public Primitive, public UIntVector
};
// backwards compatibility with first incarnation of DrawElements nameing convention.
typedef DrawElementsUByte UByteDrawElements;
typedef DrawElementsUShort UShortDrawElements;
typedef DrawElementsUInt UIntDrawElements;
}
#endif

266
include/osg/State
View File

@@ -118,6 +118,15 @@ class SG_EXPORT State : public Referenced
return applyMode(mode,enabled,ms);
}
inline const bool applyTextureMode(unsigned int unit, const StateAttribute::GLMode mode,const bool enabled)
{
if (unit>=_textureModeMapList.size()) _textureModeMapList.resize(unit);
ModeMap& modeMap = _textureModeMapList[unit];
ModeStack& ms = modeMap[mode];
ms.changed = true;
return applyMode(mode,enabled,ms);
}
/** Apply an attribute if required. */
inline const bool applyAttribute(const StateAttribute* attribute)
@@ -127,6 +136,15 @@ class SG_EXPORT State : public Referenced
return applyAttribute(attribute,as);
}
inline const bool applyTextureAttribute(unsigned int unit, const StateAttribute* attribute)
{
if (unit>=_textureAttributeMapList.size()) _textureAttributeMapList.resize(unit);
AttributeMap& attributeMap = _textureAttributeMapList[unit];
AttributeStack& as = attributeMap[attribute->getType()];
as.changed = true;
return applyAttribute(attribute,as);
}
/** Mode has been set externally, update state to reflect this setting.*/
void haveAppliedMode(const StateAttribute::GLMode mode,const StateAttribute::GLModeValue value);
@@ -152,6 +170,219 @@ class SG_EXPORT State : public Referenced
/** Get the current specified attribute, return NULL is one has not yet been applied.*/
const StateAttribute* getLastAppliedAttribute(const StateAttribute::Type type) const;
/** texture Mode has been set externally, update state to reflect this setting.*/
void haveAppliedTextureMode(unsigned int unit, const StateAttribute::GLMode mode,const StateAttribute::GLModeValue value);
/** texture Mode has been set externally, therefore dirty the associated mode in osg::State
* so it is applied on next call to osg::State::apply(..)*/
void haveAppliedTextureMode(unsigned int unit, const StateAttribute::GLMode mode);
/** texture Attribute has been applied externally, update state to reflect this setting.*/
void haveAppliedTextureAttribute(unsigned int unit, const StateAttribute* attribute);
/** texture Attribute has been applied externally,
* and therefore this attribute type has been dirtied
* and will need to be re-appplied on next osg::State.apply(..).
* note, if you have an osg::StateAttribute which you have applied externally
* then use the have_applied(attribute) method as this will the osg::State to
* track the current state more accuratly and enable lazy state updating such
* that only changed state will be applied.*/
void haveAppliedTextureAttribute(unsigned int unit, const StateAttribute::Type type);
/** Get whether the current specified texture mode is enabled (true) or disabled (false).*/
const bool getLastAppliedTextureMode(unsigned int unit, const StateAttribute::GLMode mode) const;
/** Get the current specified texture attribute, return NULL is one has not yet been applied.*/
const StateAttribute* getLastAppliedTextureAttribute(unsigned int unit, const StateAttribute::Type type) const;
/** wrapper around glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(..);
* note, only updates values that change.*/
inline void setVertexPointer( GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr )
{
if (!_vertexArray._enabled)
{
_vertexArray._enabled = true;
glEnableClientState(GL_VERTEX_ARRAY);
}
if (_vertexArray._pointer!=ptr)
{
_vertexArray._pointer=ptr;
glVertexPointer( size, type, stride, ptr );
}
}
/** wrapper glDisableClientState(GL_VERTEX_ARRAY).
* note, only updates values that change.*/
inline void disableVertexPointer()
{
if (_vertexArray._enabled)
{
_vertexArray._enabled = false;
glDisableClientState(GL_VERTEX_ARRAY);
}
}
/** wrapper around glEnableClientState(GL_NORMAL_ARRAY);glNormalPointer(..);
* note, only updates values that change.*/
inline void setNormalPointer( GLenum type, GLsizei stride,
const GLvoid *ptr )
{
if (!_normalArray._enabled)
{
_normalArray._enabled = true;
glEnableClientState(GL_NORMAL_ARRAY);
}
if (_normalArray._pointer!=ptr)
{
_normalArray._pointer=ptr;
glNormalPointer( type, stride, ptr );
}
}
/** wrapper around glDisableClientState(GL_NORMAL_ARRAY);
* note, only updates values that change.*/
inline void disableNormalPointer()
{
if (_normalArray._enabled)
{
_normalArray._enabled = false;
glDisableClientState(GL_NORMAL_ARRAY);
}
}
/** wrapper around glEnableClientState(GL_COLOR_ARRAY);glColorPointer(..);
* note, only updates values that change.*/
inline void setColorPointer( GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr )
{
if (!_colorArray._enabled)
{
_colorArray._enabled = true;
glEnableClientState(GL_COLOR_ARRAY);
}
if (_colorArray._pointer!=ptr)
{
_colorArray._pointer=ptr;
glColorPointer( size, type, stride, ptr );
}
}
/** wrapper around glDisableClientState(GL_COLOR_ARRAY);
* note, only updates values that change.*/
inline void disableColorPointer()
{
if (_colorArray._enabled)
{
_colorArray._enabled = false;
glDisableClientState(GL_COLOR_ARRAY);
}
}
/** wrapper around glEnableClientState(GL_INDEX_ARRAY);glIndexPointer(..);
* note, only updates values that change.*/
inline void setIndexPointer( GLenum type, GLsizei stride,
const GLvoid *ptr )
{
if (!_indexArray._enabled)
{
_indexArray._enabled = true;
glEnableClientState(GL_INDEX_ARRAY);
}
if (_indexArray._pointer!=ptr)
{
_indexArray._pointer=ptr;
glIndexPointer( type, stride, ptr );
}
}
/** wrapper around glDisableClientState(GL_INDEX_ARRAY);
* note, only updates values that change.*/
inline void disableIndexPointer()
{
//if (_indexArray._enabled)
{
_indexArray._enabled = false;
glDisableClientState(GL_INDEX_ARRAY);
}
}
/** wrapper around glEnableClientState(GL_TEXTURE_COORD_ARRAY);glTexCoordPointer(..);
* note, only updates values that change.*/
inline void setTexCoordPointer( unsigned int unit,
GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr )
{
if (setClientActiveTextureUnit(unit))
{
if ( unit >= _texCoordArrayList.size()) _texCoordArrayList.resize(unit+1);
EnabledArrayPair& eap = _texCoordArrayList[unit];
//if (!eap._enabled)
{
eap._enabled = true;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (eap._pointer!=ptr)
{
glTexCoordPointer( size, type, stride, ptr );
eap._pointer = ptr;
}
}
}
/** wrapper around glDisableClientState(GL_TEXTURE_COORD_ARRAY);
* note, only updates values that change.*/
inline void disableTexCoordPointer( unsigned int unit )
{
if (setClientActiveTextureUnit(unit))
{
if ( unit > _texCoordArrayList.size()) _texCoordArrayList.resize(unit+1);
EnabledArrayPair& eap = _texCoordArrayList[unit];
if (eap._enabled)
{
eap._enabled = false;
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
}
}
/** set the current tex coord array texture unit, return true if selected, false if selection failed such as when multitexturing is not supported.
* note, only updates values that change.*/
inline bool setClientActiveTextureUnit( unsigned int unit )
{
return unit==0;
// will need to check for extensions etc.
// if (unit!=_currentClientActiveTextureUnit)
// {
// glClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
// _currentClientActiveTextureUnit = unit;
// }
// return true;
}
/** set the current texture unit, return true if selected, false if selection failed such as when multitexturing is not supported.
* note, only updates values that change.*/
inline bool setActiveTextureUnit( unsigned int unit )
{
return unit==0;
//
// if (unit!=_currentActiveTextureUnit)
// {
// glActiveTextureARB(GL_TEXTURE0_ARB+unit);
// _currentActiveTextureUnit = unit;
// }
// return true;
}
/** Set the current OpenGL context uniqueID.
@@ -275,13 +506,42 @@ class SG_EXPORT State : public Referenced
}
typedef std::map<StateAttribute::GLMode,ModeStack> ModeMap;
typedef std::vector<ModeMap> TextureModeMapList;
typedef std::map<StateAttribute::Type,AttributeStack> AttributeMap;
typedef std::vector<AttributeMap> TextureAttributeMapList;
typedef std::vector<ref_ptr<const StateSet> > StateSetStack;
typedef std::vector<ref_ptr<const Matrix> > MatrixStack;
ModeMap _modeMap;
AttributeMap _attributeMap;
StateSetStack _drawStateStack;
ModeMap _modeMap;
AttributeMap _attributeMap;
TextureModeMapList _textureModeMapList;
TextureAttributeMapList _textureAttributeMapList;
StateSetStack _drawStateStack;
struct EnabledArrayPair
{
EnabledArrayPair():_enabled(false),_pointer(0) {}
EnabledArrayPair(const EnabledArrayPair& eap):_enabled(eap._enabled),_pointer(eap._pointer) {}
EnabledArrayPair& operator = (const EnabledArrayPair& eap) { _enabled=eap._enabled; _pointer=eap._pointer; return *this; }
bool _enabled;
const GLvoid* _pointer;
};
typedef std::vector<EnabledArrayPair> EnabledTexCoordArrayList;
EnabledArrayPair _vertexArray;
EnabledArrayPair _colorArray;
EnabledArrayPair _indexArray;
EnabledArrayPair _normalArray;
EnabledTexCoordArrayList _texCoordArrayList;
unsigned int _currentActiveTextureUnit;
unsigned int _currentClientActiveTextureUnit;
};

4
include/osg/StateAttribute
View File

@@ -101,10 +101,6 @@ class SG_EXPORT StateAttribute : public Object
enum Types
{
TEXTURE,
TEXTURE_0 =TEXTURE,
TEXTURE_1,
TEXTURE_2,
TEXTURE_3,
POLYGONMODE,
POLYGONOFFSET,

83
include/osg/StateSet
View File

@@ -75,6 +75,7 @@ class SG_EXPORT StateSet : public Object
inline const ModeList& getModeList() const { return _modeList; }
/** simple pairing between an attribute and its override flag.*/
typedef std::pair<ref_ptr<StateAttribute>,StateAttribute::OverrideValue> RefAttributePair;
/** a container to map StateAttribyte::Types to their respective RefAttributePair.*/
@@ -106,6 +107,58 @@ class SG_EXPORT StateSet : public Object
/** return the const list of all StateAttributes contained in this const StateSet.*/
inline const AttributeList& getAttributeList() const { return _attributeList; }
typedef std::vector<ModeList> TextureModeList;
/** set this StateSet to contain specified GLMode and value.*/
void setTextureMode(unsigned int unit,const StateAttribute::GLMode mode, const StateAttribute::GLModeValue value);
/** set this StateSet to inherit specified GLMode type from parents.
* has the effect of deleting any GlMode of specified type from StateSet.*/
void setTextureModeToInherit(unsigned int unit,const StateAttribute::GLMode mode);
/** get specified GLModeValue for specified GLMode.
* returns INHERIT if no GLModeValue is contained within StateSet.*/
const StateAttribute::GLModeValue getTextureMode(unsigned int unit,const StateAttribute::GLMode mode) const;
/** return the list of all Texture related GLModes contained in this StateSet.*/
inline TextureModeList& getTextureModeList() { return _textureModeList; }
/** return the const list of all Texture related GLModes contained in this const StateSet.*/
inline const TextureModeList& getTextureModeList() const { return _textureModeList; }
typedef std::vector<AttributeList> TextureAttributeList;
/** set this StateSet to contain specified attribute and override flag.*/
void setTextureAttribute(unsigned int unit,StateAttribute *attribute, const StateAttribute::OverrideValue value=StateAttribute::OFF);
/** set this StateSet to contain specified attribute and set the associated GLMode's to specified value.*/
void setTextureAttributeAndModes(unsigned int unit,StateAttribute *attribute, const StateAttribute::GLModeValue value=StateAttribute::ON);
/** set this StateSet to inherit specified attribute type from parents.
* has the effect of deleting any state attributes of specified type from StateSet.*/
void setTextureAttributeToInherit(unsigned int unit,const StateAttribute::Type type);
/** get specified Texture related StateAttribute for specified type.
* returns NULL if no type is contained within StateSet.*/
StateAttribute* getTextureAttribute(unsigned int unit,const StateAttribute::Type type);
/** get specified Texture related const StateAttribute for specified type.
* returns NULL if no type is contained within const StateSet.*/
const StateAttribute* getTextureAttribute(unsigned int unit,const StateAttribute::Type type) const;
/** get specified Texture related RefAttributePair for specified type.
* returns NULL if no type is contained within StateSet.*/
const RefAttributePair* getTextureAttributePair(unsigned int unit,const StateAttribute::Type type) const;
/** return the list of all Texture related StateAttributes contained in this StateSet.*/
inline TextureAttributeList& getTextureAttributeList() { return _textureAttributeList; }
/** return the const list of all Texture related StateAttributes contained in this const StateSet.*/
inline const TextureAttributeList& getTextureAttributeList() const { return _textureAttributeList; }
enum RenderingHint
{
DEFAULT_BIN = 0,
@@ -159,16 +212,30 @@ class SG_EXPORT StateSet : public Object
virtual ~StateSet();
StateSet& operator = (const StateSet&) { return *this; }
ModeList _modeList;
AttributeList _attributeList;
int _renderingHint;
ModeList _modeList;
AttributeList _attributeList;
RenderBinMode _binMode;
int _binNum;
std::string _binName;
TextureModeList _textureModeList;
TextureAttributeList _textureAttributeList;
inline ModeList& getOrCreateTextureModeList(unsigned int unit)
{
if (unit>=_textureModeList.size()) _textureModeList.resize(unit+1);
return _textureModeList[unit];
}
inline AttributeList& getOrCreateTextureAttributeList(unsigned int unit)
{
if (unit>=_textureAttributeList.size()) _textureAttributeList.resize(unit+1);
return _textureAttributeList[unit];
}
int _renderingHint;
RenderBinMode _binMode;
int _binNum;
std::string _binName;
};

16
include/osg/Texture
View File

@@ -84,7 +84,6 @@ class SG_EXPORT Texture : public StateAttribute
_modifiedTag(),
_image(copyop(text._image.get())),
_target(text._target),
_textureUnit(text._textureUnit),
_wrap_s(text._wrap_s),
_wrap_t(text._wrap_t),
_wrap_r(text._wrap_r),
@@ -102,7 +101,7 @@ class SG_EXPORT Texture : public StateAttribute
_subloadWidth(text._subloadWidth),
_subloadHeight(text._subloadHeight) {}
META_StateAttribute(osg, Texture,(Type)(TEXTURE_0+_textureUnit));
META_StateAttribute(osg, Texture,TEXTURE);
/** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/
virtual int compare(const StateAttribute& rhs) const;
@@ -136,17 +135,6 @@ class SG_EXPORT Texture : public StateAttribute
*/
void copyTexSubImage2D(State& state, int xoffset, int yoffset, int x, int y, int width, int height );
/** Set the texture unit.
* Valid values are 0,1,2,3.
* Default value of texture unit is 0.
* note, multi-texturing not fully implemented yet... April 2001.
*/
inline void setTextureUnit(const unsigned int textureUnit) { _textureUnit = textureUnit; }
/** get the texture unit.*/
inline const unsigned int getTextureUnit() const { return _textureUnit; }
enum WrapParameter {
WRAP_S,
WRAP_T,
@@ -342,8 +330,6 @@ class SG_EXPORT Texture : public StateAttribute
GLenum _target; // defaults to GL_TEXTURE_2D
unsigned int _textureUnit;
WrapMode _wrap_s;
WrapMode _wrap_t;
WrapMode _wrap_r;

2
include/osg/TextureCubeMap
View File

@@ -27,7 +27,7 @@ class SG_EXPORT TextureCubeMap : public Texture
TextureCubeMap(const TextureCubeMap& cm,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Texture(cm,copyop) {}
META_StateAttribute(osg, TextureCubeMap,(Type)(TEXTURE_0+_textureUnit));
META_StateAttribute(osg, TextureCubeMap,TEXTURE);
/** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/
virtual int compare(const StateAttribute& rhs) const;