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

Work in progress on shader language uniform support

Browse Source
This commit is contained in:
Robert Osfield
2005-04-13 12:00:28 +00:00
parent 67ba3c94c9
commit 2e10cffb4d
6 changed files with 425 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
src/osg/Program.cpp
View File

@@ -2050,6 +2050,7 @@ void Program::apply( osg::State& state ) const
if( isFixedFunction() )
{
extensions->glUseProgram( 0 );
state.setLastAppliedProgramObject(0);
return;
}
@@ -2058,12 +2059,13 @@ void Program::apply( osg::State& state ) const
if( pcp->isLinked() )
{
pcp->useProgram();
pcp->applyUniforms( state );
state.setLastAppliedProgramObject(pcp);
}
else
{
// program not usable, fallback to fixed function.
extensions->glUseProgram( 0 );
state.setLastAppliedProgramObject(0);
}
}
@@ -2098,70 +2100,6 @@ void Program::getGlProgramInfoLog(unsigned int contextID, std::string& log) cons
getPCP( contextID )->getInfoLog( log );
}
///////////////////////////////////////////////////////////////////////////
// osg::Program::ActiveUniform
///////////////////////////////////////////////////////////////////////////
Program::ActiveUniform::ActiveUniform( const char* name, GLenum type, GLint loc ) :
Uniform(name, static_cast<Type>(type)), _location(loc)
{
}
void Program::ActiveUniform::applyData( const GL2Extensions* ext, GLuint /*prog*/ )
{
switch( repType(getType()) )
{
case FLOAT:
ext->glUniform1f( _location, _data.f1 );
break;
case FLOAT_VEC2:
ext->glUniform2fv( _location, 1, _data.f2 );
break;
case FLOAT_VEC3:
ext->glUniform3fv( _location, 1, _data.f3 );
break;
case FLOAT_VEC4:
ext->glUniform4fv( _location, 1, _data.f4 );
break;
case FLOAT_MAT2:
ext->glUniformMatrix2fv( _location, 1, GL_FALSE, _data.f4 );
break;
case FLOAT_MAT3:
ext->glUniformMatrix3fv( _location, 1, GL_FALSE, _data.f9 );
break;
case FLOAT_MAT4:
ext->glUniformMatrix4fv( _location, 1, GL_FALSE, _data.f16 );
break;
case INT:
ext->glUniform1i( _location, _data.i1 );
break;
case INT_VEC2:
ext->glUniform2iv( _location, 1, _data.i2 );
break;
case INT_VEC3:
ext->glUniform3iv( _location, 1, _data.i3 );
break;
case INT_VEC4:
ext->glUniform4iv( _location, 1, _data.i4 );
break;
default:
osg::notify(osg::FATAL) << "how got here?" << std::endl;
break;
}
}
///////////////////////////////////////////////////////////////////////////
// osg::Program::PerContextProgram
// PCP is an OSG abstraction of the per-context glProgram
@@ -2195,8 +2133,6 @@ void Program::PerContextProgram::linkProgram()
if( ! _needsLink ) return;
_needsLink = false;
_activeUniformList.clear();
// set any explicit vertex attribute bindings
const AttribBindingList& bindlist = _program->getAttribBindingList();
for( AttribBindingList::const_iterator itr = bindlist.begin();
@@ -2219,6 +2155,8 @@ void Program::PerContextProgram::linkProgram()
return;
}
notify(NOTICE)<<"Program "<<std::endl;
// build ActiveUniformList
GLint numUniforms = 0;
GLsizei maxLen = 0;
@@ -2235,14 +2173,43 @@ void Program::PerContextProgram::linkProgram()
_extensions->glGetActiveUniform( _glProgramHandle,
i, maxLen, 0, &size, &type, name );
GLint loc = getUniformLocation( name );
if( loc != -1 )
{
_activeUniformList.push_back( new ActiveUniform( name, type, loc ) );
notify(NOTICE)<<" Active uniform "<<name<<std::endl;
_uniformLocationMap[name] = loc;
}
}
delete [] name;
}
// build ActiveUniformList
GLint numAttrib = 0;
_extensions->glGetProgramiv( _glProgramHandle, GL_ACTIVE_ATTRIBUTES, &numAttrib );
_extensions->glGetProgramiv( _glProgramHandle, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLen );
if( (numAttrib > 0) && (maxLen > 1) )
{
GLint size = 0;
GLenum type = 0;
GLchar* name = new GLchar[maxLen];
for( GLint i = 0; i < numAttrib; ++i )
{
_extensions->glGetActiveAttrib( _glProgramHandle,
i, maxLen, 0, &size, &type, name );
GLint loc = getUniformLocation( name );
if( loc != -1 )
{
notify(NOTICE)<<" Active attribute "<<name<<std::endl;
_attribLocationMap[name] = loc;
}
}
delete [] name;
}
notify(NOTICE)<<"Program "<<std::endl;
}
void Program::PerContextProgram::getInfoLog( std::string& infoLog ) const
@@ -2255,37 +2222,5 @@ void Program::PerContextProgram::useProgram() const
_extensions->glUseProgram( _glProgramHandle );
}
GLint Program::PerContextProgram::getUniformLocation( const char* name ) const
{
return _extensions->glGetUniformLocation( _glProgramHandle, name );
}
GLint Program::PerContextProgram::getAttribLocation( const char* name ) const
{
return _extensions->glGetAttribLocation( _glProgramHandle, name );
}
void Program::PerContextProgram::applyUniforms( osg::State& state ) const
{
for( ActiveUniformList::const_iterator itr = _activeUniformList.begin();
itr != _activeUniformList.end(); ++itr )
{
ActiveUniform* au = const_cast<ActiveUniform*>( itr->get() );
// use name of active uniform to find a value uniform
const osg::Uniform* vu = state.findUniform( au->getName() );
if( ! vu ) continue;
// skip if types are not identical
if( au->getType() != vu->getType() ) continue;
// skip if values are already identical
if( au->compareData( *vu ) == 0 ) continue;
au->copyData( *vu );
au->applyData( _extensions.get(), _glProgramHandle );
}
}
/*EOF*/

43
src/osg/State.cpp
View File

@@ -28,7 +28,7 @@ State::State()
_modelView = _identity;
_abortRenderingPtr = false;
_reportGLErrors = false;
_reportGLErrors = true;
_currentActiveTextureUnit=0;
_currentClientActiveTextureUnit=0;
@@ -41,6 +41,8 @@ State::State()
_isVertexBufferObjectSupportResolved = false;
_isVertexBufferObjectSupported = false;
_lastAppliedProgramObject = 0;
}
State::~State()
@@ -103,13 +105,29 @@ void State::reset()
}
}
_drawStateStack.clear();
_stateStateStack.clear();
_modelView = _identity;
_projection = _identity;
dirtyAllVertexArrays();
setActiveTextureUnit(0);
_lastAppliedProgramObject = 0;
// what about uniforms??? need to clear them too...
// go through all active Unfirom's, setting to change to force update,
// the idea is to leave only the global defaults left.
for(UniformMap::iterator uitr=_uniformMap.begin();
uitr!=_uniformMap.end();
++uitr)
{
UniformStack& us = uitr->second;
us.uniformVec.clear();
us.last_applied_uniform = NULL;
us.changed = true;
}
}
void State::setInitialViewMatrix(const osg::RefMatrix* matrix)
@@ -122,7 +140,7 @@ void State::setInitialViewMatrix(const osg::RefMatrix* matrix)
void State::pushStateSet(const StateSet* dstate)
{
_drawStateStack.push_back(dstate);
_stateStateStack.push_back(dstate);
if (dstate)
{
@@ -150,7 +168,7 @@ void State::pushStateSet(const StateSet* dstate)
void State::popAllStateSets()
{
while (!_drawStateStack.empty()) popStateSet();
while (!_stateStateStack.empty()) popStateSet();
applyProjectionMatrix(0);
applyModelViewMatrix(0);
@@ -158,9 +176,9 @@ void State::popAllStateSets()
void State::popStateSet()
{
if (_drawStateStack.empty()) return;
if (_stateStateStack.empty()) return;
const StateSet* dstate = _drawStateStack.back();
const StateSet* dstate = _stateStateStack.back();
if (dstate)
{
@@ -186,7 +204,7 @@ void State::popStateSet()
}
// remove the top draw state from the stack.
_drawStateStack.pop_back();
_stateStateStack.pop_back();
}
void State::captureCurrentState(StateSet& stateset) const
@@ -261,6 +279,12 @@ void State::apply(const StateSet* dstate)
else if (unit<_textureAttributeMapList.size()) applyAttributeMap(_textureAttributeMapList[unit]);
}
}
if (_lastAppliedProgramObject)
{
osg::notify(osg::NOTICE)<<"Ready to apply uniforms A"<<std::endl;
}
}
else
@@ -295,6 +319,11 @@ void State::apply()
}
}
if (_lastAppliedProgramObject)
{
osg::notify(osg::NOTICE)<<"Ready to apply uniforms B"<<std::endl;
}
if (_reportGLErrors) checkGLErrors("end of State::apply()");
}

504
src/osg/Uniform.cpp
View File

@@ -10,8 +10,8 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
/* file: src/osg/Uniform.cpp
* author: Mike Weiblen 2005-04-07
/* file: src/osg/Uniform.cpp
* author: Mike Weiblen 2005-04-07
*/
// NOTICE: This code is CLOSED during construction and/or renovation!
@@ -32,45 +32,45 @@ using namespace osg;
///////////////////////////////////////////////////////////////////////////
Uniform::Uniform() :
_name(""), _type(UNDEFINED)
_name(""), _type(UNDEFINED)
{
}
Uniform::Uniform( const char* name, Type type ) :
_name(name), _type(type)
_name(name), _type(type)
{
switch( _type )
{
case FLOAT: set( 0.0f ); break;
case FLOAT_VEC2: set( osg::Vec2() ); break;
case FLOAT_VEC3: set( osg::Vec3() ); break;
case FLOAT_VEC4: set( osg::Vec4() ); break;
case INT: set( 0 ); break;
case INT_VEC2: set( 0, 0 ); break;
case INT_VEC3: set( 0, 0, 0 ); break;
case INT_VEC4: set( 0, 0, 0, 0 ); break;
case BOOL: set( false ); break;
case BOOL_VEC2: set( false, false ); break;
case BOOL_VEC3: set( false, false, false ); break;
case BOOL_VEC4: set( false, false, false, false ); break;
// TODO case FLOAT_MAT2:
// TODO case FLOAT_MAT3:
case FLOAT_MAT4: set( osg::Matrix() ); break;
case SAMPLER_1D: set( 0 ); break;
case SAMPLER_2D: set( 0 ); break;
case SAMPLER_3D: set( 0 ); break;
case SAMPLER_CUBE: set( 0 ); break;
case SAMPLER_1D_SHADOW: set( 0 ); break;
case SAMPLER_2D_SHADOW: set( 0 ); break;
default:
osg::notify(osg::WARN) << "UNDEFINED Uniform type" << std::endl;
break;
case FLOAT: set( 0.0f ); break;
case FLOAT_VEC2: set( osg::Vec2() ); break;
case FLOAT_VEC3: set( osg::Vec3() ); break;
case FLOAT_VEC4: set( osg::Vec4() ); break;
case INT: set( 0 ); break;
case INT_VEC2: set( 0, 0 ); break;
case INT_VEC3: set( 0, 0, 0 ); break;
case INT_VEC4: set( 0, 0, 0, 0 ); break;
case BOOL: set( false ); break;
case BOOL_VEC2: set( false, false ); break;
case BOOL_VEC3: set( false, false, false ); break;
case BOOL_VEC4: set( false, false, false, false ); break;
// TODO case FLOAT_MAT2:
// TODO case FLOAT_MAT3:
case FLOAT_MAT4: set( osg::Matrix() ); break;
case SAMPLER_1D: set( 0 ); break;
case SAMPLER_2D: set( 0 ); break;
case SAMPLER_3D: set( 0 ); break;
case SAMPLER_CUBE: set( 0 ); break;
case SAMPLER_1D_SHADOW: set( 0 ); break;
case SAMPLER_2D_SHADOW: set( 0 ); break;
default:
osg::notify(osg::WARN) << "UNDEFINED Uniform type" << std::endl;
break;
}
}
Uniform::Uniform( const Uniform& rhs, const CopyOp& copyop ) :
Object(rhs,copyop), _name(rhs._name), _type(rhs._type)
Object(rhs,copyop), _name(rhs._name), _type(rhs._type)
{
copyData( rhs );
}
@@ -79,8 +79,8 @@ bool Uniform::setType( Type t )
{
if( _type != UNDEFINED )
{
osg::notify(osg::WARN) << "cannot change Uniform type" << std::endl;
return false;
osg::notify(osg::WARN) << "cannot change Uniform type" << std::endl;
return false;
}
_type = t;
return true;
@@ -90,8 +90,8 @@ bool Uniform::setName( const std::string& name )
{
if( _name != "" )
{
osg::notify(osg::WARN) << "cannot change Uniform name" << std::endl;
return false;
osg::notify(osg::WARN) << "cannot change Uniform name" << std::endl;
return false;
}
_name = name;
return true;
@@ -119,80 +119,80 @@ int Uniform::compareData(const Uniform& rhs) const
switch( repType(getType()) )
{
case FLOAT:
if( _data.f1 < rhs._data.f1 ) return -1;
if( _data.f1 > rhs._data.f1 ) return 1;
return 0;
case FLOAT:
if( _data.f1 < rhs._data.f1 ) return -1;
if( _data.f1 > rhs._data.f1 ) return 1;
return 0;
case FLOAT_VEC2:
if( _data.f2[0] < rhs._data.f2[0] ) return -1;
if( _data.f2[0] > rhs._data.f2[0] ) return 1;
if( _data.f2[1] < rhs._data.f2[1] ) return -1;
if( _data.f2[1] > rhs._data.f2[1] ) return 1;
return 0;
case FLOAT_VEC2:
if( _data.f2[0] < rhs._data.f2[0] ) return -1;
if( _data.f2[0] > rhs._data.f2[0] ) return 1;
if( _data.f2[1] < rhs._data.f2[1] ) return -1;
if( _data.f2[1] > rhs._data.f2[1] ) return 1;
return 0;
case FLOAT_VEC3:
if( _data.f3[0] < rhs._data.f3[0] ) return -1;
if( _data.f3[0] > rhs._data.f3[0] ) return 1;
if( _data.f3[1] < rhs._data.f3[1] ) return -1;
if( _data.f3[1] > rhs._data.f3[1] ) return 1;
if( _data.f3[2] < rhs._data.f3[2] ) return -1;
if( _data.f3[2] > rhs._data.f3[2] ) return 1;
return 0;
case FLOAT_VEC3:
if( _data.f3[0] < rhs._data.f3[0] ) return -1;
if( _data.f3[0] > rhs._data.f3[0] ) return 1;
if( _data.f3[1] < rhs._data.f3[1] ) return -1;
if( _data.f3[1] > rhs._data.f3[1] ) return 1;
if( _data.f3[2] < rhs._data.f3[2] ) return -1;
if( _data.f3[2] > rhs._data.f3[2] ) return 1;
return 0;
case FLOAT_VEC4:
case FLOAT_MAT2:
if( _data.f4[0] < rhs._data.f4[0] ) return -1;
if( _data.f4[0] > rhs._data.f4[0] ) return 1;
if( _data.f4[1] < rhs._data.f4[1] ) return -1;
if( _data.f4[1] > rhs._data.f4[1] ) return 1;
if( _data.f4[2] < rhs._data.f4[2] ) return -1;
if( _data.f4[2] > rhs._data.f4[2] ) return 1;
if( _data.f4[3] < rhs._data.f4[3] ) return -1;
if( _data.f4[3] > rhs._data.f4[3] ) return 1;
return 0;
case FLOAT_VEC4:
case FLOAT_MAT2:
if( _data.f4[0] < rhs._data.f4[0] ) return -1;
if( _data.f4[0] > rhs._data.f4[0] ) return 1;
if( _data.f4[1] < rhs._data.f4[1] ) return -1;
if( _data.f4[1] > rhs._data.f4[1] ) return 1;
if( _data.f4[2] < rhs._data.f4[2] ) return -1;
if( _data.f4[2] > rhs._data.f4[2] ) return 1;
if( _data.f4[3] < rhs._data.f4[3] ) return -1;
if( _data.f4[3] > rhs._data.f4[3] ) return 1;
return 0;
case FLOAT_MAT3:
return memcmp(_data.f9, rhs._data.f9, sizeof(_data.f9));
case FLOAT_MAT3:
return memcmp(_data.f9, rhs._data.f9, sizeof(_data.f9));
case FLOAT_MAT4:
return memcmp(_data.f16, rhs._data.f16, sizeof(_data.f16));
case FLOAT_MAT4:
return memcmp(_data.f16, rhs._data.f16, sizeof(_data.f16));
case INT:
if( _data.i1 < rhs._data.i1 ) return -1;
if( _data.i1 > rhs._data.i1 ) return 1;
return 0;
case INT:
if( _data.i1 < rhs._data.i1 ) return -1;
if( _data.i1 > rhs._data.i1 ) return 1;
return 0;
case INT_VEC2:
if( _data.i2[0] < rhs._data.i2[0] ) return -1;
if( _data.i2[0] > rhs._data.i2[0] ) return 1;
if( _data.i2[1] < rhs._data.i2[1] ) return -1;
if( _data.i2[1] > rhs._data.i2[1] ) return 1;
return 0;
case INT_VEC2:
if( _data.i2[0] < rhs._data.i2[0] ) return -1;
if( _data.i2[0] > rhs._data.i2[0] ) return 1;
if( _data.i2[1] < rhs._data.i2[1] ) return -1;
if( _data.i2[1] > rhs._data.i2[1] ) return 1;
return 0;
case INT_VEC3:
if( _data.i3[0] < rhs._data.i3[0] ) return -1;
if( _data.i3[0] > rhs._data.i3[0] ) return 1;
if( _data.i3[1] < rhs._data.i3[1] ) return -1;
if( _data.i3[1] > rhs._data.i3[1] ) return 1;
if( _data.i3[2] < rhs._data.i3[2] ) return -1;
if( _data.i3[2] > rhs._data.i3[2] ) return 1;
return 0;
case INT_VEC3:
if( _data.i3[0] < rhs._data.i3[0] ) return -1;
if( _data.i3[0] > rhs._data.i3[0] ) return 1;
if( _data.i3[1] < rhs._data.i3[1] ) return -1;
if( _data.i3[1] > rhs._data.i3[1] ) return 1;
if( _data.i3[2] < rhs._data.i3[2] ) return -1;
if( _data.i3[2] > rhs._data.i3[2] ) return 1;
return 0;
case INT_VEC4:
if( _data.i4[0] < rhs._data.i4[0] ) return -1;
if( _data.i4[0] > rhs._data.i4[0] ) return 1;
if( _data.i4[1] < rhs._data.i4[1] ) return -1;
if( _data.i4[1] > rhs._data.i4[1] ) return 1;
if( _data.i4[2] < rhs._data.i4[2] ) return -1;
if( _data.i4[2] > rhs._data.i4[2] ) return 1;
if( _data.i4[3] < rhs._data.i4[3] ) return -1;
if( _data.i4[3] > rhs._data.i4[3] ) return 1;
return 0;
case INT_VEC4:
if( _data.i4[0] < rhs._data.i4[0] ) return -1;
if( _data.i4[0] > rhs._data.i4[0] ) return 1;
if( _data.i4[1] < rhs._data.i4[1] ) return -1;
if( _data.i4[1] > rhs._data.i4[1] ) return 1;
if( _data.i4[2] < rhs._data.i4[2] ) return -1;
if( _data.i4[2] > rhs._data.i4[2] ) return 1;
if( _data.i4[3] < rhs._data.i4[3] ) return -1;
if( _data.i4[3] > rhs._data.i4[3] ) return 1;
return 0;
default:
osg::notify(osg::WARN) << "cannot compare UNDEFINED Uniform type" << std::endl;
return 0;
default:
osg::notify(osg::WARN) << "cannot compare UNDEFINED Uniform type" << std::endl;
return 0;
}
}
@@ -203,62 +203,62 @@ void Uniform::copyData(const Uniform& rhs)
int i;
switch( repType(getType()) )
{
case FLOAT:
_data.f1 = rhs._data.f1;
break;
case FLOAT:
_data.f1 = rhs._data.f1;
break;
case FLOAT_VEC2:
_data.f2[0] = rhs._data.f2[0];
_data.f2[1] = rhs._data.f2[1];
break;
case FLOAT_VEC2:
_data.f2[0] = rhs._data.f2[0];
_data.f2[1] = rhs._data.f2[1];
break;
case FLOAT_VEC3:
_data.f3[0] = rhs._data.f3[0];
_data.f3[1] = rhs._data.f3[1];
_data.f3[2] = rhs._data.f3[2];
break;
case FLOAT_VEC3:
_data.f3[0] = rhs._data.f3[0];
_data.f3[1] = rhs._data.f3[1];
_data.f3[2] = rhs._data.f3[2];
break;
case FLOAT_VEC4:
case FLOAT_MAT2:
_data.f4[0] = rhs._data.f4[0];
_data.f4[1] = rhs._data.f4[1];
_data.f4[2] = rhs._data.f4[2];
_data.f4[3] = rhs._data.f4[3];
break;
case FLOAT_VEC4:
case FLOAT_MAT2:
_data.f4[0] = rhs._data.f4[0];
_data.f4[1] = rhs._data.f4[1];
_data.f4[2] = rhs._data.f4[2];
_data.f4[3] = rhs._data.f4[3];
break;
case FLOAT_MAT3:
for(i=0;i<9;++i) _data.f9[i]=rhs._data.f9[i];
break;
case FLOAT_MAT3:
for(i=0;i<9;++i) _data.f9[i]=rhs._data.f9[i];
break;
case FLOAT_MAT4:
for(i=0;i<16;++i) _data.f16[i]=rhs._data.f16[i];
break;
case FLOAT_MAT4:
for(i=0;i<16;++i) _data.f16[i]=rhs._data.f16[i];
break;
case INT:
_data.i1 = rhs._data.i1;
break;
case INT:
_data.i1 = rhs._data.i1;
break;
case INT_VEC2:
_data.i2[0] = rhs._data.i2[0];
_data.i2[1] = rhs._data.i2[1];
break;
case INT_VEC2:
_data.i2[0] = rhs._data.i2[0];
_data.i2[1] = rhs._data.i2[1];
break;
case INT_VEC3:
_data.i3[0] = rhs._data.i3[0];
_data.i3[1] = rhs._data.i3[1];
_data.i3[2] = rhs._data.i3[2];
break;
case INT_VEC3:
_data.i3[0] = rhs._data.i3[0];
_data.i3[1] = rhs._data.i3[1];
_data.i3[2] = rhs._data.i3[2];
break;
case INT_VEC4:
_data.i4[0] = rhs._data.i4[0];
_data.i4[1] = rhs._data.i4[1];
_data.i4[2] = rhs._data.i4[2];
_data.i4[3] = rhs._data.i4[3];
break;
case INT_VEC4:
_data.i4[0] = rhs._data.i4[0];
_data.i4[1] = rhs._data.i4[1];
_data.i4[2] = rhs._data.i4[2];
_data.i4[3] = rhs._data.i4[3];
break;
default:
osg::notify(osg::WARN) << "cannot copy UNDEFINED Uniform type" << std::endl;
break;
default:
osg::notify(osg::WARN) << "cannot copy UNDEFINED Uniform type" << std::endl;
break;
}
}
@@ -269,8 +269,8 @@ bool Uniform::isCompatibleType( Type t ) const
if( repType(t) == repType(getType()) ) return true;
osg::notify(osg::WARN)
<< "Cannot assign between Uniform types " << getTypename(t)
<< " and " << getTypename(getType()) << std::endl;
<< "Cannot assign between Uniform types " << getTypename(t)
<< " and " << getTypename(getType()) << std::endl;
return false;
}
@@ -281,54 +281,54 @@ const char* Uniform::getTypename( Type t )
{
switch( t )
{
case FLOAT: return "float";
case FLOAT_VEC2: return "vec2";
case FLOAT_VEC3: return "vec3";
case FLOAT_VEC4: return "vec4";
case INT: return "int";
case INT_VEC2: return "ivec2";
case INT_VEC3: return "ivec3";
case INT_VEC4: return "ivec4";
case BOOL: return "bool";
case BOOL_VEC2: return "bvec2";
case BOOL_VEC3: return "bvec3";
case BOOL_VEC4: return "bvec4";
case FLOAT_MAT2: return "mat2";
case FLOAT_MAT3: return "mat3";
case FLOAT_MAT4: return "mat4";
case SAMPLER_1D: return "sampler1D";
case SAMPLER_2D: return "sampler2D";
case SAMPLER_3D: return "sampler3D";
case SAMPLER_CUBE: return "samplerCube";
case SAMPLER_1D_SHADOW: return "sampler1DShadow";
case SAMPLER_2D_SHADOW: return "sampler2DShadow";
default: return "UNDEFINED";
case FLOAT: return "float";
case FLOAT_VEC2: return "vec2";
case FLOAT_VEC3: return "vec3";
case FLOAT_VEC4: return "vec4";
case INT: return "int";
case INT_VEC2: return "ivec2";
case INT_VEC3: return "ivec3";
case INT_VEC4: return "ivec4";
case BOOL: return "bool";
case BOOL_VEC2: return "bvec2";
case BOOL_VEC3: return "bvec3";
case BOOL_VEC4: return "bvec4";
case FLOAT_MAT2: return "mat2";
case FLOAT_MAT3: return "mat3";
case FLOAT_MAT4: return "mat4";
case SAMPLER_1D: return "sampler1D";
case SAMPLER_2D: return "sampler2D";
case SAMPLER_3D: return "sampler3D";
case SAMPLER_CUBE: return "samplerCube";
case SAMPLER_1D_SHADOW: return "sampler1DShadow";
case SAMPLER_2D_SHADOW: return "sampler2DShadow";
default: return "UNDEFINED";
}
}
Uniform::Type Uniform::getTypeId( const std::string& tname )
{
if( tname == "float" ) return FLOAT;
if( tname == "vec2" ) return FLOAT_VEC2;
if( tname == "vec3" ) return FLOAT_VEC3;
if( tname == "vec4" ) return FLOAT_VEC4;
if( tname == "int" ) return INT;
if( tname == "ivec2" ) return INT_VEC2;
if( tname == "ivec3" ) return INT_VEC3;
if( tname == "ivec4" ) return INT_VEC4;
if( tname == "bool" ) return BOOL;
if( tname == "bvec2" ) return BOOL_VEC2;
if( tname == "bvec3" ) return BOOL_VEC3;
if( tname == "bvec4" ) return BOOL_VEC4;
if( tname == "mat2" ) return FLOAT_MAT2;
if( tname == "mat3" ) return FLOAT_MAT3;
if( tname == "mat4" ) return FLOAT_MAT4;
if( tname == "sampler1D" ) return SAMPLER_1D;
if( tname == "sampler2D" ) return SAMPLER_2D;
if( tname == "sampler3D" ) return SAMPLER_3D;
if( tname == "samplerCube" ) return SAMPLER_CUBE;
if( tname == "sampler1DShadow" ) return SAMPLER_1D_SHADOW;
if( tname == "sampler2DShadow" ) return SAMPLER_2D_SHADOW;
if( tname == "float" ) return FLOAT;
if( tname == "vec2" ) return FLOAT_VEC2;
if( tname == "vec3" ) return FLOAT_VEC3;
if( tname == "vec4" ) return FLOAT_VEC4;
if( tname == "int" ) return INT;
if( tname == "ivec2" ) return INT_VEC2;
if( tname == "ivec3" ) return INT_VEC3;
if( tname == "ivec4" ) return INT_VEC4;
if( tname == "bool" ) return BOOL;
if( tname == "bvec2" ) return BOOL_VEC2;
if( tname == "bvec3" ) return BOOL_VEC3;
if( tname == "bvec4" ) return BOOL_VEC4;
if( tname == "mat2" ) return FLOAT_MAT2;
if( tname == "mat3" ) return FLOAT_MAT3;
if( tname == "mat4" ) return FLOAT_MAT4;
if( tname == "sampler1D" ) return SAMPLER_1D;
if( tname == "sampler2D" ) return SAMPLER_2D;
if( tname == "sampler3D" ) return SAMPLER_3D;
if( tname == "samplerCube" ) return SAMPLER_CUBE;
if( tname == "sampler1DShadow" ) return SAMPLER_1D_SHADOW;
if( tname == "sampler2DShadow" ) return SAMPLER_2D_SHADOW;
return UNDEFINED;
}
@@ -336,26 +336,26 @@ Uniform::Type Uniform::repType( Type t )
{
switch( t )
{
case BOOL:
case SAMPLER_1D:
case SAMPLER_2D:
case SAMPLER_3D:
case SAMPLER_CUBE:
case SAMPLER_1D_SHADOW:
case SAMPLER_2D_SHADOW:
return INT;
case BOOL:
case SAMPLER_1D:
case SAMPLER_2D:
case SAMPLER_3D:
case SAMPLER_CUBE:
case SAMPLER_1D_SHADOW:
case SAMPLER_2D_SHADOW:
return INT;
case BOOL_VEC2:
return INT_VEC2;
case BOOL_VEC2:
return INT_VEC2;
case BOOL_VEC3:
return INT_VEC3;
case BOOL_VEC3:
return INT_VEC3;
case BOOL_VEC4:
return INT_VEC4;
case BOOL_VEC4:
return INT_VEC4;
default:
return t;
default:
return t;
}
}
@@ -364,25 +364,25 @@ Uniform::Type Uniform::repType( Type t )
// value constructors
Uniform::Uniform( const char* name, float f ) :
_name(name), _type(FLOAT)
_name(name), _type(FLOAT)
{
set( f );
}
Uniform::Uniform( const char* name, const osg::Vec2& v2 ) :
_name(name), _type(FLOAT_VEC2)
_name(name), _type(FLOAT_VEC2)
{
set( v2 );
}
Uniform::Uniform( const char* name, const osg::Vec3& v3 ) :
_name(name), _type(FLOAT_VEC3)
_name(name), _type(FLOAT_VEC3)
{
set( v3 );
}
Uniform::Uniform( const char* name, const osg::Vec4& v4 ) :
_name(name), _type(FLOAT_VEC4)
_name(name), _type(FLOAT_VEC4)
{
set( v4 );
}
@@ -392,55 +392,55 @@ Uniform::Uniform( const char* name, const osg::Vec4& v4 ) :
//Uniform::Uniform( const char* name, const osg::Matrix3& m3 )
Uniform::Uniform( const char* name, const osg::Matrix& m4 ) :
_name(name), _type(FLOAT_MAT4)
_name(name), _type(FLOAT_MAT4)
{
set( m4 );
}
Uniform::Uniform( const char* name, int i ) :
_name(name), _type(INT)
_name(name), _type(INT)
{
set( i );
}
Uniform::Uniform( const char* name, int i0, int i1 ) :
_name(name), _type(INT_VEC2)
_name(name), _type(INT_VEC2)
{
set( i0, i1 );
}
Uniform::Uniform( const char* name, int i0, int i1, int i2 ) :
_name(name), _type(INT_VEC3)
_name(name), _type(INT_VEC3)
{
set( i0, i1, i2 );
}
Uniform::Uniform( const char* name, int i0, int i1, int i2, int i3 ) :
_name(name), _type(INT_VEC4)
_name(name), _type(INT_VEC4)
{
set( i0, i1, i2, i3 );
}
Uniform::Uniform( const char* name, bool b ) :
_name(name), _type(BOOL)
_name(name), _type(BOOL)
{
set( b );
}
Uniform::Uniform( const char* name, bool b0, bool b1 ) :
_name(name), _type(BOOL_VEC2)
_name(name), _type(BOOL_VEC2)
{
set( b0, b1 );
}
Uniform::Uniform( const char* name, bool b0, bool b1, bool b2 ) :
_name(name), _type(BOOL_VEC3)
_name(name), _type(BOOL_VEC3)
{
set( b0, b1, b2 );
}
Uniform::Uniform( const char* name, bool b0, bool b1, bool b2, bool b3 ) :
_name(name), _type(BOOL_VEC4)
_name(name), _type(BOOL_VEC4)
{
set( b0, b1, b2, b3 );
}
@@ -492,10 +492,10 @@ bool Uniform::set( const osg::Matrix& m4 )
int n = 0;
for(int row=0; row<4; ++row)
{
for(int col=0; col<4; ++col)
{
_data.f16[n++] = m4(row,col);
}
for(int col=0; col<4; ++col)
{
_data.f16[n++] = m4(row,col);
}
}
return true;
}
@@ -615,10 +615,10 @@ bool Uniform::get( osg::Matrix& m4 ) const
int n = 0;
for(int row=0; row<4; ++row)
{
for(int col=0; col<4; ++col)
{
m4(row,col) = _data.f16[n++];
}
for(int col=0; col<4; ++col)
{
m4(row,col) = _data.f16[n++];
}
}
return true;
}
@@ -691,4 +691,58 @@ bool Uniform::get( bool& b0, bool& b1, bool& b2, bool& b3 ) const
return true;
}
void Uniform::apply(const GL2Extensions* ext, GLint location) const
{
switch( _type )
{
case FLOAT:
ext->glUniform1f( location, _data.f1 );
break;
case FLOAT_VEC2:
ext->glUniform2fv( location, 1, _data.f2 );
break;
case FLOAT_VEC3:
ext->glUniform3fv( location, 1, _data.f3 );
break;
case FLOAT_VEC4:
ext->glUniform4fv( location, 1, _data.f4 );
break;
case FLOAT_MAT2:
ext->glUniformMatrix2fv( location, 1, GL_FALSE, _data.f4 );
break;
case FLOAT_MAT3:
ext->glUniformMatrix3fv( location, 1, GL_FALSE, _data.f9 );
break;
case FLOAT_MAT4:
ext->glUniformMatrix4fv( location, 1, GL_FALSE, _data.f16 );
break;
case INT:
ext->glUniform1i( location, _data.i1 );
break;
case INT_VEC2:
ext->glUniform2iv( location, 1, _data.i2 );
break;
case INT_VEC3:
ext->glUniform3iv( location, 1, _data.i3 );
break;
case INT_VEC4:
ext->glUniform4iv( location, 1, _data.i4 );
break;
default:
osg::notify(osg::FATAL) << "how got here?" << std::endl;
break;
}
}
/*EOF*/