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); } } }