void
MPGeometry::renderPrimitiveSets(osg::State& state,
bool renderColor,
bool usingVBOs) const
{
// check the map frame to see if it's up to date
if ( _frame.needsSync() )
{
// this lock protects a MapFrame sync when we have multiple DRAW threads.
Threading::ScopedMutexLock exclusive( _frameSyncMutex );
if ( _frame.needsSync() && _frame.sync() ) // always double check
{
// This should only happen is the layer ordering changes;
// If layers are added or removed, the Tile gets rebuilt and
// the point is moot.
std::vector<Layer> reordered;
const ImageLayerVector& layers = _frame.imageLayers();
reordered.reserve( layers.size() );
for( ImageLayerVector::const_iterator i = layers.begin(); i != layers.end(); ++i )
{
std::vector<Layer>::iterator j = std::find( _layers.begin(), _layers.end(), i->get()->getUID() );
if ( j != _layers.end() )
reordered.push_back( *j );
}
_layers.swap( reordered );
}
}
unsigned layersDrawn = 0;
// access the GL extensions interface for the current GC:
const osg::Program::PerContextProgram* pcp = 0L;
#if OSG_MIN_VERSION_REQUIRED(3,3,3)
osg::ref_ptr<osg::GLExtensions> ext;
#else
osg::ref_ptr<osg::GL2Extensions> ext;
#endif
unsigned contextID;
if (_supportsGLSL)
{
contextID = state.getContextID();
#if OSG_MIN_VERSION_REQUIRED(3,3,3)
ext = osg::GLExtensions::Get(contextID, true);
#else
ext = osg::GL2Extensions::Get( contextID, true );
#endif
pcp = state.getLastAppliedProgramObject();
}
// cannot store these in the object since there could be multiple GCs (and multiple
// PerContextPrograms) at large
GLint tileKeyLocation = -1;
GLint birthTimeLocation = -1;
GLint opacityLocation = -1;
GLint uidLocation = -1;
GLint orderLocation = -1;
GLint texMatParentLocation = -1;
GLint minRangeLocation = -1;
GLint maxRangeLocation = -1;
// The PCP can change (especially in a VirtualProgram environment). So we do need to
// requery the uni locations each time unfortunately. TODO: explore optimizations.
if ( pcp )
{
tileKeyLocation = pcp->getUniformLocation( _tileKeyUniformNameID );
birthTimeLocation = pcp->getUniformLocation( _birthTimeUniformNameID );
opacityLocation = pcp->getUniformLocation( _opacityUniformNameID );
uidLocation = pcp->getUniformLocation( _uidUniformNameID );
orderLocation = pcp->getUniformLocation( _orderUniformNameID );
texMatParentLocation = pcp->getUniformLocation( _texMatParentUniformNameID );
minRangeLocation = pcp->getUniformLocation( _minRangeUniformNameID );
maxRangeLocation = pcp->getUniformLocation( _maxRangeUniformNameID );
}
// apply the tilekey uniform once.
if ( tileKeyLocation >= 0 )
{
ext->glUniform4fv( tileKeyLocation, 1, _tileKeyValue.ptr() );
}
// set the "birth time" - i.e. the time this tile last entered the scene in the current GC.
if ( birthTimeLocation >= 0 )
{
PerContextData& pcd = _pcd[contextID];
if ( pcd.birthTime < 0.0f )
{
const osg::FrameStamp* stamp = state.getFrameStamp();
if ( stamp )
{
pcd.birthTime = stamp->getReferenceTime();
}
}
ext->glUniform1f( birthTimeLocation, pcd.birthTime );
}
// activate the tile coordinate set - same for all layers
if ( renderColor )
{
state.setTexCoordPointer( _imageUnit+1, _tileCoords.get() );
}
#ifndef OSG_GLES2_AVAILABLE
if ( renderColor )
{
// emit a default terrain color since we're not binding a color array:
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
#endif
// activate the elevation texture if there is one. Same for all layers.
//if ( _elevTex.valid() )
//{
// state.setActiveTextureUnit( 2 );
// state.setTexCoordPointer( 1, _tileCoords.get() ); // necessary?? since we do it above
// _elevTex->apply( state );
// // todo: probably need an elev texture matrix as well. -gw
//}
// track the active image unit.
int activeImageUnit = -1;
// remember whether we applied a parent texture.
bool usedTexParent = false;
if ( _layers.size() > 0 )
{
float prev_opacity = -1.0f;
// first bind any shared layers. We still have to do this even if we are
// in !renderColor mode b/c these textures could be used by vertex shaders
// to alter the geometry.
int sharedLayers = 0;
if ( pcp )
{
for(unsigned i=0; i<_layers.size(); ++i)
{
const Layer& layer = _layers[i];
// a "shared" layer binds to a secondary texture unit so that other layers
// can see it and use it.
if ( layer._imageLayer->isShared() )
{
++sharedLayers;
int sharedUnit = layer._imageLayer->shareImageUnit().get();
{
state.setActiveTextureUnit( sharedUnit );
state.setTexCoordPointer( sharedUnit, layer._texCoords.get() );
// bind the texture for this layer to the active share unit.
layer._tex->apply( state );
// Shared layers need a texture matrix since the terrain engine doesn't
// provide a "current texture coordinate set" uniform (i.e. oe_layer_texc)
GLint texMatLocation = 0;
texMatLocation = pcp->getUniformLocation( layer._texMatUniformID );
if ( texMatLocation >= 0 )
{
ext->glUniformMatrix4fv( texMatLocation, 1, GL_FALSE, layer._texMat.ptr() );
}
}
}
}
}
if (renderColor)
{
// find the first opaque layer, top-down, and start there:
unsigned first = 0;
for(first = _layers.size()-1; first > 0; --first)
{
const Layer& layer = _layers[first];
if (layer._opaque &&
//Color filters can modify the opacity
layer._imageLayer->getColorFilters().empty() &&
layer._imageLayer->getVisible() &&
layer._imageLayer->getOpacity() >= 1.0f)
{
break;
}
}
// interate over all the image layers
for(unsigned i=first; i<_layers.size(); ++i)
{
const Layer& layer = _layers[i];
if ( layer._imageLayer->getVisible() && layer._imageLayer->getOpacity() > 0.0f )
{
// activate the visible unit if necessary:
if ( activeImageUnit != _imageUnit )
{
state.setActiveTextureUnit( _imageUnit );
activeImageUnit = _imageUnit;
}
// bind the texture for this layer:
layer._tex->apply( state );
// in FFP mode, we need to enable the GL mode for texturing:
if ( !pcp ) //!_supportsGLSL)
{
state.applyMode(GL_TEXTURE_2D, true);
}
// if we're using a parent texture for blending, activate that now
if ( texMatParentLocation >= 0 && layer._texParent.valid() )
{
state.setActiveTextureUnit( _imageUnitParent );
activeImageUnit = _imageUnitParent;
layer._texParent->apply( state );
usedTexParent = true;
}
// bind the texture coordinates for this layer.
// TODO: can probably optimize this by sharing or using texture matrixes.
// State::setTexCoordPointer does some redundant work under the hood.
state.setTexCoordPointer( _imageUnit, layer._texCoords.get() );
// apply uniform values:
if ( pcp )
{
// apply opacity:
if ( opacityLocation >= 0 )
{
float opacity = layer._imageLayer->getOpacity();
if ( opacity != prev_opacity )
{
ext->glUniform1f( opacityLocation, (GLfloat)opacity );
prev_opacity = opacity;
}
}
// assign the layer UID:
if ( uidLocation >= 0 )
{
ext->glUniform1i( uidLocation, (GLint)layer._layerID );
}
// assign the layer order:
if ( orderLocation >= 0 )
{
ext->glUniform1i( orderLocation, (GLint)layersDrawn );
}
// assign the parent texture matrix
if ( texMatParentLocation >= 0 && layer._texParent.valid() )
{
ext->glUniformMatrix4fv( texMatParentLocation, 1, GL_FALSE, layer._texMatParent.ptr() );
}
// assign the min range
if ( minRangeLocation >= 0 )
{
ext->glUniform1f( minRangeLocation, layer._imageLayer->getImageLayerOptions().minVisibleRange().get() );
}
// assign the max range
if ( maxRangeLocation >= 0 )
{
ext->glUniform1f( maxRangeLocation, layer._imageLayer->getImageLayerOptions().maxVisibleRange().get() );
}
}
// draw the primitive sets.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
if ( primitiveset )
{
primitiveset->draw(state, usingVBOs);
}
else
{
OE_WARN << LC << "Strange, MPGeometry had a 0L primset" << std::endl;
}
}
++layersDrawn;
}
}
}
}
// if we didn't draw anything, draw the raw tiles anyway with no texture.
if ( layersDrawn == 0 )
{
if ( pcp )
{
if ( opacityLocation >= 0 )
ext->glUniform1f( opacityLocation, (GLfloat)1.0f );
if ( uidLocation >= 0 )
ext->glUniform1i( uidLocation, (GLint)-1 );
if ( orderLocation >= 0 )
ext->glUniform1i( orderLocation, (GLint)0 );
}
// draw the primitives themselves.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
primitiveset->draw(state, usingVBOs);
}
}
else // at least one textured layer was drawn:
{
// prevent texture leakage
// TODO: find a way to remove this to speed things up
if ( renderColor )
{
glBindTexture( GL_TEXTURE_2D, 0 );
// if a parent texture was applied, need to disable both.
if ( usedTexParent )
{
state.setActiveTextureUnit(
activeImageUnit != _imageUnitParent ? _imageUnitParent :
_imageUnit );
glBindTexture( GL_TEXTURE_2D, 0);
}
}
}
}
void
VirtualProgram::apply( osg::State& state ) const
{
if (_shaderMap.empty() && !_inheritSet)
{
// If there's no data in the VP, and never has been, unload any existing program.
// NOTE: OSG's State processor creates a "global default attribute" for each type.
// Sine we have no way of knowing whether the user created the VP or OSG created it
// as the default fallback, we use the "_inheritSet" flag to differeniate. This
// prevents any shader leakage from a VP-enabled node.
const unsigned int contextID = state.getContextID();
const osg::GL2Extensions* extensions = osg::GL2Extensions::Get(contextID,true);
if( ! extensions->isGlslSupported() ) return;
extensions->glUseProgram( 0 );
state.setLastAppliedProgramObject(0);
return;
}
// first, find and collect all the VirtualProgram attributes:
ShaderMap accumShaderMap;
AttribBindingList accumAttribBindings;
AttribAliasMap accumAttribAliases;
// Build the active shader map up to this point:
if ( _inherit )
{
accumulateShaders(state, _mask, accumShaderMap, accumAttribBindings, accumAttribAliases);
}
// next add the local shader components to the map, respecting the override values:
{
Threading::ScopedReadLock readonly(_dataModelMutex);
for( ShaderMap::const_iterator i = _shaderMap.begin(); i != _shaderMap.end(); ++i )
{
if ( i->second.accept(state) )
{
addToAccumulatedMap( accumShaderMap, i->first, i->second );
}
}
const AttribBindingList& abl = this->getAttribBindingList();
accumAttribBindings.insert( abl.begin(), abl.end() );
#ifdef USE_ATTRIB_ALIASES
const AttribAliasMap& aliases = this->getAttribAliases();
accumAttribAliases.insert( aliases.begin(), aliases.end() );
#endif
}
// next, assemble a list of the shaders in the map so we can use it as our
// program cache key.
// (Note: at present, the "cache key" does not include any information on the vertex
// attribute bindings. Technically it should, but in practice this might not be an
// issue; it is unlikely one would have two identical shader programs with different
// bindings.)
ShaderVector vec;
vec.reserve( accumShaderMap.size() );
for( ShaderMap::iterator i = accumShaderMap.begin(); i != accumShaderMap.end(); ++i )
{
ShaderEntry& entry = i->second;
if ( i->second.accept(state) )
{
vec.push_back( entry._shader.get() );
}
}
// see if there's already a program associated with this list:
osg::ref_ptr<osg::Program> program;
// look up the program:
{
Threading::ScopedReadLock shared( _programCacheMutex );
ProgramMap::const_iterator p = _programCache.find( vec );
if ( p != _programCache.end() )
{
program = p->second.get();
}
}
// if not found, lock and build it:
if ( !program.valid() )
{
// build a new set of accumulated functions, to support the creation of main()
ShaderComp::FunctionLocationMap accumFunctions;
accumulateFunctions( state, accumFunctions );
// now double-check the program cache, and failing that, build the
// new shader Program.
{
Threading::ScopedWriteLock exclusive( _programCacheMutex );
// double-check: look again ito negate race conditions
ProgramMap::const_iterator p = _programCache.find( vec );
if ( p != _programCache.end() )
{
program = p->second.get();
}
else
{
ShaderVector keyVector;
//OE_NOTICE << LC << "Building new Program for VP " << getName() << std::endl;
program = buildProgram(
getName(),
state,
accumFunctions,
accumShaderMap,
accumAttribBindings,
accumAttribAliases,
_template.get(),
keyVector);
// global sharing.
s_programRepo.share(program);
// finally, put own new program in the cache.
_programCache[ keyVector ] = program;
}
}
}
// finally, apply the program attribute.
if ( program.valid() )
{
const unsigned int contextID = state.getContextID();
const osg::GL2Extensions* extensions = osg::GL2Extensions::Get(contextID,true);
osg::Program::PerContextProgram* pcp = program->getPCP( contextID );
bool useProgram = state.getLastAppliedProgramObject() != pcp;
#ifdef DEBUG_APPLY_COUNTS
{
// debugging
static int s_framenum = 0;
static Threading::Mutex s_mutex;
static std::map< const VirtualProgram*, std::pair<int,int> > s_counts;
Threading::ScopedMutexLock lock(s_mutex);
int framenum = state.getFrameStamp()->getFrameNumber();
if ( framenum > s_framenum )
{
OE_NOTICE << LC << "Applies in last frame: " << std::endl;
for(std::map<const VirtualProgram*,std::pair<int,int> >::iterator i = s_counts.begin(); i != s_counts.end(); ++i)
{
std::pair<int,int>& counts = i->second;
OE_NOTICE << LC << " "
<< i->first->getName() << " : " << counts.second << "/" << counts.first << std::endl;
}
s_framenum = framenum;
s_counts.clear();
}
s_counts[this].first++;
if ( useProgram )
s_counts[this].second++;
}
#endif
if ( useProgram )
{
if( pcp->needsLink() )
program->compileGLObjects( state );
if( pcp->isLinked() )
{
if( osg::isNotifyEnabled(osg::INFO) )
pcp->validateProgram();
pcp->useProgram();
state.setLastAppliedProgramObject( pcp );
}
else
{
// program not usable, fallback to fixed function.
extensions->glUseProgram( 0 );
state.setLastAppliedProgramObject(0);
OE_WARN << LC << "Program link failure!" << std::endl;
}
}
//program->apply( state );
#if 0 // test code for detecting race conditions
for(int i=0; i<10000; ++i) {
state.setLastAppliedProgramObject(0L);
program->apply( state );
}
#endif
}
}
void
MPGeometry::renderPrimitiveSets(osg::State& state,
bool usingVBOs) const
{
// check the map frame to see if it's up to date
if ( _frame.needsSync() )
{
// this lock protects a MapFrame sync when we have multiple DRAW threads.
Threading::ScopedMutexLock exclusive( _frameSyncMutex );
if ( _frame.needsSync() && _frame.sync() ) // always double check
{
// This should only happen is the layer ordering changes;
// If layers are added or removed, the Tile gets rebuilt and
// the point is moot.
std::vector<Layer> reordered;
const ImageLayerVector& layers = _frame.imageLayers();
reordered.reserve( layers.size() );
for( ImageLayerVector::const_iterator i = layers.begin(); i != layers.end(); ++i )
{
std::vector<Layer>::iterator j = std::find( _layers.begin(), _layers.end(), i->get()->getUID() );
if ( j != _layers.end() )
reordered.push_back( *j );
}
_layers.swap( reordered );
}
}
unsigned layersDrawn = 0;
osg::ref_ptr<osg::GL2Extensions> ext = osg::GL2Extensions::Get( state.getContextID(), true );
const osg::Program::PerContextProgram* pcp = state.getLastAppliedProgramObject();
GLint opacityLocation;
GLint uidLocation;
GLint orderLocation;
GLint texMatParentLocation;
// yes, it's possible that the PCP is not set up yet.
// TODO: can we optimize this so we don't need to get uni locations every time?
if ( pcp )
{
opacityLocation = pcp->getUniformLocation( _opacityUniform->getNameID() );
uidLocation = pcp->getUniformLocation( _layerUIDUniform->getNameID() );
orderLocation = pcp->getUniformLocation( _layerOrderUniform->getNameID() );
texMatParentLocation = pcp->getUniformLocation( _texMatParentUniform->getNameID() );
}
// activate the tile coordinate set - same for all layers
state.setTexCoordPointer( _imageUnit+1, _tileCoords.get() );
if ( _layers.size() > 0 )
{
float prev_opacity = -1.0f;
float prev_alphaThreshold = -1.0f;
// first bind any shared layers
// TODO: optimize by pre-storing shared indexes
for(unsigned i=0; i<_layers.size(); ++i)
{
const Layer& layer = _layers[i];
// a "shared" layer binds to a secondary texture unit so that other layers
// can see it and use it.
if ( layer._imageLayer->isShared() )
{
int sharedUnit = layer._imageLayer->shareImageUnit().get();
{
state.setActiveTextureUnit( sharedUnit );
state.setTexCoordPointer( sharedUnit, layer._texCoords.get() );
// bind the texture for this layer to the active share unit.
layer._tex->apply( state );
// no texture LOD blending for shared layers for now. maybe later.
}
}
}
// track the active image unit.
int activeImageUnit = -1;
// interate over all the image layers
for(unsigned i=0; i<_layers.size(); ++i)
{
const Layer& layer = _layers[i];
if ( layer._imageLayer->getVisible() )
{
// activate the visible unit if necessary:
if ( activeImageUnit != _imageUnit )
{
state.setActiveTextureUnit( _imageUnit );
activeImageUnit = _imageUnit;
}
// bind the texture for this layer:
layer._tex->apply( state );
// if we're using a parent texture for blending, activate that now
if ( layer._texParent.valid() )
{
state.setActiveTextureUnit( _imageUnitParent );
activeImageUnit = _imageUnitParent;
layer._texParent->apply( state );
}
// bind the texture coordinates for this layer.
// TODO: can probably optimize this by sharing or using texture matrixes.
// State::setTexCoordPointer does some redundant work under the hood.
state.setTexCoordPointer( _imageUnit, layer._texCoords.get() );
// apply uniform values:
if ( pcp )
{
// apply opacity:
float opacity = layer._imageLayer->getOpacity();
if ( opacity != prev_opacity )
{
_opacityUniform->set( opacity );
_opacityUniform->apply( ext, opacityLocation );
prev_opacity = opacity;
}
// assign the layer UID:
_layerUIDUniform->set( layer._layerID );
_layerUIDUniform->apply( ext, uidLocation );
// assign the layer order:
_layerOrderUniform->set( (int)layersDrawn );
_layerOrderUniform->apply( ext, orderLocation );
// assign the parent texture matrix
if ( layer._texParent.valid() )
{
_texMatParentUniform->set( layer._texMatParent );
_texMatParentUniform->apply( ext, texMatParentLocation );
}
}
// draw the primitive sets.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
primitiveset->draw(state, usingVBOs);
}
++layersDrawn;
}
}
// prevent texture leakage
glBindTexture( GL_TEXTURE_2D, 0 );
}
// if we didn't draw anything, draw the raw tiles anyway with no texture.
if ( layersDrawn == 0 )
{
_opacityUniform->set( 1.0f );
_opacityUniform->apply( ext, opacityLocation );
_layerUIDUniform->set( (int)-1 ); // indicates a non-textured layer
_layerUIDUniform->apply( ext, uidLocation );
_layerOrderUniform->set( (int)0 );
_layerOrderUniform->apply( ext, orderLocation );
// draw the primitives themselves.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
primitiveset->draw(state, usingVBOs);
}
}
}
void
MPGeometry::renderPrimitiveSets(osg::State& state,
bool usingVBOs) const
{
// check the map frame to see if it's up to date
if ( _frame.needsSync() )
{
// this lock protects a MapFrame sync when we have multiple DRAW threads.
Threading::ScopedMutexLock exclusive( _frameSyncMutex );
if ( _frame.needsSync() && _frame.sync() ) // always double check
{
// This should only happen is the layer ordering changes;
// If layers are added or removed, the Tile gets rebuilt and
// the point is moot.
std::vector<Layer> reordered;
const ImageLayerVector& layers = _frame.imageLayers();
reordered.reserve( layers.size() );
for( ImageLayerVector::const_iterator i = layers.begin(); i != layers.end(); ++i )
{
std::vector<Layer>::iterator j = std::find( _layers.begin(), _layers.end(), i->get()->getUID() );
if ( j != _layers.end() )
reordered.push_back( *j );
}
_layers.swap( reordered );
}
}
unsigned layersDrawn = 0;
// access the GL extensions interface for the current GC:
osg::ref_ptr<osg::GL2Extensions> ext = osg::GL2Extensions::Get( state.getContextID(), true );
const osg::Program::PerContextProgram* pcp = state.getLastAppliedProgramObject();
// cannot store these in the object since there could be multiple GCs (and multiple
// PerContextPrograms) at large
GLint tileKeyLocation;
GLint opacityLocation;
GLint uidLocation;
GLint orderLocation;
GLint texMatParentLocation;
// The PCP can change (especially in a VirtualProgram environment). So we do need to
// requery the uni locations each time unfortunately. TODO: explore optimizations.
if ( pcp )
{
tileKeyLocation = pcp->getUniformLocation( _tileKeyUniformNameID );
opacityLocation = pcp->getUniformLocation( _opacityUniformNameID );
uidLocation = pcp->getUniformLocation( _uidUniformNameID );
orderLocation = pcp->getUniformLocation( _orderUniformNameID );
texMatParentLocation = pcp->getUniformLocation( _texMatParentUniformNameID );
}
// apply the tilekey uniform once.
ext->glUniform4fv( tileKeyLocation, 1, _tileKeyValue.ptr() );
// activate the tile coordinate set - same for all layers
state.setTexCoordPointer( _imageUnit+1, _tileCoords.get() );
if ( _layers.size() > 0 )
{
float prev_opacity = -1.0f;
float prev_alphaThreshold = -1.0f;
// first bind any shared layers
// TODO: optimize by pre-storing shared indexes
for(unsigned i=0; i<_layers.size(); ++i)
{
const Layer& layer = _layers[i];
// a "shared" layer binds to a secondary texture unit so that other layers
// can see it and use it.
if ( layer._imageLayer->isShared() )
{
int sharedUnit = layer._imageLayer->shareImageUnit().get();
{
state.setActiveTextureUnit( sharedUnit );
state.setTexCoordPointer( sharedUnit, layer._texCoords.get() );
// bind the texture for this layer to the active share unit.
layer._tex->apply( state );
// no texture LOD blending for shared layers for now. maybe later.
}
}
}
// track the active image unit.
int activeImageUnit = -1;
// interate over all the image layers
//glDepthMask(GL_TRUE);
for(unsigned i=0; i<_layers.size(); ++i)
{
// if ( i > 0 )
// glDepthMask(GL_FALSE);
const Layer& layer = _layers[i];
if ( layer._imageLayer->getVisible() )
{
// activate the visible unit if necessary:
if ( activeImageUnit != _imageUnit )
{
state.setActiveTextureUnit( _imageUnit );
activeImageUnit = _imageUnit;
}
// bind the texture for this layer:
layer._tex->apply( state );
// if we're using a parent texture for blending, activate that now
if ( layer._texParent.valid() )
{
state.setActiveTextureUnit( _imageUnitParent );
activeImageUnit = _imageUnitParent;
layer._texParent->apply( state );
}
// bind the texture coordinates for this layer.
// TODO: can probably optimize this by sharing or using texture matrixes.
// State::setTexCoordPointer does some redundant work under the hood.
state.setTexCoordPointer( _imageUnit, layer._texCoords.get() );
// apply uniform values:
if ( pcp )
{
// apply opacity:
float opacity = layer._imageLayer->getOpacity();
if ( opacity != prev_opacity )
{
ext->glUniform1f( opacityLocation, (GLfloat)opacity );
prev_opacity = opacity;
}
// assign the layer UID:
ext->glUniform1i( uidLocation, (GLint)layer._layerID );
// assign the layer order:
ext->glUniform1i( orderLocation, (GLint)layersDrawn );
// assign the parent texture matrix
if ( layer._texParent.valid() )
{
ext->glUniformMatrix4fv( texMatParentLocation, 1, GL_FALSE, layer._texMatParent.ptr() );
}
}
// draw the primitive sets.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
primitiveset->draw(state, usingVBOs);
}
++layersDrawn;
}
}
// prevent texture leakage
// TODO: find a way to remove this to speed things up
glBindTexture( GL_TEXTURE_2D, 0 );
}
// if we didn't draw anything, draw the raw tiles anyway with no texture.
if ( layersDrawn == 0 )
{
ext->glUniform1f( opacityLocation, (GLfloat)1.0f );
ext->glUniform1i( uidLocation, (GLint)-1 );
ext->glUniform1i( orderLocation, (GLint)0 );
// draw the primitives themselves.
for(unsigned int primitiveSetNum=0; primitiveSetNum!=_primitives.size(); ++primitiveSetNum)
{
const osg::PrimitiveSet* primitiveset = _primitives[primitiveSetNum].get();
primitiveset->draw(state, usingVBOs);
}
}
}