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

31
src/osg/GeoSet.cpp
View File

@@ -1117,23 +1117,42 @@ Geometry* GeoSet::convertToGeometry()
return 0;
}
for( int i = 0; i < _numprims; i++ )
if( _cindex.valid() )
{
if( _cindex.valid() )
for( int i = 0; i < _numprims; i++ )
{
UShortDrawElements* n = new UShortDrawElements;
geom->addPrimitive(n);
if (_cindex._is_ushort)
geom->addPrimitive(osgNew UShortDrawElements( (GLenum)_oglprimtype, _primLengths[i],&_cindex._ptr._ushort[index] ));
else
geom->addPrimitive(osgNew UIntDrawElements( (GLenum)_oglprimtype, _primLengths[i], &_cindex._ptr._uint[index] ));
index += _primLengths[i];
}
}
else
{
if (_numprims==1)
{
DrawArrays* da = new DrawArrays(_oglprimtype,0,_primLengths[0]);
geom->addPrimitive(da);
}
else
geom->addPrimitive(osgNew DrawArrays( (GLenum)_oglprimtype, index, _primLengths[i] ));
{
DrawArrayLengths* dal = new DrawArrayLengths(_oglprimtype,0,_numprims);
geom->addPrimitive(dal);
for( int i = 0; i < _numprims; i++ )
{
(*dal)[i] = _primLengths[i];
index += _primLengths[i];
}
}
index += _primLengths[i];
}
}
else // POINTS, LINES, TRIANGLES, QUADS
{
@@ -1284,10 +1303,12 @@ Geometry* GeoSet::convertToGeometry()
index += _primLengths[i];
}
}
else
{
// POINTS, LINES, TRIANGLES, QUADS
Vec3Array* coords = osgNew Vec3Array;
Vec3Array* normals = 0;

44
src/osg/Geometry.cpp
View File

@@ -40,28 +40,30 @@ Array* Geometry::getTexCoordArray(unsigned int unit)
else return 0;
}
void Geometry::drawImmediateMode(State& /*state*/)
void Geometry::drawImmediateMode(State& state)
{
if (!_vertexArray.valid()) return;
// set up the vertex arrays.
glEnableClientState( GL_VERTEX_ARRAY );
glVertexPointer(3,GL_FLOAT,0,_vertexArray->dataPointer());
// glEnableClientState( GL_VERTEX_ARRAY );
// glVertexPointer(3,GL_FLOAT,0,_vertexArray->dataPointer());
state.setVertexPointer(3,GL_FLOAT,0,_vertexArray->dataPointer());
// set up texture coordinates.
for(unsigned int i=0;i<_texCoordList.size();++i)
{
Array* array = _texCoordList[i].get();
//glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
if (array)
{
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glTexCoordPointer(array->dataSize(),array->dataType(),0,array->dataPointer());
// glEnableClientState( GL_TEXTURE_COORD_ARRAY );
// glTexCoordPointer(array->dataSize(),array->dataType(),0,array->dataPointer());
state.setTexCoordPointer(i,array->dataSize(),array->dataType(),0,array->dataPointer());
}
else
{
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
// glDisableClientState( GL_TEXTURE_COORD_ARRAY );
state.disableTexCoordPointer(i);
}
}
@@ -73,18 +75,22 @@ void Geometry::drawImmediateMode(State& /*state*/)
switch (_normalBinding)
{
case(BIND_OFF):
glDisableClientState( GL_NORMAL_ARRAY );
// glDisableClientState( GL_NORMAL_ARRAY );
state.disableNormalPointer();
break;
case(BIND_OVERALL):
glDisableClientState( GL_NORMAL_ARRAY );
// glDisableClientState( GL_NORMAL_ARRAY );
state.disableNormalPointer();
if (normalPointer) glNormal3fv(reinterpret_cast<const GLfloat*>(normalPointer));
break;
case(BIND_PER_PRIMITIVE):
glDisableClientState( GL_NORMAL_ARRAY );
// glDisableClientState( GL_NORMAL_ARRAY );
state.disableNormalPointer();
break;
case(BIND_PER_VERTEX):
glEnableClientState( GL_NORMAL_ARRAY );
if (normalPointer) glNormalPointer(GL_FLOAT,0,normalPointer);
// glEnableClientState( GL_NORMAL_ARRAY );
// if (normalPointer) glNormalPointer(GL_FLOAT,0,normalPointer);
if (normalPointer) state.setNormalPointer(GL_FLOAT,0,normalPointer);
break;
}
@@ -124,10 +130,12 @@ void Geometry::drawImmediateMode(State& /*state*/)
switch (_colorBinding)
{
case(BIND_OFF):
glDisableClientState( GL_COLOR_ARRAY );
// glDisableClientState( GL_COLOR_ARRAY );
state.disableColorPointer();
break;
case(BIND_OVERALL):
glDisableClientState( GL_COLOR_ARRAY );
// glDisableClientState( GL_COLOR_ARRAY );
state.disableColorPointer();
if (colorPointer)
{
switch(colorType)
@@ -145,11 +153,13 @@ void Geometry::drawImmediateMode(State& /*state*/)
}
break;
case(BIND_PER_PRIMITIVE):
glDisableClientState( GL_COLOR_ARRAY );
// glDisableClientState( GL_COLOR_ARRAY );
state.disableColorPointer();
break;
case(BIND_PER_VERTEX):
glEnableClientState( GL_COLOR_ARRAY );
if (colorPointer) glColorPointer(_colorArray->dataSize(),_colorArray->dataType(),0,colorPointer);
// glEnableClientState( GL_COLOR_ARRAY );
// if (colorPointer) glColorPointer(_colorArray->dataSize(),_colorArray->dataType(),0,colorPointer);
if (colorPointer) state.setColorPointer(_colorArray->dataSize(),_colorArray->dataType(),0,colorPointer);
}

37
src/osg/Primitive.cpp
View File

@@ -12,36 +12,61 @@ void DrawArrays::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
functor.drawArrays(_mode,_first,_count);
}
void DrawArrayLengths::draw() const
{
GLint first = _first;
for(VectorSizei::const_iterator itr=begin();
itr!=end();
++itr)
{
glDrawArrays(_mode,first,*itr);
first += *itr;
}
}
void UByteDrawElements::draw() const
void DrawArrayLengths::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
{
GLint first = _first;
for(VectorSizei::iterator itr=begin();
itr!=end();
++itr)
{
functor.drawArrays(_mode,first,*itr);
first += *itr;
}
}
void DrawElementsUByte::draw() const
{
glDrawElements(_mode,size(),GL_UNSIGNED_BYTE,&front());
}
void UByteDrawElements::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
void DrawElementsUByte::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
{
if (!empty()) functor.drawElements(_mode,size(),&front());
}
void UShortDrawElements::draw() const
void DrawElementsUShort::draw() const
{
glDrawElements(_mode,size(),GL_UNSIGNED_SHORT,&front());
}
void UShortDrawElements::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
void DrawElementsUShort::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
{
if (!empty()) functor.drawElements(_mode,size(),&front());
}
void UIntDrawElements::draw() const
void DrawElementsUInt::draw() const
{
glDrawElements(_mode,size(),GL_UNSIGNED_INT,&front());
}
void UIntDrawElements::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
void DrawElementsUInt::applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor)
{
if (!empty()) functor.drawElements(_mode,size(),&front());
}

304
src/osg/StateSet.cpp
View File

@@ -37,6 +37,30 @@ StateSet::StateSet(const StateSet& rhs,const CopyOp& copyop):Object(rhs,copyop)
if (attr) _attributeList[type]=RefAttributePair(attr,rap.second);
}
// copy texture related modes.
_textureModeList = rhs._textureModeList;
// set up the size of the texture attribute list.
_textureAttributeList.resize(rhs._textureAttributeList.size());
// copy the contents across.
for(unsigned int i=0;i<rhs._textureAttributeList.size();++i)
{
AttributeList& lhs_attributeList = _textureAttributeList[i];
const AttributeList& rhs_attributeList = rhs._textureAttributeList[i];
for(AttributeList::const_iterator itr=rhs_attributeList.begin();
itr!=rhs_attributeList.end();
++itr)
{
StateAttribute::Type type = itr->first;
const RefAttributePair& rap = itr->second;
StateAttribute* attr = copyop(rap.first.get());
if (attr) lhs_attributeList[type]=RefAttributePair(attr,rap.second);
}
}
_renderingHint = rhs._renderingHint;
_binMode = rhs._binMode;
@@ -54,6 +78,61 @@ StateSet::~StateSet()
int StateSet::compare(const StateSet& rhs,bool compareAttributeContents) const
{
if (_textureAttributeList.size()<rhs._textureAttributeList.size()) return -1;
if (_textureAttributeList.size()>rhs._textureAttributeList.size()) return 1;
for(unsigned int ai=0;ai<_textureAttributeList.size();++ai)
{
const AttributeList& rhs_attributeList = _textureAttributeList[ai];
const AttributeList& lhs_attributeList = rhs._textureAttributeList[ai];
if (compareAttributeContents)
{
// now check to see how the attributes compare.
AttributeList::const_iterator lhs_attr_itr = lhs_attributeList.begin();
AttributeList::const_iterator rhs_attr_itr = rhs_attributeList.begin();
while (lhs_attr_itr!=lhs_attributeList.end() && rhs_attr_itr!=rhs_attributeList.end())
{
if (lhs_attr_itr->first<rhs_attr_itr->first) return -1;
else if (rhs_attr_itr->first<lhs_attr_itr->first) return 1;
if (*(lhs_attr_itr->second.first)<*(rhs_attr_itr->second.first)) return -1;
else if (*(rhs_attr_itr->second.first)<*(lhs_attr_itr->second.first)) return 1;
if (lhs_attr_itr->second.second<rhs_attr_itr->second.second) return -1;
else if (rhs_attr_itr->second.second<lhs_attr_itr->second.second) return 1;
++lhs_attr_itr;
++rhs_attr_itr;
}
if (lhs_attr_itr==lhs_attributeList.end())
{
if (rhs_attr_itr!=rhs_attributeList.end()) return -1;
}
else if (rhs_attr_itr == rhs_attributeList.end()) return 1;
}
else // just compare pointers.
{
// now check to see how the attributes compare.
AttributeList::const_iterator lhs_attr_itr = lhs_attributeList.begin();
AttributeList::const_iterator rhs_attr_itr = rhs_attributeList.begin();
while (lhs_attr_itr!=lhs_attributeList.end() && rhs_attr_itr!=rhs_attributeList.end())
{
if (lhs_attr_itr->first<rhs_attr_itr->first) return -1;
else if (rhs_attr_itr->first<lhs_attr_itr->first) return 1;
if (lhs_attr_itr->second.first<rhs_attr_itr->second.first) return -1;
else if (rhs_attr_itr->second.first<lhs_attr_itr->second.first) return 1;
if (lhs_attr_itr->second.second<rhs_attr_itr->second.second) return -1;
else if (rhs_attr_itr->second.second<lhs_attr_itr->second.second) return 1;
++lhs_attr_itr;
++rhs_attr_itr;
}
if (lhs_attr_itr==lhs_attributeList.end())
{
if (rhs_attr_itr!=rhs_attributeList.end()) return -1;
}
else if (rhs_attr_itr == rhs_attributeList.end()) return 1;
}
}
// now check the rest of the non texture attributes
if (compareAttributeContents)
{
// now check to see how the attributes compare.
@@ -101,8 +180,36 @@ int StateSet::compare(const StateSet& rhs,bool compareAttributeContents) const
// we've got here so attributes must be equal...
// check to see how the modes compare.
if (_textureModeList.size()<rhs._textureModeList.size()) return -1;
if (_textureModeList.size()>rhs._textureModeList.size()) return 1;
// check to see how the modes compare.
// first check the rest of the texture modes
for(unsigned int ti=0;ti<_textureModeList.size();++ti)
{
const ModeList& lhs_modeList = _textureModeList[ti];
const ModeList& rhs_modeList = rhs._textureModeList[ti];
ModeList::const_iterator lhs_mode_itr = lhs_modeList.begin();
ModeList::const_iterator rhs_mode_itr = rhs_modeList.begin();
while (lhs_mode_itr!=lhs_modeList.end() && rhs_mode_itr!=rhs_modeList.end())
{
if (lhs_mode_itr->first<rhs_mode_itr->first) return -1;
else if (rhs_mode_itr->first<lhs_mode_itr->first) return 1;
if (lhs_mode_itr->second<rhs_mode_itr->second) return -1;
else if (rhs_mode_itr->second<lhs_mode_itr->second) return 1;
++lhs_mode_itr;
++rhs_mode_itr;
}
if (lhs_mode_itr==lhs_modeList.end())
{
if (rhs_mode_itr!=rhs_modeList.end()) return -1;
}
else if (rhs_mode_itr == rhs_modeList.end()) return 1;
}
// check non texture modes.
ModeList::const_iterator lhs_mode_itr = _modeList.begin();
ModeList::const_iterator rhs_mode_itr = rhs._modeList.begin();
while (lhs_mode_itr!=_modeList.end() && rhs_mode_itr!=rhs._modeList.end())
@@ -172,6 +279,10 @@ void StateSet::setAllToInherit()
_modeList.clear();
_attributeList.clear();
_textureModeList.clear();
_textureAttributeList.clear();
}
void StateSet::merge(const StateSet& rhs)
@@ -222,6 +333,66 @@ void StateSet::merge(const StateSet& rhs)
}
}
if (_textureModeList.size()<rhs._textureModeList.size()) _textureModeList.resize(rhs._textureModeList.size());
for(unsigned int mi=0;mi<rhs._textureModeList.size();++mi)
{
ModeList& lhs_modeList = _textureModeList[mi];
const ModeList& rhs_modeList = rhs._textureModeList[mi];
// merge the modes of rhs into this,
// this overrides rhs if OVERRIDE defined in this.
for(ModeList::const_iterator rhs_mitr = rhs_modeList.begin();
rhs_mitr != rhs_modeList.end();
++rhs_mitr)
{
ModeList::iterator lhs_mitr = lhs_modeList.find(rhs_mitr->first);
if (lhs_mitr!=lhs_modeList.end())
{
if (!(lhs_mitr->second & StateAttribute::OVERRIDE))
{
// override isn't on in rhs, so overrite it with incomming
// value.
lhs_mitr->second = rhs_mitr->second;
}
}
else
{
// entry doesn't exist so insert it.
lhs_modeList.insert(*rhs_mitr);
}
}
}
if (_textureAttributeList.size()<rhs._textureAttributeList.size()) _textureAttributeList.resize(rhs._textureAttributeList.size());
for(unsigned int ai=0;ai<rhs._textureAttributeList.size();++ai)
{
AttributeList& lhs_attributeList = _textureAttributeList[ai];
const AttributeList& rhs_attributeList = rhs._textureAttributeList[ai];
// merge the attributes of rhs into this,
// this overrides rhs if OVERRIDE defined in this.
for(AttributeList::const_iterator rhs_aitr = rhs_attributeList.begin();
rhs_aitr != rhs_attributeList.end();
++rhs_aitr)
{
AttributeList::iterator lhs_aitr = lhs_attributeList.find(rhs_aitr->first);
if (lhs_aitr!=lhs_attributeList.end())
{
if (!(lhs_aitr->second.second & StateAttribute::OVERRIDE))
{
// override isn't on in rhs, so overrite it with incomming
// value.
lhs_aitr->second = rhs_aitr->second;
}
}
else
{
// entry doesn't exist so insert it.
lhs_attributeList.insert(*rhs_aitr);
}
}
}
// need to merge rendering hints
// but will need to think how best to do this first
// RO, Nov. 2001.
@@ -316,6 +487,119 @@ const StateSet::RefAttributePair* StateSet::getAttributePair(const StateAttribut
return NULL;
}
void StateSet::setTextureMode(unsigned int unit,const StateAttribute::GLMode mode, const StateAttribute::GLModeValue value)
{
ModeList& modeList = getOrCreateTextureModeList(unit);
if ((value&StateAttribute::INHERIT)) setTextureModeToInherit(unit,mode);
else modeList[mode] = value;
}
void StateSet::setTextureModeToInherit(unsigned int unit,const StateAttribute::GLMode mode)
{
if (unit>=_textureModeList.size()) return;
ModeList& modeList = _textureModeList[unit];
ModeList::iterator itr = modeList.find(mode);
if (itr!=modeList.end())
{
modeList.erase(itr);
}
}
const StateAttribute::GLModeValue StateSet::getTextureMode(unsigned int unit,const StateAttribute::GLMode mode) const
{
if (unit>=_textureModeList.size()) return StateAttribute::INHERIT;
const ModeList& modeList = _textureModeList[unit];
ModeList::const_iterator itr = modeList.find(mode);
if (itr!=modeList.end())
{
return itr->second;
}
else
return StateAttribute::INHERIT;
}
void StateSet::setTextureAttribute(unsigned int unit,StateAttribute *attribute, const StateAttribute::OverrideValue value=StateAttribute::OFF)
{
if (attribute)
{
AttributeList& attributeList = getOrCreateTextureAttributeList(unit);
if ((value&StateAttribute::INHERIT)) setAttributeToInherit(attribute->getType());
else attributeList[attribute->getType()] = RefAttributePair(attribute,value&StateAttribute::OVERRIDE);
}
}
void StateSet::setTextureAttributeAndModes(unsigned int unit,StateAttribute *attribute, const StateAttribute::GLModeValue value=StateAttribute::ON)
{
if (attribute)
{
AttributeList& attributeList = getOrCreateTextureAttributeList(unit);
attributeList[attribute->getType()] = RefAttributePair(attribute,value&StateAttribute::OVERRIDE);
attribute->setStateSetModes(*this,value);
}
}
void StateSet::setTextureAttributeToInherit(unsigned int unit,const StateAttribute::Type type)
{
if (unit>=_textureAttributeList.size()) return;
AttributeList& attributeList = _textureAttributeList[unit];
AttributeList::iterator itr = attributeList.find(type);
if (itr!=attributeList.end())
{
itr->second.first->setStateSetModes(*this,StateAttribute::INHERIT);
attributeList.erase(itr);
}
}
StateAttribute* StateSet::getTextureAttribute(unsigned int unit,const StateAttribute::Type type)
{
if (unit>=_textureAttributeList.size()) return 0;
AttributeList& attributeList = _textureAttributeList[unit];
AttributeList::iterator itr = attributeList.find(type);
if (itr!=attributeList.end())
{
return itr->second.first.get();
}
else
return NULL;
}
const StateAttribute* StateSet::getTextureAttribute(unsigned int unit,const StateAttribute::Type type) const
{
if (unit>=_textureAttributeList.size()) return 0;
const AttributeList& attributeList = _textureAttributeList[unit];
AttributeList::const_iterator itr = attributeList.find(type);
if (itr!=attributeList.end())
{
return itr->second.first.get();
}
else
return NULL;
}
const StateSet::RefAttributePair* StateSet::getTextureAttributePair(unsigned int unit,const StateAttribute::Type type) const
{
if (unit>=_textureAttributeList.size()) return 0;
const AttributeList& attributeList = _textureAttributeList[unit];
AttributeList::const_iterator itr = attributeList.find(type);
if (itr!=attributeList.end())
{
return &(itr->second);
}
else
return NULL;
}
void StateSet::compile(State& state) const
{
for(AttributeList::const_iterator itr = _attributeList.begin();
@@ -324,6 +608,18 @@ void StateSet::compile(State& state) const
{
itr->second.first->compile(state);
}
for(TextureAttributeList::const_iterator taitr=_textureAttributeList.begin();
taitr!=_textureAttributeList.end();
++taitr)
{
for(AttributeList::const_iterator itr = taitr->begin();
itr!=taitr->end();
++itr)
{
itr->second.first->compile(state);
}
}
}
void StateSet::setRenderingHint(const int hint)
@@ -352,3 +648,9 @@ void StateSet::setRendingBinToInherit()
_binNum = 0;
_binName = "";
}

9
src/osg/Texture.cpp
View File

@@ -25,8 +25,6 @@ Texture::Texture()
_target = GL_TEXTURE_2D;
_textureUnit = 0;
_wrap_s = CLAMP;
_wrap_t = CLAMP;
_wrap_r = CLAMP;
@@ -83,7 +81,6 @@ int Texture::compare(const StateAttribute& sa) const
}
// compare each paramter in turn against the rhs.
COMPARE_StateAttribute_Parameter(_textureUnit)
COMPARE_StateAttribute_Parameter(_wrap_s)
COMPARE_StateAttribute_Parameter(_wrap_t)
COMPARE_StateAttribute_Parameter(_wrap_r)
@@ -191,9 +188,6 @@ void Texture::apply(State& state) const
// get the globj for the current contextID.
GLuint& handle = getHandle(contextID);
// For multi-texturing will need something like...
//glActiveTextureARB((GLenum)(GL_TEXTURE0_ARB+_textureUnit));
if (handle != 0)
{
if (_subloadMode == OFF)
@@ -611,8 +605,6 @@ void Texture::copyTexImage2D(State& state, int x, int y, int width, int height )
// RO July 2001.
}
// For multi-texturing will need something like...
// glActiveTextureARB((GLenum)(GL_TEXTURE0_ARB+_textureUnit));
// remove any previously assigned images as these are nolonger valid.
_image = NULL;
@@ -650,6 +642,7 @@ void Texture::copyTexSubImage2D(State& state, int xoffset, int yoffset, int x, i
if (handle)
{
// we have a valid image
glBindTexture( _target, handle );
applyTexParameters(_target,state);

3
src/osg/TextureCubeMap.cpp
View File

@@ -181,9 +181,6 @@ void TextureCubeMap::apply(State& state) const
// get the globj for the current contextID.
GLuint& handle = getHandle(contextID);
// For multi-texturing will need something like...
// glActiveTextureARB((GLenum)(GL_TEXTURE0_ARB+_textureUnit));
if (handle != 0)
{
if (_subloadMode == OFF)