bool
TileNode::inheritState(EngineContext* context)
{
// Find the parent node. It will only be null if this is a "first LOD" tile.
TileNode* parent = getNumParents() > 0 ? dynamic_cast<TileNode*>(getParent(0)) : 0L;
bool changesMade = false;
// which quadrant is this tile in?
unsigned quadrant = getTileKey().getQuadrant();
// default inheritance of the elevation data for bounding purposes:
osg::ref_ptr<const osg::Image> elevRaster;
osg::Matrixf elevMatrix;
if ( parent )
{
elevRaster = parent->getElevationRaster();
elevMatrix = parent->getElevationMatrix();
elevMatrix.preMult( scaleBias[quadrant] );
}
// Find all the sampler matrix uniforms and scale/bias them to the current quadrant.
// This will inherit textures and use the proper sub-quadrant until new data arrives (later).
for( RenderBindings::const_iterator binding = context->getRenderBindings().begin(); binding != context->getRenderBindings().end(); ++binding )
{
if ( binding->usage().isSetTo(binding->COLOR) )
{
if ( parent && parent->getStateSet() )
{
MPTexture* parentMPTex = parent->getMPTexture();
_mptex->inheritState( parentMPTex, scaleBias[quadrant] );
changesMade = true;
}
}
else if ( binding->usage().isSetTo(binding->COLOR_PARENT) )
{
//nop -- this is handled as part of the COLOR binding
}
else
{
osg::StateAttribute* sa = getStateSet()->getTextureAttribute(binding->unit(), osg::StateAttribute::TEXTURE);
// If the attribute isn't present, that means we are inheriting it from above.
// So construct a new scale/bias matrix.
if ( sa == 0L )
{
osg::Matrixf matrix;
// Find the parent's matrix and scale/bias it to this quadrant:
if ( parent && parent->getStateSet() )
{
const osg::Uniform* matrixUniform = parent->getStateSet()->getUniform( binding->matrixName() );
if ( matrixUniform )
{
matrixUniform->get( matrix );
matrix.preMult( scaleBias[quadrant] );
}
}
// Add a new uniform with the scale/bias'd matrix:
osg::StateSet* stateSet = getOrCreateStateSet();
stateSet->removeUniform( binding->matrixName() );
stateSet->addUniform( context->getOrCreateMatrixUniform(binding->matrixName(), matrix) );
changesMade = true;
}
// If this is elevation data, record the new raster so we can apply it to the node.
else if ( binding->usage().isSetTo(binding->ELEVATION) )
{
osg::Texture* t = static_cast<osg::Texture*>(sa);
elevRaster = t->getImage(0);
elevMatrix = osg::Matrixf::identity();
}
}
}
// If we found one, communicate it to the node and its children.
if (elevRaster.valid())
{
if (elevRaster.get() != getElevationRaster() || elevMatrix != getElevationMatrix() )
{
setElevationRaster( elevRaster.get(), elevMatrix );
changesMade = true;
}
}
// finally, update the uniforms for terrain morphing
updateTileUniforms( context->getSelectionInfo() );
if ( !changesMade )
{
OE_INFO << LC << _key.str() << ", good, no changes :)\n";
}
else
{
dirtyBound();
}
return changesMade;
}
// Generates the main shader code for rendering the terrain.
void
RexTerrainEngineNode::updateState()
{
if ( _batchUpdateInProgress )
{
_stateUpdateRequired = true;
}
else
{
osg::StateSet* terrainStateSet = _terrain->getOrCreateStateSet(); // everything
osg::StateSet* surfaceStateSet = getSurfaceStateSet(); // just the surface
// required for multipass tile rendering to work
surfaceStateSet->setAttributeAndModes(
new osg::Depth(osg::Depth::LEQUAL, 0, 1, true) );
// activate standard mix blending.
terrainStateSet->setAttributeAndModes(
new osg::BlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA),
osg::StateAttribute::ON );
// install patch param if we are tessellation on the GPU.
if ( _terrainOptions.gpuTessellation() == true )
{
#ifdef HAVE_PATCH_PARAMETER
terrainStateSet->setAttributeAndModes( new osg::PatchParameter(3) );
#endif
}
// install shaders, if we're using them.
if ( Registry::capabilities().supportsGLSL() )
{
Shaders package;
VirtualProgram* terrainVP = VirtualProgram::getOrCreate(terrainStateSet);
terrainVP->setName( "Rex Terrain" );
package.load(terrainVP, package.ENGINE_VERT_MODEL);
//moved to CTOR so it's always available
//package.load(terrainVP, package.SDK);
bool useTerrainColor = _terrainOptions.color().isSet();
package.define("OE_REX_USE_TERRAIN_COLOR", useTerrainColor);
if ( useTerrainColor )
{
surfaceStateSet->addUniform(new osg::Uniform("oe_terrain_color", _terrainOptions.color().get()));
}
bool useBlending = _terrainOptions.enableBlending().get();
package.define("OE_REX_GL_BLENDING", useBlending);
bool morphImagery = _terrainOptions.morphImagery().get();
package.define("OE_REX_MORPH_IMAGERY", morphImagery);
// Funtions that affect only the terrain surface:
VirtualProgram* surfaceVP = VirtualProgram::getOrCreate(surfaceStateSet);
surfaceVP->setName("Rex Surface");
// Functions that affect the terrain surface only:
package.load(surfaceVP, package.ENGINE_VERT_VIEW);
package.load(surfaceVP, package.ENGINE_FRAG);
// Normal mapping shaders:
if ( this->normalTexturesRequired() )
{
package.load(surfaceVP, package.NORMAL_MAP_VERT);
package.load(surfaceVP, package.NORMAL_MAP_FRAG);
}
// Morphing?
if (_terrainOptions.morphTerrain() == true ||
_terrainOptions.morphImagery() == true)
{
package.define("OE_REX_VERTEX_MORPHING", (_terrainOptions.morphTerrain() == true));
package.load(surfaceVP, package.MORPHING_VERT);
}
for(LandCoverZones::iterator zone = _landCoverData._zones.begin(); zone != _landCoverData._zones.end(); ++zone)
{
for(LandCoverBins::iterator bin = zone->_bins.begin(); bin != zone->_bins.end(); ++bin)
{
osg::StateSet* landCoverStateSet = bin->_binProto->getStateSet();
// enable alpha-to-coverage multisampling for vegetation.
landCoverStateSet->setMode(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB, 1);
// uniform that communicates the availability of multisampling.
landCoverStateSet->addUniform( new osg::Uniform(
"oe_terrain_hasMultiSamples",
osg::DisplaySettings::instance()->getMultiSamples()) );
landCoverStateSet->setAttributeAndModes(
new osg::BlendFunc(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO),
osg::StateAttribute::OVERRIDE );
#ifdef HAVE_OSG_PATCH_PARAMETER
landCoverStateSet->setAttributeAndModes( new osg::PatchParameter(3) );
#endif
}
}
// assemble color filter code snippets.
bool haveColorFilters = false;
{
// Color filter frag function:
std::string fs_colorfilters =
"#version " GLSL_VERSION_STR "\n"
GLSL_DEFAULT_PRECISION_FLOAT "\n"
"uniform int oe_layer_uid; \n"
"$COLOR_FILTER_HEAD"
"void oe_rexEngine_applyFilters(inout vec4 color) \n"
"{ \n"
"$COLOR_FILTER_BODY"
"} \n";
std::stringstream cf_head;
std::stringstream cf_body;
const char* I = " ";
// second, install the per-layer color filter functions AND shared layer bindings.
bool ifStarted = false;
int numImageLayers = _update_mapf->imageLayers().size();
for( int i=0; i<numImageLayers; ++i )
{
ImageLayer* layer = _update_mapf->getImageLayerAt(i);
if ( layer->getEnabled() )
{
// install Color Filter function calls:
const ColorFilterChain& chain = layer->getColorFilters();
if ( chain.size() > 0 )
{
haveColorFilters = true;
if ( ifStarted ) cf_body << I << "else if ";
else cf_body << I << "if ";
cf_body << "(oe_layer_uid == " << layer->getUID() << ") {\n";
for( ColorFilterChain::const_iterator j = chain.begin(); j != chain.end(); ++j )
{
const ColorFilter* filter = j->get();
cf_head << "void " << filter->getEntryPointFunctionName() << "(inout vec4 color);\n";
cf_body << I << I << filter->getEntryPointFunctionName() << "(color);\n";
filter->install( surfaceStateSet );
}
cf_body << I << "}\n";
ifStarted = true;
}
}
}
if ( haveColorFilters )
{
std::string cf_head_str, cf_body_str;
cf_head_str = cf_head.str();
cf_body_str = cf_body.str();
replaceIn( fs_colorfilters, "$COLOR_FILTER_HEAD", cf_head_str );
replaceIn( fs_colorfilters, "$COLOR_FILTER_BODY", cf_body_str );
surfaceVP->setFunction(
"oe_rexEngine_applyFilters",
fs_colorfilters,
ShaderComp::LOCATION_FRAGMENT_COLORING,
0.0 );
}
}
// Apply uniforms for sampler bindings:
OE_DEBUG << LC << "Render Bindings:\n";
for(RenderBindings::const_iterator b = _renderBindings.begin(); b != _renderBindings.end(); ++b)
{
if ( b->isActive() )
{
terrainStateSet->addUniform( new osg::Uniform(b->samplerName().c_str(), b->unit()) );
OE_DEBUG << LC << " > Bound \"" << b->samplerName() << "\" to unit " << b->unit() << "\n";
}
}
// uniform that controls per-layer opacity
terrainStateSet->addUniform( new osg::Uniform("oe_layer_opacity", 1.0f) );
// uniform that conveys the layer UID to the shaders; necessary
// for per-layer branching (like color filters)
// UID -1 => no image layer (no texture)
terrainStateSet->addUniform( new osg::Uniform("oe_layer_uid", (int)-1 ) );
// uniform that conveys the render order, since the shaders
// need to know which is the first layer in order to blend properly
terrainStateSet->addUniform( new osg::Uniform("oe_layer_order", (int)0) );
// default min/max range uniforms. (max < min means ranges are disabled)
terrainStateSet->addUniform( new osg::Uniform("oe_layer_minRange", 0.0f) );
terrainStateSet->addUniform( new osg::Uniform("oe_layer_maxRange", -1.0f) );
terrainStateSet->getOrCreateUniform(
"oe_min_tile_range_factor",
osg::Uniform::FLOAT)->set( *_terrainOptions.minTileRangeFactor() );
terrainStateSet->addUniform(new osg::Uniform("oe_tile_size", (float)_terrainOptions.tileSize().get()));
// special object ID that denotes the terrain surface.
surfaceStateSet->addUniform( new osg::Uniform(
Registry::objectIndex()->getObjectIDUniformName().c_str(), OSGEARTH_OBJECTID_TERRAIN) );
}
_stateUpdateRequired = false;
}
}