void
TerrainTileModelFactory::addColorLayers(TerrainTileModel* model,
const Map* map,
const TerrainEngineRequirements* reqs,
const TileKey& key,
const CreateTileModelFilter& filter,
ProgressCallback* progress)
{
OE_START_TIMER(fetch_image_layers);
int order = 0;
LayerVector layers;
map->getLayers(layers);
for (LayerVector::const_iterator i = layers.begin(); i != layers.end(); ++i)
{
Layer* layer = i->get();
if (layer->getRenderType() != layer->RENDERTYPE_TERRAIN_SURFACE)
continue;
if (!layer->getEnabled())
continue;
if (!filter.accept(layer))
continue;
ImageLayer* imageLayer = dynamic_cast<ImageLayer*>(layer);
if (imageLayer)
{
osg::Texture* tex = 0L;
osg::Matrixf textureMatrix;
if (imageLayer->isKeyInLegalRange(key) && imageLayer->mayHaveDataInExtent(key.getExtent()))
{
if (imageLayer->createTextureSupported())
{
tex = imageLayer->createTexture( key, progress, textureMatrix );
}
else
{
GeoImage geoImage = imageLayer->createImage( key, progress );
if ( geoImage.valid() )
{
if ( imageLayer->isCoverage() )
tex = createCoverageTexture(geoImage.getImage(), imageLayer);
else
tex = createImageTexture(geoImage.getImage(), imageLayer);
}
}
}
// if this is the first LOD, and the engine requires that the first LOD
// be populated, make an empty texture if we didn't get one.
if (tex == 0L &&
_options.firstLOD() == key.getLOD() &&
reqs && reqs->fullDataAtFirstLodRequired())
{
tex = _emptyTexture.get();
}
if (tex)
{
tex->setName(model->getKey().str());
TerrainTileImageLayerModel* layerModel = new TerrainTileImageLayerModel();
layerModel->setImageLayer(imageLayer);
layerModel->setTexture(tex);
layerModel->setMatrix(new osg::RefMatrixf(textureMatrix));
model->colorLayers().push_back(layerModel);
if (imageLayer->isShared())
{
model->sharedLayers().push_back(layerModel);
}
if (imageLayer->isDynamic())
{
model->setRequiresUpdateTraverse(true);
}
}
}
else // non-image kind of TILE layer:
{
TerrainTileColorLayerModel* colorModel = new TerrainTileColorLayerModel();
colorModel->setLayer(layer);
model->colorLayers().push_back(colorModel);
}
}
if (progress)
progress->stats()["fetch_imagery_time"] += OE_STOP_TIMER(fetch_image_layers);
}
void
RexTerrainEngineNode::addTileLayer(Layer* tileLayer)
{
if ( tileLayer && tileLayer->getEnabled() )
{
// Install the image layer stateset on this layer.
// Later we will refactor this into an ImageLayerRenderer or something similar.
//osg::StateSet* stateSet = tileLayer->getOrCreateStateSet();
//stateSet->merge(*getSurfaceStateSet());
ImageLayer* imageLayer = dynamic_cast<ImageLayer*>(tileLayer);
if (imageLayer)
{
// for a shared layer, allocate a shared image unit if necessary.
if ( imageLayer->isShared() )
{
optional<int>& unit = imageLayer->shareImageUnit();
if ( !unit.isSet() )
{
int temp;
if ( getResources()->reserveTextureImageUnit(temp) )
{
imageLayer->shareImageUnit() = temp;
OE_INFO << LC << "Image unit " << temp << " assigned to shared layer " << imageLayer->getName() << std::endl;
}
else
{
OE_WARN << LC << "Insufficient GPU image units to share layer " << imageLayer->getName() << std::endl;
}
}
// Build a sampler binding for the shared layer.
if ( unit.isSet() )
{
// Find the next empty SHARED slot:
unsigned newIndex = SamplerBinding::SHARED;
while (_renderBindings[newIndex].isActive())
++newIndex;
// Put the new binding there:
SamplerBinding& newBinding = _renderBindings[newIndex];
newBinding.usage() = SamplerBinding::SHARED;
newBinding.sourceUID() = imageLayer->getUID();
newBinding.unit() = unit.get();
newBinding.samplerName() = imageLayer->shareTexUniformName().get();
newBinding.matrixName() = imageLayer->shareTexMatUniformName().get();
OE_INFO << LC
<< " .. Sampler=\"" << newBinding.samplerName() << "\", "
<< "Matrix=\"" << newBinding.matrixName() << ", "
<< "unit=" << newBinding.unit() << "\n";
}
}
}
else
{
// non-image tile layer. Keep track of these..
}
refresh();
}
}
// Generates the main shader code for rendering the terrain.
void
MPTerrainEngineNode::updateState()
{
if ( _batchUpdateInProgress )
{
_stateUpdateRequired = true;
}
else
{
if ( _elevationTextureUnit < 0 && elevationTexturesRequired() )
{
getResources()->reserveTextureImageUnit( _elevationTextureUnit, "MP Engine Elevation" );
}
osg::StateSet* terrainStateSet = getTerrainStateSet();
if ( !terrainStateSet )
return;
// required for multipass tile rendering to work
terrainStateSet->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 shaders, if we're using them.
if ( Registry::capabilities().supportsGLSL() )
{
VirtualProgram* vp = new VirtualProgram();
vp->setName( "osgEarth.engine_mp.TerrainNode" );
terrainStateSet->setAttributeAndModes( vp, osg::StateAttribute::ON );
Shaders package;
package.replace( "$MP_PRIMARY_UNIT", Stringify() << _primaryUnit );
package.replace( "$MP_SECONDARY_UNIT", Stringify() << (_secondaryUnit>=0?_secondaryUnit:0) );
package.define( "MP_USE_BLENDING", (_terrainOptions.enableBlending() == true) );
package.load( vp, package.EngineVertexModel );
package.load( vp, package.EngineVertexView );
package.load( vp, package.EngineFragment );
if ( this->normalTexturesRequired() )
{
package.load( vp, package.NormalMapVertex );
package.load( vp, package.NormalMapFragment );
terrainStateSet->addUniform( new osg::Uniform("oe_tile_normalTex", _normalMapUnit) );
}
// terrain background color; negative means use the vertex color.
Color terrainColor = _terrainOptions.color().getOrUse( Color(1,1,1,-1) );
terrainStateSet->addUniform(new osg::Uniform("oe_terrain_color", terrainColor));
if ( _update_mapf )
{
// 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_mp_apply_filters(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.
ImageLayerVector imageLayers;
_update_mapf->getLayers(imageLayers);
bool ifStarted = false;
int numImageLayers = imageLayers.size();
for( int i=0; i<numImageLayers; ++i )
{
ImageLayer* layer = imageLayers[i].get();
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( terrainStateSet );
}
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 );
vp->setFunction(
"oe_mp_apply_filters",
fs_colorfilters,
ShaderComp::LOCATION_FRAGMENT_COLORING,
0.5f );
}
}
}
// binding for the terrain texture
terrainStateSet->getOrCreateUniform(
"oe_layer_tex", osg::Uniform::SAMPLER_2D )->set( _primaryUnit );
// binding for the secondary texture (for LOD blending)
if ( parentTexturesRequired() )
{
terrainStateSet->getOrCreateUniform(
"oe_layer_tex_parent", osg::Uniform::SAMPLER_2D )->set( _secondaryUnit );
// binding for the default secondary texture matrix
osg::Matrixf parent_mat;
parent_mat(0,0) = 0.0f;
terrainStateSet->getOrCreateUniform(
"oe_layer_parent_matrix", osg::Uniform::FLOAT_MAT4 )->set( parent_mat );
}
// uniform for accessing the elevation texture sampler.
if ( elevationTexturesRequired() )
{
terrainStateSet->getOrCreateUniform(
"oe_terrain_tex", osg::Uniform::SAMPLER_2D)->set( _elevationTextureUnit );
}
// uniform that controls per-layer opacity
terrainStateSet->getOrCreateUniform(
"oe_layer_opacity", osg::Uniform::FLOAT )->set( 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->getOrCreateUniform(
"oe_layer_uid", osg::Uniform::INT )->set( -1 );
// uniform that conveys the render order, since the shaders
// need to know which is the first layer in order to blend properly
terrainStateSet->getOrCreateUniform(
"oe_layer_order", osg::Uniform::INT )->set( 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", FLT_MAX) );
terrainStateSet->addUniform( new osg::Uniform("oe_layer_attenuationRange", _terrainOptions.attentuationDistance().get()) );
terrainStateSet->getOrCreateUniform(
"oe_min_tile_range_factor",
osg::Uniform::FLOAT)->set( *_terrainOptions.minTileRangeFactor() );
// special object ID that denotes the terrain surface.
terrainStateSet->addUniform( new osg::Uniform(
Registry::objectIndex()->getObjectIDUniformName().c_str(), OSGEARTH_OBJECTID_TERRAIN) );
// assign the uniforms for each shared layer.
if ( _update_mapf )
{
ImageLayerVector imageLayers;
_update_mapf->getLayers(imageLayers);
int numImageLayers = imageLayers.size();
for( int i=0; i<numImageLayers; ++i )
{
ImageLayer* layer = imageLayers[i].get();
if ( layer->getEnabled() && layer->isShared() )
{
terrainStateSet->addUniform( new osg::Uniform(
layer->shareTexUniformName()->c_str(),
layer->shareImageUnit().get() ) );
}
}
}
}
_stateUpdateRequired = false;
}
}
void
RexTerrainEngineNode::addTileLayer(Layer* tileLayer)
{
if ( tileLayer && tileLayer->getEnabled() )
{
ImageLayer* imageLayer = dynamic_cast<ImageLayer*>(tileLayer);
if (imageLayer)
{
// for a shared layer, allocate a shared image unit if necessary.
if ( imageLayer->isShared() )
{
if (!imageLayer->shareImageUnit().isSet())
{
int temp;
if ( getResources()->reserveTextureImageUnit(temp, imageLayer->getName().c_str()) )
{
imageLayer->shareImageUnit() = temp;
//OE_INFO << LC << "Image unit " << temp << " assigned to shared layer " << imageLayer->getName() << std::endl;
}
else
{
OE_WARN << LC << "Insufficient GPU image units to share layer " << imageLayer->getName() << std::endl;
}
}
// Build a sampler binding for the shared layer.
if ( imageLayer->shareImageUnit().isSet() )
{
// Find the next empty SHARED slot:
unsigned newIndex = SamplerBinding::SHARED;
while (_renderBindings[newIndex].isActive())
++newIndex;
// Put the new binding there:
SamplerBinding& newBinding = _renderBindings[newIndex];
newBinding.usage() = SamplerBinding::SHARED;
newBinding.sourceUID() = imageLayer->getUID();
newBinding.unit() = imageLayer->shareImageUnit().get();
newBinding.samplerName() = imageLayer->shareTexUniformName().get();
newBinding.matrixName() = imageLayer->shareTexMatUniformName().get();
OE_INFO << LC
<< "Shared Layer \"" << imageLayer->getName() << "\" : sampler=\"" << newBinding.samplerName() << "\", "
<< "matrix=\"" << newBinding.matrixName() << "\", "
<< "unit=" << newBinding.unit() << "\n";
}
}
}
else
{
// non-image tile layer. Keep track of these..
}
if (_terrain)
{
// Update the existing render models, and trigger a data reload.
// Later we can limit the reload to an update of only the new data.
UpdateRenderModels updateModels(_mapFrame);
#if 0
// This uses the loaddata filter approach which will only request
// data for one layer. It mostly works but not 100%; see hires-insets
// as an example. Removing the world layer and re-adding it while
// zoomed in doesn't result in all tiles reloading. Possibly a
// synchronization issue.
ImageLayerVector imageLayers;
_mapFrame.getLayers(imageLayers);
if (imageLayers.size() == 1)
updateModels.setReloadData(true);
else
updateModels.layersToLoad().insert(tileLayer->getUID());
#else
updateModels.setReloadData(true);
#endif
_terrain->accept(updateModels);
}
}
}