RexTerrainEngineNode::RexTerrainEngineNode() : TerrainEngineNode ( ), _terrain ( 0L ), _tileCount ( 0 ), _tileCreationTime ( 0.0 ), _batchUpdateInProgress( false ), _refreshRequired ( false ), _stateUpdateRequired ( false ) { // Necessary for pager object data this->setName("osgEarth.RexTerrainEngineNode"); // unique ID for this engine: _uid = Registry::instance()->createUID(); // always require elevation. _requireElevationTextures = true; // install an elevation callback so we can update elevation data _elevationCallback = new ElevationChangedCallback( this ); // static shaders. if ( Registry::capabilities().supportsGLSL() ) { osg::StateSet* stateset = getOrCreateStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); vp->setName("RexTerrainEngineNode"); vp->setIsAbstract(true); // cannot run by itself, requires additional children Shaders package; package.load(vp, package.SDK); } // TODO: replace with a "renderer" object that can return statesets // for different layer types, or something. _imageLayerStateSet = new osg::StateSet(); }
void DrawInstanced::install(osg::StateSet* stateset) { if ( !stateset ) return; // simple vertex program to position a vertex based on its instance // matrix, which is stored in a texture. std::string src_vert = Stringify() << "#version 120 \n" << "#extension GL_EXT_gpu_shader4 : enable \n" << "#extension GL_ARB_draw_instanced: enable \n" << "uniform sampler2D oe_di_postex; \n" << "uniform vec2 oe_di_postex_size; \n" << "void oe_di_setInstancePosition(inout vec4 VertexMODEL) \n" << "{ \n" << " float index = float(4 * gl_InstanceID) / oe_di_postex_size.x; \n" << " float s = fract(index); \n" << " float t = floor(index)/oe_di_postex_size.y; \n" << " float step = 1.0 / oe_di_postex_size.x; \n" // step from one vec4 to the next << " vec4 m0 = texture2D(oe_di_postex, vec2(s, t)); \n" << " vec4 m1 = texture2D(oe_di_postex, vec2(s+step, t)); \n" << " vec4 m2 = texture2D(oe_di_postex, vec2(s+step+step, t)); \n" << " vec4 m3 = texture2D(oe_di_postex, vec2(s+step+step+step, t)); \n" << " VertexMODEL = VertexMODEL * mat4(m0, m1, m2, m3); \n" // why??? << "} \n"; VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); vp->setFunction( "oe_di_setInstancePosition", src_vert, ShaderComp::LOCATION_VERTEX_MODEL ); stateset->getOrCreateUniform("oe_di_postex", osg::Uniform::SAMPLER_2D)->set(POSTEX_TEXTURE_UNIT); }
osg::Node* createMRTPass(App& app, osg::Node* sceneGraph) { osg::Camera* rtt = new osg::Camera(); rtt->setRenderOrder(osg::Camera::PRE_RENDER); rtt->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); rtt->setViewport(0, 0, app.gcolor->getTextureWidth(), app.gcolor->getTextureHeight()); rtt->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); rtt->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER0), app.gcolor); rtt->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER1), app.gnormal); rtt->attach(osg::Camera::BufferComponent(osg::Camera::COLOR_BUFFER2), app.gdepth); static const char* vertSource = "varying float mrt_depth;\n" "void oe_mrt_vertex(inout vec4 vertexClip)\n" "{\n" " mrt_depth = (vertexClip.z/vertexClip.w)*0.5+1.0;\n" "}\n"; static const char* fragSource = "varying float mrt_depth;\n" "vec3 oe_global_Normal; \n" "void oe_mrt_fragment(inout vec4 color)\n" "{\n" " gl_FragData[0] = color; \n" " gl_FragData[1] = vec4((oe_global_Normal+1.0)/2.0,1.0);\n" " gl_FragData[2] = vec4(mrt_depth,mrt_depth,mrt_depth,1.0); \n" "}\n"; VirtualProgram* vp = VirtualProgram::getOrCreate( rtt->getOrCreateStateSet() ); vp->setFunction( "oe_mrt_vertex", vertSource, ShaderComp::LOCATION_VERTEX_CLIP ); vp->setFunction( "oe_mrt_fragment", fragSource, ShaderComp::LOCATION_FRAGMENT_OUTPUT ); rtt->addChild( sceneGraph ); return rtt; }
void DepthOffsetAdapter::setGraph(osg::Node* graph) { if ( !_supported ) return; bool graphChanging = _graph.get() != graph; bool uninstall = (_graph.valid() && _graph->getStateSet()) && (graphChanging || (_options.enabled() == false)); bool install = (graph && graphChanging ) || (graph && (_options.enabled() == true)); if ( uninstall ) { OE_TEST << LC << "Removing depth offset shaders" << std::endl; // uninstall uniforms and shaders. osg::StateSet* s = _graph->getStateSet(); s->removeUniform( _biasUniform.get() ); s->removeUniform( _rangeUniform.get() ); VirtualProgram* vp = VirtualProgram::get( s ); if ( vp ) { vp->removeShader( "oe_doff_vertex" ); vp->removeShader( "oe_doff_fragment" ); } } if ( install ) { OE_TEST << LC << "Installing depth offset shaders" << std::endl; // install uniforms and shaders. osg::StateSet* s = graph->getOrCreateStateSet(); s->addUniform( _biasUniform.get() ); s->addUniform( _rangeUniform.get() ); VirtualProgram* vp = VirtualProgram::getOrCreate( s ); vp->setFunction( "oe_doff_vertex", s_vertex, ShaderComp::LOCATION_VERTEX_VIEW ); vp->setFunction( "oe_doff_fragment", s_fragment, ShaderComp::LOCATION_FRAGMENT_COLORING ); s->setAttributeAndModes( vp, osg::StateAttribute::ON ); } if ( graphChanging ) { _graph = graph; } // always set Dirty when setGraph is called sine it may be called anytime // the subgraph changes (as can be detected by a computeBound) _dirty = (_options.automatic() == true); }
void SimpleOceanNode::rebuild() { this->removeChildren( 0, this->getNumChildren() ); osg::ref_ptr<MapNode> mapNode; if (_parentMapNode.lock(mapNode)) { const MapOptions& parentMapOptions = mapNode->getMap()->getMapOptions(); const MapNodeOptions& parentMapNodeOptions = mapNode->getMapNodeOptions(); // set up the map to "match" the parent map: MapOptions mo; mo.coordSysType() = parentMapOptions.coordSysType(); mo.profile() = mapNode->getMap()->getProfile()->toProfileOptions(); // new data model for the ocean: Map* oceanMap = new Map( mo ); // ditto with the map node options: MapNodeOptions mno; if ( mno.enableLighting().isSet() ) mno.enableLighting() = *mno.enableLighting(); RexTerrainEngineOptions terrainoptions; terrainoptions.enableBlending() = true; // gotsta blend with the main node terrainoptions.color() = baseColor().get(); terrainoptions.tileSize() = 5; mno.setTerrainOptions( terrainoptions ); // make the ocean's map node: MapNode* oceanMapNode = new MapNode( oceanMap, mno ); // set up the shaders. osg::StateSet* ss = this->getOrCreateStateSet(); // if the caller requested a mask layer, install that now. if ( maskLayer().isSet() ) { if ( !maskLayer()->maxLevel().isSet() ) { // set the max subdivision level if it's not already specified in the // mask layer options: maskLayer()->maxLevel() = maxLOD().get(); } // make sure the mask is shared (so we can access it from our shader) // and invisible (so we can't see it) maskLayer()->shared() = true; maskLayer()->visible() = false; ImageLayer* layer = new ImageLayer("ocean-mask", maskLayer().get()); oceanMap->addLayer( layer ); ss->setDefine("OE_SIMPLE_OCEAN_USE_MASK"); OE_INFO << LC << "Using mask layer \"" << layer->getName() << "\"\n"; } // otherwise, install a "proxy layer" that will use the elevation data in the map // to determine where the ocean is. This approach is limited in that it cannot // detect the difference between ocean and inland areas that are below sea level. else { // install an "elevation proxy" layer that reads elevation tiles from the // parent map and turns them into encoded images for our shader to use. ImageLayerOptions epo( "ocean-proxy" ); epo.cachePolicy() = CachePolicy::NO_CACHE; epo.shared() = true; epo.visible() = false; epo.shareTexUniformName() = "oe_ocean_proxyTex"; epo.shareTexMatUniformName() = "oe_ocean_proxyMat"; oceanMap->addLayer( new ElevationProxyImageLayer(mapNode->getMap(), epo) ); OE_INFO << LC << "Using elevation proxy layer\n"; } this->addChild( oceanMapNode ); // install the shaders on the ocean map node. VirtualProgram* vp = VirtualProgram::getOrCreate( ss ); vp->setName( "osgEarth SimpleOcean" ); Shaders shaders; shaders.loadAll(vp, 0L); // set up the options uniforms. _seaLevel = new osg::Uniform(osg::Uniform::FLOAT, "ocean_seaLevel"); ss->addUniform( _seaLevel.get() ); _lowFeather = new osg::Uniform(osg::Uniform::FLOAT, "ocean_lowFeather"); ss->addUniform( _lowFeather.get() ); _highFeather = new osg::Uniform(osg::Uniform::FLOAT, "ocean_highFeather"); ss->addUniform( _highFeather.get() ); _baseColor = new osg::Uniform(osg::Uniform::FLOAT_VEC4, "ocean_baseColor"); ss->addUniform( _baseColor.get() ); _maxRange = new osg::Uniform(osg::Uniform::FLOAT, "ocean_max_range"); ss->addUniform( _maxRange.get() ); _fadeRange = new osg::Uniform(osg::Uniform::FLOAT, "ocean_fade_range"); ss->addUniform( _fadeRange.get() ); _alphaUniform = new osg::Uniform(osg::Uniform::FLOAT, "oe_ocean_alpha"); ss->addUniform( _alphaUniform.get() ); // disable depth writes. ss->setAttributeAndModes( new osg::Depth(osg::Depth::LEQUAL, 0.0, 1.0, false) ); // load up a surface texture osg::ref_ptr<osg::Image> surfaceImage; if ( textureURI().isSet() ) { surfaceImage = textureURI()->getImage(); } //if ( !surfaceImage.valid() ) //{ // surfaceImage = createSurfaceImage(); //} if ( surfaceImage.valid() ) { osg::Texture2D* tex = new osg::Texture2D( surfaceImage.get() ); tex->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR ); tex->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); tex->setWrap ( osg::Texture::WRAP_S, osg::Texture::REPEAT ); tex->setWrap ( osg::Texture::WRAP_T, osg::Texture::REPEAT ); ss->setTextureAttributeAndModes( 5, tex, 1 ); ss->getOrCreateUniform( "ocean_surface_tex", osg::Uniform::SAMPLER_2D )->set( 5 ); ss->setDefine("OE_SIMPLE_OCEAN_USE_TEXTURE"); OE_INFO << LC << "Using a surface texture (" << surfaceImage->getFileName() << ")\n"; } // remove backface culling so we can see underwater // (use OVERRIDE since the terrain engine sets back face culling.) ss->setAttributeAndModes( new osg::CullFace(), osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE ); // Material. osg::Material* m = new osgEarth::MaterialGL3(); m->setAmbient(m->FRONT_AND_BACK, osg::Vec4(.5,.5,.5,1)); m->setDiffuse(m->FRONT_AND_BACK, osg::Vec4(1,1,1,1)); m->setSpecular(m->FRONT_AND_BACK, osg::Vec4(0.2,0.2,0.2,1)); m->setEmission(m->FRONT_AND_BACK, osg::Vec4(0,0,0,1)); m->setShininess(m->FRONT_AND_BACK, 40.0); ss->setAttributeAndModes(m, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE ); // force apply options: applyOptions(); } }
osg::Node* run(osg::Node* earthfile) { // 32-bit vertex shader, for reference only. This shader will exceed // the single-precision capacity and cause "jumping verts" at the // camera make small movements. const char* vs32 = "#version 330 \n" "uniform mat4 osg_ViewMatrixInverse; \n" "flat out float isRed; \n" "void vertex(inout vec4 v32) \n" "{ \n" " vec4 world = osg_ViewMatrixInverse * v32; \n" " world /= world.w; \n" " float len = length(world); \n" " const float R = 6371234.5678; \n" " isRed = 0.0; \n" " if (len > R) \n" " isRed = 1.0;" "}\n"; // 64-bit vertex shader. This shader uses a double-precision inverse // view matrix and calculates the altitude all in double precision; // therefore the "jumping verts" problem in the 32-bit version is // resolved. (Mostly-- you will still see the jumping if you view the // earth from orbit, because the 32-bit vertex itself is very far from // the camera in view coordinates. If that is an issue, you need to pass // in 64-bit vertex attributes.) const char* vs64 = "#version 330 \n" "#extension GL_ARB_gpu_shader_fp64 : enable \n" "uniform dmat4 u_ViewMatrixInverse64; \n" // must use a 64-bit VMI. "flat out float isRed; \n" "flat out double vary64; \n" // just to test shadercomp framework "void vertex(inout vec4 v32) \n" "{ \n" " dvec4 v64 = dvec4(v32); \n" // upcast to 64-bit, no precision loss // unless camera is very far away " dvec4 world = u_ViewMatrixInverse64 * v64; \n" // xform into world coords " world /= world.w; \n" // divide by w " double len = length(world.xyz); \n" // get double-precision vector length. " const double R = 6371234.5678; \n" // arbitrary earth radius threshold " isRed = (len > R) ? 1.0 : 0.0; \n" "}\n"; // frag shader: color the terrain red if the incoming varying is non-zero. const char* fs = "#version 330 \n" "#extension GL_ARB_gpu_shader_fp64 : enable \n" "flat in float isRed; \n" "flat in double vary64; \n" "void fragment(inout vec4 color) \n" "{ \n" " if (isRed > 0.0f) { \n" " color.r = 1.0; \n" " color.gb *= 0.5; \n" " } \n" "} \n"; // installs a double-precision inverse view matrix for our shader to use. struct VMI64Callback : public osg::NodeCallback { void operator()(osg::Node* node, osg::NodeVisitor* nv) { osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv); osg::Uniform* u = new osg::Uniform(osg::Uniform::DOUBLE_MAT4, "u_ViewMatrixInverse64"); u->set(cv->getCurrentCamera()->getInverseViewMatrix()); osg::ref_ptr<osg::StateSet> ss = new osg::StateSet(); ss->addUniform(u); cv->pushStateSet(ss.get()); traverse(node, nv); cv->popStateSet(); } }; earthfile->setCullCallback(new VMI64Callback()); osg::StateSet* ss = earthfile->getOrCreateStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(ss); vp->setFunction("vertex", vs64, ShaderComp::LOCATION_VERTEX_VIEW); vp->setFunction("fragment", fs, ShaderComp::LOCATION_FRAGMENT_COLORING); return earthfile; }
// 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; } }
void ClampingTechnique::setUpCamera(OverlayDecorator::TechRTTParams& params) { // To store technique-specific per-view info: LocalPerViewData* local = new LocalPerViewData(); params._techniqueData = local; // create the projected texture: local->_rttTexture = new osg::Texture2D(); local->_rttTexture->setTextureSize( *_textureSize, *_textureSize ); local->_rttTexture->setInternalFormat( GL_DEPTH_COMPONENT ); local->_rttTexture->setFilter( osg::Texture::MIN_FILTER, osg::Texture::NEAREST ); local->_rttTexture->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); // this is important. geometry that is outside the depth texture will clamp to the // closest edge value in the texture -- this is good when you are rendering a // primitive that has one or more of its verts off-screen. local->_rttTexture->setWrap( osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE ); local->_rttTexture->setWrap( osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE ); //local->_rttTexture->setBorderColor( osg::Vec4(0,0,0,1) ); // set up the RTT camera: params._rttCamera = new osg::Camera(); params._rttCamera->setReferenceFrame( osg::Camera::ABSOLUTE_RF_INHERIT_VIEWPOINT ); params._rttCamera->setClearDepth( 1.0 ); params._rttCamera->setClearMask( GL_DEPTH_BUFFER_BIT ); params._rttCamera->setComputeNearFarMode( osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR ); params._rttCamera->setViewport( 0, 0, *_textureSize, *_textureSize ); params._rttCamera->setRenderOrder( osg::Camera::PRE_RENDER ); params._rttCamera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT ); params._rttCamera->setImplicitBufferAttachmentMask(0, 0); params._rttCamera->attach( osg::Camera::DEPTH_BUFFER, local->_rttTexture.get() ); #ifdef DUMP_RTT_IMAGE local->_rttDebugImage = new osg::Image(); local->_rttDebugImage->allocateImage(4096, 4096, 1, GL_RGB, GL_UNSIGNED_BYTE); memset( (void*)local->_rttDebugImage->getDataPointer(), 0xff, local->_rttDebugImage->getTotalSizeInBytes() ); params._rttCamera->attach( osg::Camera::COLOR_BUFFER, local->_rttDebugImage.get() ); params._rttCamera->setFinalDrawCallback( new DumpTex(local->_rttDebugImage.get()) ); #endif #ifdef TIME_RTT_CAMERA params._rttCamera->setInitialDrawCallback( new RttIn() ); params._rttCamera->setFinalDrawCallback( new RttOut() ); #endif // set up a StateSet for the RTT camera. osg::StateSet* rttStateSet = params._rttCamera->getOrCreateStateSet(); rttStateSet->setMode( GL_BLEND, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE); // prevents wireframe mode in the depth camera. rttStateSet->setAttributeAndModes( new osg::PolygonMode( osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::FILL ), osg::StateAttribute::ON | osg::StateAttribute::PROTECTED ); // attach the terrain to the camera. // todo: should probably protect this with a mutex..... params._rttCamera->addChild( _engine ); // the terrain itself. // assemble the overlay graph stateset. local->_groupStateSet = new osg::StateSet(); // Required for now, otherwise GPU-clamped geometry will jitter sometimes. // TODO: figure out why and fix it. This is a workaround for now. local->_groupStateSet->setDataVariance( osg::Object::DYNAMIC ); local->_groupStateSet->setTextureAttributeAndModes( _textureUnit, local->_rttTexture.get(), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE ); // set up depth test/write parameters for the overlay geometry: local->_groupStateSet->setAttributeAndModes( new osg::Depth( osg::Depth::LEQUAL, 0.0, 1.0, true ), osg::StateAttribute::ON ); local->_groupStateSet->setRenderingHint( osg::StateSet::TRANSPARENT_BIN ); // uniform for the horizon distance (== max clamping distance) local->_horizonDistanceUniform = local->_groupStateSet->getOrCreateUniform( "oe_clamp_horizonDistance", osg::Uniform::FLOAT ); // sampler for depth map texture: local->_groupStateSet->getOrCreateUniform( "oe_clamp_depthTex", osg::Uniform::SAMPLER_2D )->set( _textureUnit ); // matrix that transforms a vert from EYE coords to the depth camera's CLIP coord. local->_camViewToDepthClipUniform = local->_groupStateSet->getOrCreateUniform( "oe_clamp_cameraView2depthClip", osg::Uniform::FLOAT_MAT4 ); #ifdef SUPPORT_Z // matrix that transforms a vert from depth clip coords to depth view coords. local->_depthClipToDepthViewUniform = local->_groupStateSet->getOrCreateUniform( "oe_clamp_depthClip2depthView", osg::Uniform::FLOAT_MAT4 ); // matrix that transforms a vert from depth view coords to camera view coords. local->_depthViewToCamViewUniform = local->_groupStateSet->getOrCreateUniform( "oe_clamp_depthView2cameraView", osg::Uniform::FLOAT_MAT4 ); #else // matrix that transforms a vert from depth-cam CLIP coords to EYE coords. local->_depthClipToCamViewUniform = local->_groupStateSet->getOrCreateUniform( "oe_clamp_depthClip2cameraView", osg::Uniform::FLOAT_MAT4 ); #endif // make the shader that will do clamping and depth offsetting. VirtualProgram* vp = VirtualProgram::getOrCreate(local->_groupStateSet.get()); vp->setName( "ClampingTechnique" ); vp->setFunction( "oe_clamp_vertex", clampingVertexShader, ShaderComp::LOCATION_VERTEX_VIEW ); vp->setFunction( "oe_clamp_fragment", clampingFragmentShader, ShaderComp::LOCATION_FRAGMENT_COLORING ); }
// Generates the main shader code for rendering the terrain. void MPTerrainEngineNode::updateState() { if ( _batchUpdateInProgress ) { _stateUpdateRequired = true; } else { osg::StateSet* terrainStateSet = _terrain->getOrCreateStateSet(); // 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 ); // bind the vertex attributes generated by the tile compiler. vp->addBindAttribLocation( "oe_terrain_attr", osg::Drawable::ATTRIBUTE_6 ); vp->addBindAttribLocation( "oe_terrain_attr2", osg::Drawable::ATTRIBUTE_7 ); // Vertex shader: std::string vs = Stringify() << "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "varying vec4 oe_layer_texc;\n" "varying vec4 oe_layer_tilec;\n" "void oe_mp_setup_coloring(inout vec4 VertexModel) \n" "{ \n" " oe_layer_texc = gl_MultiTexCoord" << _primaryUnit << ";\n" " oe_layer_tilec = gl_MultiTexCoord" << _secondaryUnit << ";\n" "}\n"; bool useTerrainColor = _terrainOptions.color().isSet(); bool useBlending = _terrainOptions.enableBlending() == true; // Fragment Shader for normal blending: std::string fs = Stringify() << "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "varying vec4 oe_layer_texc; \n" "uniform sampler2D oe_layer_tex; \n" "uniform int oe_layer_uid; \n" "uniform int oe_layer_order; \n" "uniform float oe_layer_opacity; \n" << (useTerrainColor ? "uniform vec4 oe_terrain_color; \n" : "" ) << "void oe_mp_apply_coloring(inout vec4 color) \n" "{ \n" << (useTerrainColor ? " color = oe_terrain_color; \n" : "" ) << //" color = vec4(1,1,1,1); \n" " vec4 texel; \n" " if ( oe_layer_uid >= 0 ) { \n" " texel = texture2D(oe_layer_tex, oe_layer_texc.st); \n" " texel.a *= oe_layer_opacity; \n" " } \n" " else \n" " texel = color; \n" " " << (useBlending ? " if ( oe_layer_order == 0 ) \n" " color = texel*texel.a + color*(1.0-texel.a); \n" // simulate src_alpha, 1-src_alpha blens " else \n" : "" ) << " color = texel; \n" "} \n"; // 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"; vp->setFunction( "oe_mp_setup_coloring", vs, ShaderComp::LOCATION_VERTEX_MODEL, 0.0 ); vp->setFunction( "oe_mp_apply_coloring", fs, ShaderComp::LOCATION_FRAGMENT_COLORING, 0.0 ); // assemble color filter code snippets. bool haveColorFilters = false; { 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( 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.0 ); } } // binding for the terrain texture terrainStateSet->getOrCreateUniform( "oe_layer_tex", osg::Uniform::SAMPLER_2D )->set( _primaryUnit ); // binding for the secondary texture (for LOD blending) 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 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 ); // base terrain color. if ( useTerrainColor ) { terrainStateSet->getOrCreateUniform( "oe_terrain_color", osg::Uniform::FLOAT_VEC4 )->set( *_terrainOptions.color() ); } } _stateUpdateRequired = false; } }
bool BillboardExtension::connect(MapNode* mapNode) { if ( !mapNode ) { OE_WARN << LC << "Illegal: MapNode cannot be null." << std::endl; return false; } OE_INFO << LC << "Connecting to MapNode.\n"; if ( !_options.imageURI().isSet() ) { OE_WARN << LC << "Illegal: image URI is required" << std::endl; return false; } if ( !_options.featureOptions().isSet() ) { OE_WARN << LC << "Illegal: feature source is required" << std::endl; return false; } _features = FeatureSourceFactory::create( _options.featureOptions().value() ); if ( !_features.valid() ) { OE_WARN << LC << "Illegal: no valid feature source provided" << std::endl; return false; } //if ( _features->getGeometryType() != osgEarth::Symbology::Geometry::TYPE_POINTSET ) //{ // OE_WARN << LC << "Illegal: only points currently supported" << std::endl; // return false; //} _features->initialize( _dbOptions ); osg::Vec3dArray* verts; if ( _features->getFeatureProfile() ) { verts = new osg::Vec3dArray(); OE_NOTICE << "Reading features...\n"; osg::ref_ptr<FeatureCursor> cursor = _features->createFeatureCursor(); while ( cursor.valid() && cursor->hasMore() ) { Feature* f = cursor->nextFeature(); if ( f && f->getGeometry() ) { if ( f->getGeometry()->getComponentType() == Geometry::TYPE_POLYGON ) { FilterContext cx; cx.setProfile( new FeatureProfile(_features->getFeatureProfile()->getExtent()) ); ScatterFilter scatter; scatter.setDensity( _options.density().get() ); scatter.setRandom( true ); FeatureList featureList; featureList.push_back(f); scatter.push( featureList, cx ); } // Init a filter to tranform feature in desired SRS if (!mapNode->getMapSRS()->isEquivalentTo(_features->getFeatureProfile()->getSRS())) { FilterContext cx; cx.setProfile( new FeatureProfile(_features->getFeatureProfile()->getExtent()) ); TransformFilter xform( mapNode->getMapSRS() ); FeatureList featureList; featureList.push_back(f); cx = xform.push(featureList, cx); } GeometryIterator iter(f->getGeometry()); while(iter.hasMore()) { const Geometry* geom = iter.next(); osg::ref_ptr<osg::Vec3dArray> fVerts = geom->createVec3dArray(); verts->insert(verts->end(), fVerts->begin(), fVerts->end()); } } } } else { OE_WARN << LC << "Illegal: feature source has no SRS" << std::endl; return false; } if ( verts && verts->size() > 0 ) { OE_NOTICE << LC << "Read " << verts->size() << " points.\n"; //localize all the verts GeoPoint centroid; _features->getFeatureProfile()->getExtent().getCentroid(centroid); centroid = centroid.transform(mapNode->getMapSRS()); OE_NOTICE << "Centroid = " << centroid.x() << ", " << centroid.y() << "\n"; osg::Matrixd l2w, w2l; centroid.createLocalToWorld(l2w); w2l.invert(l2w); osg::MatrixTransform* mt = new osg::MatrixTransform; mt->setMatrix(l2w); OE_NOTICE << "Clamping elevations...\n"; osgEarth::ElevationQuery eq(mapNode->getMap()); eq.setFallBackOnNoData( true ); eq.getElevations(verts->asVector(), mapNode->getMapSRS(), true, 0.005); OE_NOTICE << "Building geometry...\n"; osg::Vec3Array* normals = new osg::Vec3Array(verts->size()); osg::Vec4Array* colors = new osg::Vec4Array(verts->size()); Random rng; for (int i=0; i < verts->size(); i++) { GeoPoint vert(mapNode->getMapSRS(), (*verts)[i], osgEarth::ALTMODE_ABSOLUTE); osg::Vec3d world; vert.toWorld(world); (*verts)[i] = world * w2l; osg::Vec3 normal = world; normal.normalize(); (*normals)[i] = osg::Matrix::transform3x3(normal, w2l); double n = rng.next(); (*colors)[i].set( n, n, n, 1 ); } //create geom and primitive sets osg::Geometry* geometry = new osg::Geometry(); geometry->setVertexArray( verts ); geometry->setNormalArray( normals ); geometry->setNormalBinding( osg::Geometry::BIND_PER_VERTEX ); geometry->setColorArray(colors); geometry->setColorBinding( osg::Geometry::BIND_PER_VERTEX ); geometry->addPrimitiveSet( new osg::DrawArrays( GL_POINTS, 0, verts->size() ) ); //create image and texture to render to osg::Texture2D* tex = new osg::Texture2D(_options.imageURI()->getImage(_dbOptions)); tex->setResizeNonPowerOfTwoHint(false); tex->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR ); tex->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); tex->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE); tex->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE); geometry->setName("BillboardPoints"); osg::Geode* geode = new osg::Geode; geode->addDrawable(geometry); //osg::ref_ptr<StateSetCache> cache = new StateSetCache(); //Registry::shaderGenerator().run(geode, cache.get()); //set the texture related uniforms osg::StateSet* geode_ss = geode->getOrCreateStateSet(); geode_ss->setTextureAttributeAndModes( 2, tex, 1 ); geode_ss->getOrCreateUniform("billboard_tex", osg::Uniform::SAMPLER_2D)->set( 2 ); float bbWidth = (float)tex->getImage()->s() / 2.0f; float bbHeight = (float)tex->getImage()->t(); float aspect = (float)tex->getImage()->s() / (float)tex->getImage()->t(); if (_options.height().isSet()) { bbHeight = _options.height().get(); if (!_options.width().isSet()) { bbWidth = bbHeight * aspect / 2.0f; } } if (_options.width().isSet()) { bbWidth = _options.width().get() / 2.0f; if (!_options.height().isSet()) { bbHeight = _options.width().get() / aspect; } } geode_ss->getOrCreateUniform("billboard_width", osg::Uniform::FLOAT)->set( bbWidth ); geode_ss->getOrCreateUniform("billboard_height", osg::Uniform::FLOAT)->set( bbHeight ); geode_ss->setMode(GL_BLEND, osg::StateAttribute::ON); //for now just using an osg::Program //TODO: need to add GeometryShader support to the shader comp setup VirtualProgram* vp = VirtualProgram::getOrCreate(geode_ss); vp->setName( "osgEarth Billboard Extension" ); ShaderPackage shaders; shaders.add( "Billboard geometry shader", billboardGeomShader ); shaders.add( "Billboard fragment shader", billboardFragShader ); shaders.loadAll( vp ); geode_ss->setMode( GL_CULL_FACE, osg::StateAttribute::OFF ); geode->setCullingActive(false); mt->addChild(geode); mapNode->getModelLayerGroup()->addChild(mt); return true; } return false; }
void SimpleOceanNode::rebuild() { this->removeChildren( 0, this->getNumChildren() ); if ( _parentMapNode.valid() ) { const MapOptions& parentMapOptions = _parentMapNode->getMap()->getMapOptions(); const MapNodeOptions& parentMapNodeOptions = _parentMapNode->getMapNodeOptions(); // set up the map to "match" the parent map: MapOptions mo; mo.coordSysType() = parentMapOptions.coordSysType(); mo.profile() = _parentMapNode->getMap()->getProfile()->toProfileOptions(); // new data model for the ocean: Map* oceanMap = new Map( mo ); // ditto with the map node options: MapNodeOptions mno; if ( mno.enableLighting().isSet() ) mno.enableLighting() = *mno.enableLighting(); MPTerrainEngineOptions mpoptions; mpoptions.heightFieldSkirtRatio() = 0.0; // don't want to see skirts mpoptions.minLOD() = _options.maxLOD().get(); // weird, I know // so we can the surface from underwater: mpoptions.clusterCulling() = false; // want to see underwater mpoptions.enableBlending() = true; // gotsta blend with the main node mpoptions.color() = _options.baseColor().get(); mno.setTerrainOptions( mpoptions ); // make the ocean's map node: MapNode* oceanMapNode = new MapNode( oceanMap, mno ); // if the caller requested a mask layer, install that now. if ( _options.maskLayer().isSet() ) { if ( !_options.maskLayer()->maxLevel().isSet() ) { // set the max subdivision level if it's not already specified in the // mask layer options: _options.maskLayer()->maxLevel() = *_options.maxLOD(); } // make sure the mask is shared (so we can access it from our shader) // and invisible (so we can't see it) _options.maskLayer()->shared() = true; _options.maskLayer()->visible() = false; ImageLayer* maskLayer = new ImageLayer( "ocean-mask", *_options.maskLayer() ); oceanMap->addImageLayer( maskLayer ); } // otherwise, install a "proxy layer" that will use the elevation data in the map // to determine where the ocean is. This approach is limited in that it cannot // detect the difference between ocean and inland areas that are below sea level. else { // install an "elevation proxy" layer that reads elevation tiles from the // parent map and turns them into encoded images for our shader to use. ImageLayerOptions epo( "ocean-proxy" ); epo.cachePolicy() = CachePolicy::NO_CACHE; //epo.maxLevel() = *_options.maxLOD(); oceanMap->addImageLayer( new ElevationProxyImageLayer(_parentMapNode->getMap(), epo) ); } this->addChild( oceanMapNode ); // set up the shaders. osg::StateSet* ss = this->getOrCreateStateSet(); // install the shaders on the ocean map node. VirtualProgram* vp = VirtualProgram::getOrCreate( ss ); vp->setName( "osgEarth SimpleOcean" ); // use the appropriate shader for the active technique: std::string vertSource = _options.maskLayer().isSet() ? source_vertMask : source_vertProxy; std::string fragSource = _options.maskLayer().isSet() ? source_fragMask : source_fragProxy; vp->setFunction( "oe_ocean_vertex", vertSource, ShaderComp::LOCATION_VERTEX_VIEW ); vp->setFunction( "oe_ocean_fragment", fragSource, ShaderComp::LOCATION_FRAGMENT_COLORING, 0.6f ); // install the slot attribute(s) ss->getOrCreateUniform( "ocean_data", osg::Uniform::SAMPLER_2D )->set( 0 ); // set up the options uniforms. _seaLevel = new osg::Uniform(osg::Uniform::FLOAT, "ocean_seaLevel"); ss->addUniform( _seaLevel.get() ); _lowFeather = new osg::Uniform(osg::Uniform::FLOAT, "ocean_lowFeather"); ss->addUniform( _lowFeather.get() ); _highFeather = new osg::Uniform(osg::Uniform::FLOAT, "ocean_highFeather"); ss->addUniform( _highFeather.get() ); _baseColor = new osg::Uniform(osg::Uniform::FLOAT_VEC4, "ocean_baseColor"); ss->addUniform( _baseColor.get() ); _maxRange = new osg::Uniform(osg::Uniform::FLOAT, "ocean_max_range"); ss->addUniform( _maxRange.get() ); _fadeRange = new osg::Uniform(osg::Uniform::FLOAT, "ocean_fade_range"); ss->addUniform( _fadeRange.get() ); // trick to mitigate z-fighting.. ss->setAttributeAndModes( new osg::Depth(osg::Depth::LEQUAL, 0.0, 1.0, false) ); ss->setRenderingHint( osg::StateSet::TRANSPARENT_BIN ); // load up a surface texture osg::ref_ptr<osg::Image> surfaceImage; ss->getOrCreateUniform( "ocean_has_surface_tex", osg::Uniform::BOOL )->set( false ); if ( _options.textureURI().isSet() ) { //TODO: enable cache support here? surfaceImage = _options.textureURI()->getImage(); } if ( !surfaceImage.valid() ) { surfaceImage = createSurfaceImage(); } if ( surfaceImage.valid() ) { osg::Texture2D* tex = new osg::Texture2D( surfaceImage.get() ); tex->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR ); tex->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); tex->setWrap ( osg::Texture::WRAP_S, osg::Texture::REPEAT ); tex->setWrap ( osg::Texture::WRAP_T, osg::Texture::REPEAT ); ss->setTextureAttributeAndModes( 2, tex, 1 ); ss->getOrCreateUniform( "ocean_surface_tex", osg::Uniform::SAMPLER_2D )->set( 2 ); ss->getOrCreateUniform( "ocean_has_surface_tex", osg::Uniform::BOOL )->set( true ); } // remove backface culling so we can see underwater // (use OVERRIDE since the terrain engine sets back face culling.) ss->setAttributeAndModes( new osg::CullFace(), osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE ); // Material. osg::Material* m = new osg::Material(); m->setAmbient(m->FRONT_AND_BACK, osg::Vec4(0,0,0,1)); m->setDiffuse(m->FRONT_AND_BACK, osg::Vec4(1,1,1,1)); m->setSpecular(m->FRONT_AND_BACK, osg::Vec4(0.1,0.1,0.1,1)); m->setEmission(m->FRONT_AND_BACK, osg::Vec4(0,0,0,1)); m->setShininess(m->FRONT_AND_BACK, 32.0); ss->setAttributeAndModes(m, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE ); // force apply options: applyOptions(); } }
void GroundCoverLayer::buildStateSets() { // assert we have the necessary TIUs: if (_groundCoverTexBinding.valid() == false) { OE_DEBUG << LC << "buildStateSets deferred.. bindings not reserved\n"; return; } if (!_zonesConfigured) { OE_DEBUG << LC << "buildStateSets deferred.. zones not yet configured\n"; return; } osg::ref_ptr<LandCoverDictionary> landCoverDict; if (_landCoverDict.lock(landCoverDict) == false) { OE_DEBUG << LC << "buildStateSets deferred.. land cover dictionary not available\n"; return; } osg::ref_ptr<LandCoverLayer> landCoverLayer; if (_landCoverLayer.lock(landCoverLayer) == false) { OE_DEBUG << LC << "buildStateSets deferred.. land cover layer not available\n"; return; } NoiseTextureFactory noise; osg::ref_ptr<osg::Texture> noiseTexture = noise.create(256u, 4u); GroundCoverShaders shaders; // Layer-wide stateset: osg::StateSet* stateset = getOrCreateStateSet(); // bind the noise sampler. stateset->setTextureAttribute(_noiseBinding.unit(), noiseTexture.get()); stateset->addUniform(new osg::Uniform(NOISE_SAMPLER, _noiseBinding.unit())); if (_maskLayer.valid()) { stateset->setDefine("OE_GROUNDCOVER_MASK_SAMPLER", _maskLayer->shareTexUniformName().get()); stateset->setDefine("OE_GROUNDCOVER_MASK_MATRIX", _maskLayer->shareTexMatUniformName().get()); } // disable backface culling to support shadow/depth cameras, // for which the geometry shader renders cross hatches instead of billboards. stateset->setMode(GL_CULL_FACE, osg::StateAttribute::PROTECTED); // enable alpha-to-coverage multisampling for vegetation. stateset->setMode(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB, 1); // uniform that communicates the availability of multisampling. if (osg::DisplaySettings::instance()->getMultiSamples()) { stateset->setDefine("OE_GROUNDCOVER_HAS_MULTISAMPLES"); } stateset->setAttributeAndModes( new osg::BlendFunc(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO), osg::StateAttribute::OVERRIDE); for (Zones::iterator z = _zones.begin(); z != _zones.end(); ++z) { Zone* zone = z->get(); GroundCover* groundCover = zone->getGroundCover(); if (groundCover) { if (!groundCover->getBiomes().empty() || groundCover->getTotalNumBillboards() > 0) { osg::StateSet* zoneStateSet = groundCover->getOrCreateStateSet(); // Install the land cover shaders on the state set VirtualProgram* vp = VirtualProgram::getOrCreate(zoneStateSet); vp->setName("Ground cover (" + groundCover->getName() + ")"); shaders.loadAll(vp, getReadOptions()); // Generate the coverage acceptor shader osg::Shader* covTest = groundCover->createPredicateShader(_landCoverDict.get(), _landCoverLayer.get()); covTest->setName(covTest->getName() + "_GEOMETRY"); covTest->setType(osg::Shader::GEOMETRY); vp->setShader(covTest); osg::Shader* covTest2 = groundCover->createPredicateShader(_landCoverDict.get(), _landCoverLayer.get()); covTest->setName(covTest->getName() + "_TESSCONTROL"); covTest2->setType(osg::Shader::TESSCONTROL); vp->setShader(covTest2); osg::ref_ptr<osg::Shader> layerShader = groundCover->createShader(); layerShader->setType(osg::Shader::GEOMETRY); vp->setShader(layerShader.get()); OE_INFO << LC << "Established zone \"" << zone->getName() << "\" at LOD " << getLOD() << "\n"; osg::Texture* tex = groundCover->createTexture(); zoneStateSet->setTextureAttribute(_groundCoverTexBinding.unit(), tex); zoneStateSet->addUniform(new osg::Uniform(GCTEX_SAMPLER, _groundCoverTexBinding.unit())); OE_DEBUG << LC << "buildStateSets completed!\n"; } else { OE_WARN << LC << "ILLEGAL: ground cover layer with no biomes or no billboards defined\n"; } } else { // not an error. OE_DEBUG << LC << "zone contains no ground cover information\n"; } } }
osg::Node* ExtrudeGeometryFilter::push( FeatureList& input, FilterContext& context ) { reset( context ); // minimally, we require an extrusion symbol. if ( !_extrusionSymbol.valid() ) { OE_WARN << LC << "Missing required extrusion symbolology; geometry will be empty" << std::endl; return new osg::Group(); } // establish the active resource library, if applicable. _wallResLib = 0L; _roofResLib = 0L; const StyleSheet* sheet = context.getSession() ? context.getSession()->styles() : 0L; if ( sheet != 0L ) { if ( _wallSkinSymbol.valid() && _wallSkinSymbol->libraryName().isSet() ) { _wallResLib = sheet->getResourceLibrary( *_wallSkinSymbol->libraryName() ); if ( !_wallResLib.valid() ) { OE_WARN << LC << "Unable to load resource library '" << *_wallSkinSymbol->libraryName() << "'" << "; wall geometry will not be textured." << std::endl; _wallSkinSymbol = 0L; } } if ( _roofSkinSymbol.valid() && _roofSkinSymbol->libraryName().isSet() ) { _roofResLib = sheet->getResourceLibrary( *_roofSkinSymbol->libraryName() ); if ( !_roofResLib.valid() ) { OE_WARN << LC << "Unable to load resource library '" << *_roofSkinSymbol->libraryName() << "'" << "; roof geometry will not be textured." << std::endl; _roofSkinSymbol = 0L; } } } // calculate the localization matrices (_local2world and _world2local) computeLocalizers( context ); // push all the features through the extruder. bool ok = process( input, context ); // convert everything to triangles and combine drawables. if ( _mergeGeometry == true && _featureNameExpr.empty() ) { for( SortedGeodeMap::iterator i = _geodes.begin(); i != _geodes.end(); ++i ) { MeshConsolidator::run( *i->second.get() ); } } // parent geometry with a delocalizer (if necessary) osg::Group* group = createDelocalizeGroup(); // combines geometries where the statesets are the same. for( SortedGeodeMap::iterator i = _geodes.begin(); i != _geodes.end(); ++i ) { group->addChild( i->second.get() ); } _geodes.clear(); // if we drew outlines, apply a poly offset too. if ( _outlineSymbol.valid() ) { osg::StateSet* groupStateSet = group->getOrCreateStateSet(); groupStateSet->setAttributeAndModes( new osg::PolygonOffset(1,1), 1 ); if ( _outlineSymbol->stroke()->width().isSet() ) groupStateSet->setAttributeAndModes( new osg::LineWidth(*_outlineSymbol->stroke()->width()), 1 ); } // if we have textures, install a shader to draw them if ( _wallSkinSymbol.valid() || _roofSkinSymbol.valid() ) { osg::StateSet* stateSet = group->getOrCreateStateSet(); VirtualProgram* vp = new VirtualProgram(); vp->setName("ExtrudeGeomFilter"); vp->installDefaultColoringShaders( 1 ); stateSet->setAttributeAndModes( vp, osg::StateAttribute::ON ); // a default empty texture will support any non-textured geometry osg::Texture2D* tex = new osg::Texture2D( ImageUtils::createEmptyImage() ); tex->setUnRefImageDataAfterApply( false ); stateSet->setTextureAttributeAndModes(0, tex, osg::StateAttribute::ON); stateSet->getOrCreateUniform("tex0", osg::Uniform::SAMPLER_2D)->set(0); } return group; }
/** * Creates a complete set of positioned label nodes from a feature list. */ osg::Node* createNode( const FeatureList& input, const Style& style, const FilterContext& context ) { if ( style.get<TextSymbol>() == 0L && style.get<IconSymbol>() == 0L ) return 0L; // copy the style so we can (potentially) modify the text symbol. Style styleCopy = style; TextSymbol* text = styleCopy.get<TextSymbol>(); IconSymbol* icon = styleCopy.get<IconSymbol>(); osg::Group* group = new osg::Group(); StringExpression textContentExpr ( text ? *text->content() : StringExpression() ); NumericExpression textPriorityExpr( text ? *text->priority() : NumericExpression() ); NumericExpression textSizeExpr ( text ? *text->size() : NumericExpression() ); StringExpression iconUrlExpr ( icon ? *icon->url() : StringExpression() ); NumericExpression iconScaleExpr ( icon ? *icon->scale() : NumericExpression() ); NumericExpression iconHeadingExpr ( icon ? *icon->heading() : NumericExpression() ); for( FeatureList::const_iterator i = input.begin(); i != input.end(); ++i ) { const Feature* feature = i->get(); if ( !feature ) continue; const Geometry* geom = feature->getGeometry(); if ( !geom ) continue; Style tempStyle = styleCopy; // evaluate expressions into literals. // TODO: Later we could replace this with a generate "expression evaluator" type // that we could pass to PlaceNode in the DB options. -gw if ( text ) { if ( text->content().isSet() ) tempStyle.get<TextSymbol>()->content()->setLiteral( feature->eval( textContentExpr, &context ) ); if ( text->size().isSet() ) tempStyle.get<TextSymbol>()->size()->setLiteral( feature->eval(textSizeExpr, &context) ); } if ( icon ) { if ( icon->url().isSet() ) tempStyle.get<IconSymbol>()->url()->setLiteral( feature->eval(iconUrlExpr, &context) ); if ( icon->scale().isSet() ) tempStyle.get<IconSymbol>()->scale()->setLiteral( feature->eval(iconScaleExpr, &context) ); if ( icon->heading().isSet() ) tempStyle.get<IconSymbol>()->heading()->setLiteral( feature->eval(iconHeadingExpr, &context) ); } osg::Node* node = makePlaceNode( context, feature, tempStyle, textPriorityExpr); if ( node ) { if ( context.featureIndex() ) { context.featureIndex()->tagNode(node, const_cast<Feature*>(feature)); } group->addChild( node ); } } VirtualProgram* vp = VirtualProgram::getOrCreate(group->getOrCreateStateSet()); vp->setInheritShaders( false ); return group; }
bool ShaderGenerator::processGeometry( osg::StateSet* ss, osg::ref_ptr<osg::StateSet>& replacement ) { // do nothing if there's no GLSL support if ( !Registry::capabilities().supportsGLSL() ) return false; // State object with extra accessors: StateEx* state = static_cast<StateEx*>(_state.get()); // check for a real osg::Program in the whole state stack. If it exists, bail out // so that OSG can use the program already in the graph. We never override a // full Program. osg::StateAttribute* program = state->getAttribute(osg::StateAttribute::PROGRAM); if ( dynamic_cast<osg::Program*>(program) != 0L ) return false; // see if the current state set contains a VirtualProgram already. If so, // we will add to it if necessary. VirtualProgram* vp = dynamic_cast<VirtualProgram*>( ss->getAttribute(VirtualProgram::SA_TYPE) ); // Check whether the lighting state has changed and install a mode uniform. if ( ss->getMode(GL_LIGHTING) != osg::StateAttribute::INHERIT ) { if ( !replacement.valid() ) replacement = osg::clone(ss, osg::CopyOp::DEEP_COPY_ALL); ShaderFactory* sf = Registry::instance()->getShaderFactory(); osg::StateAttribute::GLModeValue value = state->getMode(GL_LIGHTING); // from the state, not the ss. replacement->addUniform( sf->createUniformForGLMode(GL_LIGHTING, value) ); } // if the stateset changes any texture attributes, we need a new virtual program: if (ss->getTextureAttributeList().size() > 0) { if ( !replacement.valid() ) replacement = osg::clone(ss, osg::CopyOp::DEEP_COPY_ALL); // work off the state's accumulated texture attribute set: int texCount = state->getNumTextureAttributes(); if ( !vp ) { vp = osg::clone( _defaultVP.get() ); replacement->setAttributeAndModes( vp, osg::StateAttribute::ON ); } // start generating the shader source. std::stringstream vertHead, vertBody, fragHead, fragBody; // compatibility strings make it work in GL or GLES. vertHead << "#version " GLSL_VERSION_STR "\n" GLSL_PRECISION; fragHead << "#version " GLSL_VERSION_STR "\n" GLSL_PRECISION; // function declarations: vertBody << "void " VERTEX_FUNCTION "()\n{\n"; fragBody << "void " FRAGMENT_FUNCTION "(inout vec4 color)\n{\n"; for( int t = 0; t < texCount; ++t ) { if (t == 0) { fragBody << INDENT << MEDIUMP "vec4 texel; \n"; } osg::StateAttribute* tex = state->getTextureAttribute( t, osg::StateAttribute::TEXTURE ); if ( tex ) { // see if we have a texenv; if so get its blending mode. osg::TexEnv::Mode blendingMode = osg::TexEnv::MODULATE; osg::TexEnv* env = dynamic_cast<osg::TexEnv*>(state->getTextureAttribute(t, osg::StateAttribute::TEXENV) ); if ( env ) { blendingMode = env->getMode(); if ( blendingMode == osg::TexEnv::BLEND ) { replacement->getOrCreateUniform( Stringify() << TEXENV_COLOR << t, osg::Uniform::FLOAT_VEC4 )->set( env->getColor() ); } } vertHead << "varying " MEDIUMP "vec4 " TEX_COORD << t << ";\n"; vertBody << INDENT << TEX_COORD << t << " = gl_MultiTexCoord" << t << ";\n"; fragHead << "varying " MEDIUMP "vec4 " TEX_COORD << t << ";\n"; if ( dynamic_cast<osg::Texture1D*>(tex) ) { fragHead << "uniform sampler1D " SAMPLER << t << ";\n"; fragBody << INDENT "texel = texture1D(" SAMPLER << t << ", " TEX_COORD << t << ".x);\n"; replacement->getOrCreateUniform( Stringify() << SAMPLER << t, osg::Uniform::SAMPLER_1D )->set( t ); } else if ( dynamic_cast<osg::Texture2D*>(tex) ) { fragHead << "uniform sampler2D " SAMPLER << t << ";\n"; fragBody << INDENT "texel = texture2D(" SAMPLER << t << ", " TEX_COORD << t << ".xy);\n"; replacement->getOrCreateUniform( Stringify() << SAMPLER << t, osg::Uniform::SAMPLER_2D )->set( t ); } else if ( dynamic_cast<osg::Texture3D*>(tex) ) { fragHead << "uniform sampler3D " SAMPLER << t << ";\n"; fragBody << INDENT "texel = texture3D(" SAMPLER << t << ", " TEX_COORD << t << ".xyz);\n"; replacement->getOrCreateUniform( Stringify() << SAMPLER << t, osg::Uniform::SAMPLER_3D )->set( t ); } // See http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml switch( blendingMode ) { case osg::TexEnv::REPLACE: fragBody << INDENT "color = texel; \n"; break; case osg::TexEnv::MODULATE: fragBody << INDENT "color = color * texel; \n"; break; case osg::TexEnv::DECAL: fragBody << INDENT "color.rgb = color.rgb * (1.0 - texel.a) + (texel.rgb * texel.a); \n"; break; case osg::TexEnv::BLEND: fragHead << "uniform " MEDIUMP "vec4 " TEXENV_COLOR << t << "\n;"; fragBody << INDENT "color.rgb = color.rgb * (1.0 - texel.rgb) + (" << TEXENV_COLOR << t << ".rgb * texel.rgb); \n" << INDENT "color.a = color.a * texel.a; \n"; break; case osg::TexEnv::ADD: default: fragBody << INDENT "color.rgb = color.rgb + texel.rgb; \n" << INDENT "color.a = color.a * texel.a; \n"; } } } // close out functions: vertBody << "}\n"; fragBody << "}\n"; // Extract the shader source strings (win compat method) std::string vertBodySrc, vertSrc, fragBodySrc, fragSrc; vertBodySrc = vertBody.str(); vertHead << vertBodySrc; vertSrc = vertHead.str(); fragBodySrc = fragBody.str(); fragHead << fragBodySrc; fragSrc = fragHead.str(); // inject the shaders: vp->setFunction( VERTEX_FUNCTION, vertSrc, ShaderComp::LOCATION_VERTEX_PRE_LIGHTING ); vp->setFunction( FRAGMENT_FUNCTION, fragSrc, ShaderComp::LOCATION_FRAGMENT_PRE_LIGHTING ); } return replacement.valid(); }
osg::Node* PolygonizeLinesFilter::push(FeatureList& input, FilterContext& cx) { // compute the coordinate localization matrices. computeLocalizers( cx ); // establish some things bool makeECEF = false; const SpatialReference* featureSRS = 0L; const SpatialReference* mapSRS = 0L; if ( cx.isGeoreferenced() ) { makeECEF = cx.getSession()->getMapInfo().isGeocentric(); featureSRS = cx.extent()->getSRS(); mapSRS = cx.getSession()->getMapInfo().getProfile()->getSRS(); } // The operator we'll use to make lines into polygons. const LineSymbol* line = _style.get<LineSymbol>(); PolygonizeLinesOperator polygonize( line ? (*line->stroke()) : Stroke() ); // Geode to hold all the geometries. osg::Geode* geode = new osg::Geode(); // iterate over all features. for( FeatureList::iterator i = input.begin(); i != input.end(); ++i ) { Feature* f = i->get(); // iterate over all the feature's geometry parts. We will treat // them as lines strings. GeometryIterator parts( f->getGeometry(), false ); while( parts.hasMore() ) { Geometry* part = parts.next(); // skip empty geometry if ( part->size() == 0 ) continue; // transform the geometry into the target SRS and localize it about // a local reference point. osg::Vec3Array* verts = new osg::Vec3Array(); osg::Vec3Array* normals = new osg::Vec3Array(); transformAndLocalize( part->asVector(), featureSRS, verts, normals, mapSRS, _world2local, makeECEF ); // turn the lines into polygons. osg::Geometry* geom = polygonize( verts, normals ); geode->addDrawable( geom ); // record the geometry's primitive set(s) in the index: if ( cx.featureIndex() ) cx.featureIndex()->tagPrimitiveSets( geom, f ); } } // attempt to combine geometries for better performance MeshConsolidator::run( *geode ); // GPU performance optimization: VertexCacheOptimizer vco; geode->accept( vco ); // If we're auto-scaling, we need a shader float minPixels = line ? line->stroke()->minPixels().getOrUse( 0.0f ) : 0.0f; if ( minPixels > 0.0f ) { osg::StateSet* stateSet = geode->getOrCreateStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(stateSet); vp->setName( "osgEarth::PolygonizeLines" ); const char* vs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "attribute vec3 oe_polyline_center; \n" "uniform float oe_polyline_scale; \n" "uniform float oe_polyline_min_pixels; \n" "uniform mat3 oe_WindowScaleMatrix; \n" "void oe_polyline_scalelines(inout vec4 VertexMODEL) \n" "{ \n" " if ( oe_polyline_scale != 1.0 || oe_polyline_min_pixels > 0.0 ) \n" " { \n" " vec4 center_model = vec4(oe_polyline_center*VertexMODEL.w, VertexMODEL.w); \n" " vec4 vector_model = VertexMODEL - center_model; \n" " if ( length(vector_model.xyz) > 0.0 ) \n" " { \n" " float scale = oe_polyline_scale; \n" " vec4 vertex_clip = gl_ModelViewProjectionMatrix * VertexMODEL; \n" " vec4 center_clip = gl_ModelViewProjectionMatrix * center_model; \n" " vec4 vector_clip = vertex_clip - center_clip; \n" " if ( oe_polyline_min_pixels > 0.0 ) \n" " { \n" " vec3 vector_win = oe_WindowScaleMatrix * (vertex_clip.xyz/vertex_clip.w - center_clip.xyz/center_clip.w); \n" " float min_scale = max( (0.5*oe_polyline_min_pixels)/length(vector_win.xy), 1.0 ); \n" " scale = max( scale, min_scale ); \n" " } \n" " VertexMODEL = center_model + vector_model*scale; \n" " } \n" " } \n" "} \n"; vp->setFunction( "oe_polyline_scalelines", vs, ShaderComp::LOCATION_VERTEX_MODEL ); vp->addBindAttribLocation( "oe_polyline_center", osg::Drawable::ATTRIBUTE_6 ); // add the default scaling uniform. // good way to test: // osgearth_viewer earthfile --uniform oe_polyline_scale 1.0 10.0 osg::Uniform* scaleU = new osg::Uniform(osg::Uniform::FLOAT, "oe_polyline_scale"); scaleU->set( 1.0f ); stateSet->addUniform( scaleU, 1 ); // the default "min pixels" uniform. osg::Uniform* minPixelsU = new osg::Uniform(osg::Uniform::FLOAT, "oe_polyline_min_pixels"); minPixelsU->set( minPixels ); stateSet->addUniform( minPixelsU, 1 ); } return delocalize( geode ); }
void OverlayDecorator::initSubgraphShaders( osg::StateSet* set ) { VirtualProgram* vp = new VirtualProgram(); vp->setName( "OverlayDecorator subgraph shader" ); set->setAttributeAndModes( vp, osg::StateAttribute::ON ); // sampler for projected texture: set->getOrCreateUniform( "osgearth_overlay_ProjTex", osg::Uniform::SAMPLER_2D )->set( *_textureUnit ); // the texture projection matrix uniform. _texGenUniform = set->getOrCreateUniform( "osgearth_overlay_TexGenMatrix", osg::Uniform::FLOAT_MAT4 ); std::stringstream buf; // vertex shader - subgraph buf << "#version 110 \n" << "uniform mat4 osgearth_overlay_TexGenMatrix; \n" << "uniform mat4 osg_ViewMatrixInverse; \n" << "void osgearth_overlay_vertex(void) \n" << "{ \n" << " gl_TexCoord["<< *_textureUnit << "] = osgearth_overlay_TexGenMatrix * osg_ViewMatrixInverse * gl_ModelViewMatrix * gl_Vertex; \n" << "} \n"; std::string vertexSource = buf.str(); vp->setFunction( "osgearth_overlay_vertex", vertexSource, ShaderComp::LOCATION_VERTEX_POST_LIGHTING ); // fragment shader - subgraph buf.str(""); buf << "#version 110 \n" << "uniform sampler2D osgearth_overlay_ProjTex; \n"; if ( _useWarping ) { buf << "uniform float warp; \n" // because the built-in pow() is busted << "float mypow( in float x, in float y ) \n" << "{ \n" << " return x/(x+y-y*x); \n" << "} \n" << "vec2 warpTexCoord( in vec2 src ) \n" << "{ \n" // incoming tex coord is [0..1], so we scale to [-1..1] << " vec2 srcn = vec2( src.x*2.0 - 1.0, src.y*2.0 - 1.0 ); \n" // we want to work in the [0..1] space on each side of 0, so can the abs // and store the signs for later: << " vec2 srct = vec2( abs(srcn.x), abs(srcn.y) ); \n" << " vec2 sign = vec2( srcn.x > 0.0 ? 1.0 : -1.0, srcn.y > 0.0 ? 1.0 : -1.0 ); \n" // apply the deformation using a deceleration curve: << " vec2 srcp = vec2( 1.0-mypow(1.0-srct.x,warp), 1.0-mypow(1.0-srct.y,warp) ); \n" // reapply the sign, and scale back to [0..1]: << " vec2 srcr = vec2( sign.x*srcp.x, sign.y*srcp.y ); \n" << " return vec2( 0.5*(srcr.x + 1.0), 0.5*(srcr.y + 1.0) ); \n" << "} \n"; } buf << "void osgearth_overlay_fragment( inout vec4 color ) \n" << "{ \n" << " vec2 texCoord = gl_TexCoord["<< *_textureUnit << "].xy / gl_TexCoord["<< *_textureUnit << "].q; \n"; if ( _useWarping && !_visualizeWarp ) buf << " texCoord = warpTexCoord( texCoord ); \n"; buf << " vec4 texel = texture2D(osgearth_overlay_ProjTex, texCoord); \n" << " color = vec4( mix( color.rgb, texel.rgb, texel.a ), color.a); \n" << "} \n"; std::string fragmentSource = buf.str(); vp->setFunction( "osgearth_overlay_fragment", fragmentSource, ShaderComp::LOCATION_FRAGMENT_PRE_LIGHTING ); }
// Generates the main shader code for rendering the terrain. void MPTerrainEngineNode::updateShaders() { if ( _batchUpdateInProgress ) { _shaderUpdateRequired = true; } else { osg::StateSet* terrainStateSet = _terrain->getOrCreateStateSet(); VirtualProgram* vp = new VirtualProgram(); vp->setName( "engine_mp:TerrainNode" ); terrainStateSet->setAttributeAndModes( vp, osg::StateAttribute::ON ); // bind the vertex attributes generated by the tile compiler. vp->addBindAttribLocation( "oe_terrain_attr", osg::Drawable::ATTRIBUTE_6 ); vp->addBindAttribLocation( "oe_terrain_attr2", osg::Drawable::ATTRIBUTE_7 ); // Vertex shader template: std::string vs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "varying vec4 oe_layer_texc;\n" "varying vec4 oe_layer_tilec;\n" "void oe_mp_setup_coloring(inout vec4 VertexModel) \n" "{ \n" " oe_layer_texc = __GL_MULTITEXCOORD1__;\n" " oe_layer_tilec = __GL_MULTITEXCOORD2__;\n" "}\n"; // Fragment shader for normal blending: std::string fs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "varying vec4 oe_layer_texc; \n" "uniform sampler2D oe_layer_tex; \n" "uniform int oe_layer_uid; \n" "uniform int oe_layer_order; \n" "uniform float oe_layer_opacity; \n" "void oe_mp_apply_coloring( inout vec4 color ) \n" "{ \n" " vec4 texel; \n" " if ( oe_layer_uid >= 0 ) { \n" " texel = texture2D(oe_layer_tex, oe_layer_texc.st); \n" " texel.a *= oe_layer_opacity; \n" " } \n" " else \n" " texel = color; \n" " if (oe_layer_order == 0 ) \n" " color = texel*texel.a + color*(1.0-texel.a); \n" // simulate src_alpha, 1-src_alpha blens " else \n" " color = texel; \n" "} \n"; // Fragment shader with pre-multiplied alpha blending: std::string fs_pma = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "varying vec4 oe_layer_texc; \n" "uniform sampler2D oe_layer_tex; \n" "uniform int oe_layer_uid; \n" "uniform int oe_layer_order; \n" "uniform float oe_layer_opacity; \n" "void oe_mp_apply_coloring_pma( inout vec4 color ) \n" "{ \n" " vec4 texelpma; \n" // a UID < 0 means no texture. " if ( oe_layer_uid >= 0 ) \n" " texelpma = texture2D(oe_layer_tex, oe_layer_texc.st) * oe_layer_opacity; \n" " else \n" " texelpma = color * color.a * oe_layer_opacity; \n" // to PMA. // first layer must PMA-blend with the globe color. " if (oe_layer_order == 0) { \n" " color.rgb *= color.a; \n" " color = texelpma + color*(1.0-texelpma.a); \n" // simulate one, 1-src_alpha blend " } \n" " else { \n" " color = texelpma; \n" " } \n" "} \n"; // 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"; // install the gl_MultiTexCoord* variable that uses the proper texture // image unit: replaceIn( vs, "__GL_MULTITEXCOORD1__", Stringify() << "gl_MultiTexCoord" << _primaryUnit ); replaceIn( vs, "__GL_MULTITEXCOORD2__", Stringify() << "gl_MultiTexCoord" << _secondaryUnit ); vp->setFunction( "oe_mp_setup_coloring", vs, ShaderComp::LOCATION_VERTEX_MODEL, 0.0 ); if ( _terrainOptions.premultipliedAlpha() == true ) vp->setFunction( "oe_mp_apply_coloring_pma", fs_pma, ShaderComp::LOCATION_FRAGMENT_COLORING, 0.0 ); else vp->setFunction( "oe_mp_apply_coloring", fs, ShaderComp::LOCATION_FRAGMENT_COLORING, 0.0 ); // assemble color filter code snippets. bool haveColorFilters = false; { std::stringstream cf_head; std::stringstream cf_body; const char* I = " "; if ( _terrainOptions.premultipliedAlpha() == true ) { // un-PMA the color before passing it to the color filters. cf_body << I << "if (color.a > 0.0) color.rgb /= color.a; \n"; } // 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( terrainStateSet ); } cf_body << I << "}\n"; ifStarted = true; } } } if ( _terrainOptions.premultipliedAlpha() == true ) { // re-PMA the color after it passes through the color filters. cf_body << I << "color.rgb *= color.a; \n"; } 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.0 ); } } if ( _terrainOptions.premultipliedAlpha() == true ) { // activate PMA blending. terrainStateSet->setAttributeAndModes( new osg::BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA), osg::StateAttribute::ON ); } else { // activate standard mix blending. terrainStateSet->setAttributeAndModes( new osg::BlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA), osg::StateAttribute::ON ); } // required for multipass tile rendering to work terrainStateSet->setAttributeAndModes( new osg::Depth(osg::Depth::LEQUAL, 0, 1, true) ); // binding for the terrain texture terrainStateSet->getOrCreateUniform( "oe_layer_tex", osg::Uniform::SAMPLER_2D )->set( _primaryUnit ); // binding for the secondary texture (for LOD blending) terrainStateSet->getOrCreateUniform( "oe_layer_tex_parent", osg::Uniform::SAMPLER_2D )->set( _secondaryUnit ); // 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 ); _shaderUpdateRequired = false; } }
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; if ( _inherit ) { const StateHack::AttributeVec* av = StateHack::GetAttributeVec( state, this ); if ( av && av->size() > 0 ) { // find the deepest VP that doesn't inherit: unsigned start = 0; for( start = (int)av->size()-1; start > 0; --start ) { const VirtualProgram* vp = dynamic_cast<const VirtualProgram*>( (*av)[start].first ); if ( vp && (vp->_mask & _mask) && vp->_inherit == false ) break; } // collect shaders from there to here: for( unsigned i=start; i<av->size(); ++i ) { const VirtualProgram* vp = dynamic_cast<const VirtualProgram*>( (*av)[i].first ); if ( vp && (vp->_mask && _mask) ) { for( ShaderMap::const_iterator i = vp->_shaderMap.begin(); i != vp->_shaderMap.end(); ++i ) { addToAccumulatedMap( accumShaderMap, i->first, i->second ); } const AttribBindingList& abl = vp->getAttribBindingList(); accumAttribBindings.insert( abl.begin(), abl.end() ); const AttribAliasMap& aliases = vp->getAttribAliases(); accumAttribAliases.insert( aliases.begin(), aliases.end() ); } } } } // next add the local shader components to the map, respecting the override values: for( ShaderMap::const_iterator i = _shaderMap.begin(); i != _shaderMap.end(); ++i ) { addToAccumulatedMap( accumShaderMap, i->first, i->second ); } const AttribBindingList& abl = this->getAttribBindingList(); accumAttribBindings.insert( abl.begin(), abl.end() ); const AttribAliasMap& aliases = this->getAttribAliases(); accumAttribAliases.insert( aliases.begin(), aliases.end() ); if ( true ) //even with nothing in the map, we still want mains! -gw //accumShaderMap.size() ) { // 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; vec.push_back( entry.first.get() ); } // see if there's already a program associated with this list: osg::Program* program = 0L; // 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 ) { Threading::ScopedWriteLock exclusive( _programCacheMutex ); // look again in case of contention: ProgramMap::const_iterator p = _programCache.find( vec ); if ( p != _programCache.end() ) { program = p->second.get(); } else { VirtualProgram* nc = const_cast<VirtualProgram*>(this); program = nc->buildProgram( state, accumShaderMap, accumAttribBindings, accumAttribAliases); } } // finally, apply the program attribute. program->apply( state ); } }
void PolygonizeLinesOperator::installShaders(osg::Node* node) const { if ( !node ) return; float minPixels = _stroke.minPixels().getOrUse( 0.0f ); if ( minPixels <= 0.0f ) return; osg::StateSet* stateset = node->getOrCreateStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); // bail if already installed. if ( vp->getName().compare( SHADER_NAME ) == 0 ) return; vp->setName( SHADER_NAME ); const char* vs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "in vec3 oe_polyline_center; \n" "uniform float oe_polyline_scale; \n" "uniform float oe_polyline_min_pixels; \n" "uniform vec4 oe_PixelSizeVector; \n" "void oe_polyline_scalelines(inout vec4 vertex_model4) \n" "{ \n" " const float epsilon = 0.0001; \n" " vec4 center = vec4(oe_polyline_center, 1.0); \n" " vec3 vector = vertex_model4.xyz - center.xyz; \n" " float r = length(vector); \n" " float activate = step(epsilon, r*oe_polyline_min_pixels);\n" " float pixelSize = max(epsilon, 2.0*abs(r/dot(center, oe_PixelSizeVector))); \n" " float min_scale = max(oe_polyline_min_pixels/pixelSize, 1.0); \n" " float scale = mix(1.0, max(oe_polyline_scale, min_scale), activate); \n" " vertex_model4.xyz = center.xyz + vector*scale; \n" "} \n"; vp->setFunction( "oe_polyline_scalelines", vs, ShaderComp::LOCATION_VERTEX_MODEL, 0.5f ); vp->addBindAttribLocation( "oe_polyline_center", ATTR_LOCATION ); // add the default scaling uniform. // good way to test: // osgearth_viewer earthfile --uniform oe_polyline_scale 1.0 10.0 osg::Uniform* scaleU = new osg::Uniform(osg::Uniform::FLOAT, "oe_polyline_scale"); scaleU->set( 1.0f ); stateset->addUniform( scaleU, 1 ); // the default "min pixels" uniform. osg::Uniform* minPixelsU = new osg::Uniform(osg::Uniform::FLOAT, "oe_polyline_min_pixels"); minPixelsU->set( minPixels ); stateset->addUniform( minPixelsU, 1 ); // this will install and update the oe_PixelSizeVector uniform. node->addCullCallback( new PixelSizeVectorCullCallback(stateset) ); }
void TextureCompositorMultiTexture::updateMasterStateSet(osg::StateSet* stateSet, const TextureLayout& layout ) const { int numSlots = layout.getMaxUsedSlot() + 1; int maxUnits = numSlots; if ( _useGPU ) { // Validate against the max number of GPU texture units: if ( maxUnits > Registry::instance()->getCapabilities().getMaxGPUTextureUnits() ) { maxUnits = Registry::instance()->getCapabilities().getMaxGPUTextureUnits(); OE_WARN << LC << "Warning! You have exceeded the number of texture units available on your GPU (" << maxUnits << "). Consider using another compositing mode." << std::endl; } VirtualProgram* vp = static_cast<VirtualProgram*>( stateSet->getAttribute(VirtualProgram::SA_TYPE) ); // see if we have any blended layers: bool hasBlending = layout.containsSecondarySlots( maxUnits ); // Why are these marked as PROTECTED? See the comments in MapNode.cpp for the answer. // (Where it sets up the top-level VirtualProgram) vp->setFunction( "oe_multicomp_vertex", s_createTextureVertexShader(layout, hasBlending), ShaderComp::LOCATION_VERTEX_MODEL, 0.0 ); vp->setFunction( "oe_multicomp_fragment", s_createTextureFragShaderFunction(layout, maxUnits, hasBlending, _lodTransitionTime), ShaderComp::LOCATION_FRAGMENT_COLORING, 0.0 ); //vp->setShader( // "osgearth_vert_setupColoring", // s_createTextureVertexShader(layout, hasBlending), // osg::StateAttribute::ON | osg::StateAttribute::PROTECTED ); //vp->setShader( // "osgearth_frag_applyColoring", // s_createTextureFragShaderFunction(layout, maxUnits, hasBlending, _lodTransitionTime), // osg::StateAttribute::ON | osg::StateAttribute::PROTECTED ); } else { // Forcably disable shaders stateSet->setAttributeAndModes( new osg::Program(), osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED ); // Validate against the maximum number of textures available in FFP mode. if ( maxUnits > Registry::instance()->getCapabilities().getMaxFFPTextureUnits() ) { maxUnits = Registry::instance()->getCapabilities().getMaxFFPTextureUnits(); OE_WARN << LC << "Warning! You have exceeded the number of texture units available in fixed-function pipeline " "mode on your graphics hardware (" << maxUnits << "). Consider using another " "compositing mode." << std::endl; } // FFP multitexturing requires that we set up a series of TexCombine attributes: if (maxUnits == 1) { osg::TexEnv* texenv = new osg::TexEnv(osg::TexEnv::MODULATE); stateSet->setTextureAttributeAndModes(0, texenv, osg::StateAttribute::ON); } else if (maxUnits >= 2) { //Blend together the colors and accumulate the alpha values of textures 0 and 1 on unit 0 { osg::TexEnvCombine* texenv = new osg::TexEnvCombine; texenv->setCombine_RGB(osg::TexEnvCombine::INTERPOLATE); texenv->setCombine_Alpha(osg::TexEnvCombine::ADD); texenv->setSource0_RGB(osg::TexEnvCombine::TEXTURE0+1); texenv->setOperand0_RGB(osg::TexEnvCombine::SRC_COLOR); texenv->setSource0_Alpha(osg::TexEnvCombine::TEXTURE0+1); texenv->setOperand0_Alpha(osg::TexEnvCombine::SRC_ALPHA); texenv->setSource1_RGB(osg::TexEnvCombine::TEXTURE0+0); texenv->setOperand1_RGB(osg::TexEnvCombine::SRC_COLOR); texenv->setSource1_Alpha(osg::TexEnvCombine::TEXTURE0+0); texenv->setOperand1_Alpha(osg::TexEnvCombine::SRC_ALPHA); texenv->setSource2_RGB(osg::TexEnvCombine::TEXTURE0+1); texenv->setOperand2_RGB(osg::TexEnvCombine::SRC_ALPHA); stateSet->setTextureAttributeAndModes(0, texenv, osg::StateAttribute::ON); } //For textures 2 and beyond, blend them together with the previous //Add the alpha values of this unit and the previous unit for (int unit = 1; unit < maxUnits-1; ++unit) { osg::TexEnvCombine* texenv = new osg::TexEnvCombine; texenv->setCombine_RGB(osg::TexEnvCombine::INTERPOLATE); texenv->setCombine_Alpha(osg::TexEnvCombine::ADD); texenv->setSource0_RGB(osg::TexEnvCombine::TEXTURE0+unit+1); texenv->setOperand0_RGB(osg::TexEnvCombine::SRC_COLOR); texenv->setSource0_Alpha(osg::TexEnvCombine::TEXTURE0+unit+1); texenv->setOperand0_Alpha(osg::TexEnvCombine::SRC_ALPHA); texenv->setSource1_RGB(osg::TexEnvCombine::PREVIOUS); texenv->setOperand1_RGB(osg::TexEnvCombine::SRC_COLOR); texenv->setSource1_Alpha(osg::TexEnvCombine::PREVIOUS); texenv->setOperand1_Alpha(osg::TexEnvCombine::SRC_ALPHA); texenv->setSource2_RGB(osg::TexEnvCombine::TEXTURE0+unit+1); texenv->setOperand2_RGB(osg::TexEnvCombine::SRC_ALPHA); stateSet->setTextureAttributeAndModes(unit, texenv, osg::StateAttribute::ON); } //Modulate the colors to get proper lighting on the last unit //Keep the alpha results from the previous stage { osg::TexEnvCombine* texenv = new osg::TexEnvCombine; texenv->setCombine_RGB(osg::TexEnvCombine::MODULATE); texenv->setCombine_Alpha(osg::TexEnvCombine::REPLACE); texenv->setSource0_RGB(osg::TexEnvCombine::PREVIOUS); texenv->setOperand0_RGB(osg::TexEnvCombine::SRC_COLOR); texenv->setSource0_Alpha(osg::TexEnvCombine::PREVIOUS); texenv->setOperand0_Alpha(osg::TexEnvCombine::SRC_ALPHA); texenv->setSource1_RGB(osg::TexEnvCombine::PRIMARY_COLOR); texenv->setOperand1_RGB(osg::TexEnvCombine::SRC_COLOR); stateSet->setTextureAttributeAndModes(maxUnits-1, texenv, osg::StateAttribute::ON); } } } }
int main(int argc, char** argv) { osg::ArgumentParser arguments(&argc,argv); // help? if ( arguments.read("--help") ) return usage(argv[0]); // set up a viewer: osgViewer::Viewer viewer(arguments); viewer.getDatabasePager()->setUnrefImageDataAfterApplyPolicy( false, false ); // install our default manipulator (do this before calling load) viewer.setCameraManipulator( new EarthManipulator() ); // load an earth file, and support all or our example command-line options // and earth file <external> tags osg::Node* node = MapNodeHelper().load( arguments, &viewer ); if ( node ) { // Make a root group: osg::Group* root = new osg::Group(); root->addChild( node ); viewer.setSceneData( root ); // Install a ClipNode. The ClipNode establishes positional state so it // doesn't need to parent anything. In this case it needs to be at the // top of the scene graph since out clip plane calculator assumes // you're in world space. osg::ClipNode* clipNode = new osg::ClipNode(); root->addChild( clipNode ); // By default, the clip node will activate any clip planes you add to it // for its subgraph. Our clip node doesn't parent anything, but we include // this to demonstrate how you would disable that: clipNode->getOrCreateStateSet()->setMode(GL_CLIP_PLANE0, 0); // Create a ClipPlane we will use to clip to the visible horizon: osg::ClipPlane* cp = new osg::ClipPlane(); clipNode->addClipPlane( cp ); // This cull callback will recalcuate the position of the clipping plane // each frame based on the camera. const osgEarth::SpatialReference* srs = osgEarth::MapNode::get(node)->getMapSRS(); clipNode->addCullCallback( new ClipToGeocentricHorizon(srs, cp) ); // We also need a shader that will activate clipping in GLSL. VirtualProgram* vp = VirtualProgram::getOrCreate(root->getOrCreateStateSet()); vp->setFunction("oe_clip_vert", clipvs, ShaderComp::LOCATION_VERTEX_VIEW); // Now everything is set up. The last thing to do is: anywhere in your // scene graph that you want to activate the clipping plane, set the // corresponding mode on, like so: // // node->getOrCreateStateSet()->setMode(GL_CLIP_PLANE0, osg::StateAttribute::ON); // // If you are using symbology, you can use RenderSymbol::clipPlane(). Or in // the earth file, for example: // // render-depth-test: false; // render-clip-plane: 0; return viewer.run(); } else { return usage(argv[0]); } }
void ShadowCaster::reinitialize() { if ( !_supported ) return; _shadowmap = 0L; _rttCameras.clear(); int numSlices = (int)_ranges.size() - 1; if ( numSlices < 1 ) { OE_WARN << LC << "Illegal. Must have at least one range slice." << std::endl; return ; } // create the projected texture: _shadowmap = new osg::Texture2DArray(); _shadowmap->setTextureSize( _size, _size, numSlices ); _shadowmap->setInternalFormat( GL_DEPTH_COMPONENT ); _shadowmap->setFilter( osg::Texture::MIN_FILTER, osg::Texture::LINEAR ); _shadowmap->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); _shadowmap->setWrap( osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_BORDER ); _shadowmap->setWrap( osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_BORDER ); _shadowmap->setBorderColor(osg::Vec4(1,1,1,1)); // set up the RTT camera: for(int i=0; i<numSlices; ++i) { osg::Camera* rtt = new osg::Camera(); Shadowing::setIsShadowCamera(rtt); rtt->setReferenceFrame( osg::Camera::ABSOLUTE_RF_INHERIT_VIEWPOINT ); rtt->setClearDepth( 1.0 ); rtt->setClearMask( GL_DEPTH_BUFFER_BIT ); rtt->setComputeNearFarMode( osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR ); rtt->setViewport( 0, 0, _size, _size ); rtt->setRenderOrder( osg::Camera::PRE_RENDER ); rtt->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT ); rtt->setImplicitBufferAttachmentMask(0, 0); rtt->attach( osg::Camera::DEPTH_BUFFER, _shadowmap.get(), 0, i ); rtt->addChild( _castingGroup.get() ); _rttCameras.push_back(rtt); } _rttStateSet = new osg::StateSet(); // only draw back faces to the shadow depth map _rttStateSet->setAttributeAndModes( new osg::CullFace(osg::CullFace::FRONT), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); _rttStateSet->addUniform(new osg::Uniform("oe_isShadowCamera", true), osg::StateAttribute::OVERRIDE); _renderStateSet = new osg::StateSet(); std::string vertex = Stringify() << "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "uniform mat4 oe_shadow_matrix[" << numSlices << "]; \n" "varying vec4 oe_shadow_coord[" << numSlices << "]; \n" "void oe_shadow_vertex(inout vec4 VertexVIEW) \n" "{ \n" " for(int i=0; i<" << numSlices << "; ++i) \n" " oe_shadow_coord[i] = oe_shadow_matrix[i] * VertexVIEW;\n" "} \n"; std::string fragment = Stringify() << "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "#extension GL_EXT_texture_array : enable \n" "uniform sampler2DArray oe_shadow_map; \n" "uniform vec4 oe_shadow_color; \n" "uniform float oe_shadow_blur; \n" "varying vec3 vp_Normal; \n" "varying vec4 oe_shadow_coord[" << numSlices << "]; \n" //TODO-run a generator and rplace "#define OE_SHADOW_NUM_SAMPLES 16\n" "const vec2 oe_shadow_samples[OE_SHADOW_NUM_SAMPLES] = vec2[]( vec2( -0.942016, -0.399062 ), vec2( 0.945586, -0.768907 ), vec2( -0.094184, -0.929389 ), vec2( 0.344959, 0.293878 ), vec2( -0.915886, 0.457714 ), vec2( -0.815442, -0.879125 ), vec2( -0.382775, 0.276768 ), vec2( 0.974844, 0.756484 ), vec2( 0.443233, -0.975116 ), vec2( 0.53743, -0.473734 ), vec2( -0.264969, -0.41893 ), vec2( 0.791975, 0.190909 ), vec2( -0.241888, 0.997065 ), vec2( -0.8141, 0.914376 ), vec2( 0.199841, 0.786414 ), vec2( 0.143832, -0.141008 )); \n" "float oe_shadow_rand(vec2 co){\n" " return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n" "}\n" "vec2 oe_shadow_rot(vec2 p, float a) { \n" " vec2 sincos = vec2(sin(a), cos(a)); \n" " return vec2(dot(p, vec2(sincos.y, -sincos.x)), dot(p, sincos.xy)); \n" "}\n" // slow PCF sampling. "float oe_shadow_multisample(in vec3 c, in float refvalue, in float blur) \n" "{ \n" " float shadowed = 0.0; \n" " float a = 6.283185 * oe_shadow_rand(c.xy); \n" " vec4 b = vec4(oe_shadow_rot(vec2(1,0),a), oe_shadow_rot(vec2(0,1),a)); \n" " for(int i=0; i<OE_SHADOW_NUM_SAMPLES; ++i) { \n" " vec2 off = oe_shadow_samples[i];\n" " off = vec2(dot(off,b.xz), dot(off,b.yw)); \n" " vec3 pc = vec3(c.xy + off*blur, c.z); \n" " float depth = texture2DArray(oe_shadow_map, pc).r; \n" " if ( depth < 1.0 && depth < refvalue ) { \n" " shadowed += 1.0; \n" " } \n" " } \n" " return 1.0-(shadowed/OE_SHADOW_NUM_SAMPLES); \n" "} \n" "void oe_shadow_fragment( inout vec4 color )\n" "{\n" " float alpha = color.a; \n" " float factor = 1.0; \n" // pre-pixel biasing to reduce moire/acne " const float b0 = 0.001; \n" " const float b1 = 0.01; \n" " vec3 L = normalize(gl_LightSource[0].position.xyz); \n" " vec3 N = normalize(vp_Normal); \n" " float costheta = clamp(dot(L,N), 0.0, 1.0); \n" " float bias = b0*tan(acos(costheta)); \n" // loop over the slices: " for(int i=0; i<" << numSlices << " && factor > 0.0; ++i) \n" " { \n" " vec4 c = oe_shadow_coord[i]; \n" " vec3 coord = vec3(c.x, c.y, float(i)); \n" " if ( oe_shadow_blur > 0.0 ) \n" " { \n" " factor = min(factor, oe_shadow_multisample(coord, c.z-bias, oe_shadow_blur)); \n" " } \n" " else \n" " { \n" " float depth = texture2DArray(oe_shadow_map, coord).r; \n" " if ( depth < 1.0 && depth < c.z-bias ) \n" " factor = 0.0; \n" " } \n" " } \n" " vec4 colorInFullShadow = color * oe_shadow_color; \n" " color = mix(colorInFullShadow, color, factor); \n" " color.a = alpha;\n" "}\n"; VirtualProgram* vp = VirtualProgram::getOrCreate(_renderStateSet.get()); vp->setFunction( "oe_shadow_vertex", vertex, ShaderComp::LOCATION_VERTEX_VIEW, 0.9f ); vp->setFunction( "oe_shadow_fragment", fragment, ShaderComp::LOCATION_FRAGMENT_LIGHTING, 0.9f ); // the texture coord generator matrix array (from the caster): _shadowMapTexGenUniform = _renderStateSet->getOrCreateUniform( "oe_shadow_matrix", osg::Uniform::FLOAT_MAT4, numSlices ); // bind the shadow map texture itself: _renderStateSet->setTextureAttribute( _texImageUnit, _shadowmap.get(), osg::StateAttribute::ON ); _renderStateSet->addUniform( new osg::Uniform("oe_shadow_map", _texImageUnit) ); // blur factor: _shadowBlurUniform = _renderStateSet->getOrCreateUniform( "oe_shadow_blur", osg::Uniform::FLOAT); _shadowBlurUniform->set(_blurFactor); // shadow color: _shadowColorUniform = _renderStateSet->getOrCreateUniform( "oe_shadow_color", osg::Uniform::FLOAT_VEC4); _shadowColorUniform->set(_color); }
void DrapingTechnique::setUpCamera(OverlayDecorator::TechRTTParams& params) { // create the projected texture: osg::Texture2D* projTexture = new osg::Texture2D(); projTexture->setTextureSize( *_textureSize, *_textureSize ); projTexture->setInternalFormat( GL_RGBA ); projTexture->setSourceFormat( GL_RGBA ); projTexture->setSourceType( GL_UNSIGNED_BYTE ); projTexture->setFilter( osg::Texture::MIN_FILTER, _mipmapping? osg::Texture::LINEAR_MIPMAP_LINEAR: osg::Texture::LINEAR ); projTexture->setFilter( osg::Texture::MAG_FILTER, osg::Texture::LINEAR ); projTexture->setWrap( osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_BORDER ); projTexture->setWrap( osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_BORDER ); //projTexture->setWrap( osg::Texture::WRAP_R, osg::Texture::CLAMP_TO_EDGE ); projTexture->setBorderColor( osg::Vec4(0,0,0,0) ); // set up the RTT camera: params._rttCamera = new osg::Camera(); params._rttCamera->setClearColor( osg::Vec4f(0,0,0,0) ); // this ref frame causes the RTT to inherit its viewpoint from above (in order to properly // process PagedLOD's etc. -- it doesn't affect the perspective of the RTT camera though) params._rttCamera->setReferenceFrame( osg::Camera::ABSOLUTE_RF_INHERIT_VIEWPOINT ); params._rttCamera->setViewport( 0, 0, *_textureSize, *_textureSize ); params._rttCamera->setComputeNearFarMode( osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR ); params._rttCamera->setRenderOrder( osg::Camera::PRE_RENDER ); params._rttCamera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT ); params._rttCamera->attach( osg::Camera::COLOR_BUFFER, projTexture, 0, 0, _mipmapping ); if ( _attachStencil ) { // try a depth-packed buffer. failing that, try a normal one.. if the FBO doesn't support // that (which is doesn't on some GPUs like Intel), it will automatically fall back on // a PBUFFER_RTT impl if ( Registry::capabilities().supportsDepthPackedStencilBuffer() ) { #ifdef OSG_GLES2_AVAILABLE params._rttCamera->attach( osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, GL_DEPTH24_STENCIL8_EXT ); #else params._rttCamera->attach( osg::Camera::PACKED_DEPTH_STENCIL_BUFFER, GL_DEPTH_STENCIL_EXT ); #endif } else { params._rttCamera->attach( osg::Camera::STENCIL_BUFFER, GL_STENCIL_INDEX ); } params._rttCamera->setClearStencil( 0 ); params._rttCamera->setClearMask( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); } else { params._rttCamera->setClearMask( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); } // set up a StateSet for the RTT camera. osg::StateSet* rttStateSet = params._rttCamera->getOrCreateStateSet(); // lighting is off. We don't want draped items to be lit. rttStateSet->setMode( GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED ); // install a new default shader program that replaces anything from above. if ( _useShaders ) { VirtualProgram* vp = VirtualProgram::getOrCreate(rttStateSet); vp->setName( "DrapingTechnique RTT" ); vp->setInheritShaders( false ); //rttStateSet->setAttributeAndModes( vp, osg::StateAttribute::ON ); } // active blending within the RTT camera's FBO if ( _rttBlending ) { //Setup a separate blend function for the alpha components and the RGB components. //Because the destination alpha is initialized to 0 instead of 1 osg::BlendFunc* blendFunc = 0; if (Registry::capabilities().supportsGLSL(1.4f)) { //Blend Func Separate is only available on OpenGL 1.4 and above blendFunc = new osg::BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); } else { blendFunc = new osg::BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } rttStateSet->setAttributeAndModes(blendFunc, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); } else { rttStateSet->setMode(GL_BLEND, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE); } // attach the overlay group to the camera. // TODO: we should probably lock this since other cull traversals might be accessing the group // while we are changing its children. params._rttCamera->addChild( params._group ); // overlay geometry is rendered with no depth testing, and in the order it's found in the // scene graph... until further notice. rttStateSet->setMode(GL_DEPTH_TEST, 0); rttStateSet->setBinName( "TraversalOrderBin" ); // add to the terrain stateset, i.e. the stateset that the OverlayDecorator will // apply to the terrain before cull-traversing it. This will activate the projective // texturing on the terrain. params._terrainStateSet->setTextureAttributeAndModes( *_textureUnit, projTexture, osg::StateAttribute::ON ); // fire up the local per-view data: LocalPerViewData* local = new LocalPerViewData(); params._techniqueData = local; if ( _useShaders ) { // GPU path VirtualProgram* vp = VirtualProgram::getOrCreate(params._terrainStateSet); vp->setName( "DrapingTechnique terrain shaders"); //params._terrainStateSet->setAttributeAndModes( vp, osg::StateAttribute::ON ); // sampler for projected texture: params._terrainStateSet->getOrCreateUniform( "oe_overlay_tex", osg::Uniform::SAMPLER_2D )->set( *_textureUnit ); // the texture projection matrix uniform. local->_texGenUniform = params._terrainStateSet->getOrCreateUniform( "oe_overlay_texmatrix", osg::Uniform::FLOAT_MAT4 ); // vertex shader - subgraph std::string vs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "uniform mat4 oe_overlay_texmatrix; \n" "varying vec4 oe_overlay_texcoord; \n" "void oe_overlay_vertex(inout vec4 VertexVIEW) \n" "{ \n" " oe_overlay_texcoord = oe_overlay_texmatrix * VertexVIEW; \n" "} \n"; vp->setFunction( "oe_overlay_vertex", vs, ShaderComp::LOCATION_VERTEX_VIEW ); // fragment shader - subgraph std::string fs = "#version " GLSL_VERSION_STR "\n" GLSL_DEFAULT_PRECISION_FLOAT "\n" "uniform sampler2D oe_overlay_tex; \n" "varying vec4 oe_overlay_texcoord; \n" "void oe_overlay_fragment( inout vec4 color ) \n" "{ \n" " vec4 texel = texture2DProj(oe_overlay_tex, oe_overlay_texcoord); \n" " color = vec4( mix( color.rgb, texel.rgb, texel.a ), color.a); \n" "} \n"; vp->setFunction( "oe_overlay_fragment", fs, ShaderComp::LOCATION_FRAGMENT_COLORING ); } else { // FFP path local->_texGen = new osg::TexGen(); local->_texGen->setMode( osg::TexGen::EYE_LINEAR ); params._terrainStateSet->setTextureAttributeAndModes( *_textureUnit, local->_texGen.get(), 1 ); osg::TexEnv* env = new osg::TexEnv(); env->setMode( osg::TexEnv::DECAL ); params._terrainStateSet->setTextureAttributeAndModes( *_textureUnit, env, 1 ); } }
osg::StateSet* Text::createStateSet() { #if OSG_VERSION_GREATER_OR_EQUAL(3,5,8) // NOTE: Most of this is copied from the parent class, except for the // added osgEarth defines and the VirtualProgram in place of the Program. osgText::Font* activeFont = getActiveFont(); if (!activeFont) return 0; osgText::Font::StateSets& statesets = activeFont->getCachedStateSets(); std::stringstream ss; ss<<std::fixed<<std::setprecision(3); osg::StateSet::DefineList defineList; if (_backdropType!=NONE) { ss.str(""); ss << "vec4("<<_backdropColor.r()<<", "<<_backdropColor.g()<<", "<<_backdropColor.b()<<", "<<_backdropColor.a()<<")"; defineList["BACKDROP_COLOR"] = osg::StateSet::DefinePair(ss.str(), osg::StateAttribute::ON); if (_backdropType==OUTLINE) { ss.str(""); ss <<_backdropHorizontalOffset; defineList["OUTLINE"] = osg::StateSet::DefinePair(ss.str(), osg::StateAttribute::ON); } else { osg::Vec2 offset(_backdropHorizontalOffset, _backdropVerticalOffset); switch(_backdropType) { case(DROP_SHADOW_BOTTOM_RIGHT) : offset.set(_backdropHorizontalOffset, -_backdropVerticalOffset); break; case(DROP_SHADOW_CENTER_RIGHT) : offset.set(_backdropHorizontalOffset, 0.0f); break; case(DROP_SHADOW_TOP_RIGHT) : offset.set(_backdropHorizontalOffset, _backdropVerticalOffset); break; case(DROP_SHADOW_BOTTOM_CENTER) : offset.set(0.0f, -_backdropVerticalOffset); break; case(DROP_SHADOW_TOP_CENTER) : offset.set(0.0f, _backdropVerticalOffset); break; case(DROP_SHADOW_BOTTOM_LEFT) : offset.set(-_backdropHorizontalOffset, -_backdropVerticalOffset); break; case(DROP_SHADOW_CENTER_LEFT) : offset.set(-_backdropHorizontalOffset, 0.0f); break; case(DROP_SHADOW_TOP_LEFT) : offset.set(-_backdropHorizontalOffset, _backdropVerticalOffset); break; default : break; } ss.str(""); ss << "vec2("<<offset.x()<<", "<<offset.y()<<")"; defineList["SHADOW"] = osg::StateSet::DefinePair(ss.str(), osg::StateAttribute::ON); } } { ss<<std::fixed<<std::setprecision(1); ss.str(""); ss << float(_fontSize.second); defineList["GLYPH_DIMENSION"] = osg::StateSet::DefinePair(ss.str(), osg::StateAttribute::ON); ss.str(""); ss << float(activeFont->getTextureWidthHint()); defineList["TEXTURE_DIMENSION"] = osg::StateSet::DefinePair(ss.str(), osg::StateAttribute::ON); } if (_shaderTechnique>osgText::GREYSCALE) { defineList["SIGNED_DISTANCE_FIELD"] = osg::StateSet::DefinePair("1", osg::StateAttribute::ON); } #if 0 OSG_NOTICE<<"Text::createStateSet() defines:"<<defineList.size()<<std::endl; for(osg::StateSet::DefineList::iterator itr = defineList.begin(); itr != defineList.end(); ++itr) { OSG_NOTICE<<" define["<<itr->first<<"] = "<<itr->second.first<<std::endl; } #endif // osgEarth:: add defines #if defined(OSG_GL3_AVAILABLE) && !defined(OSG_GL2_AVAILABLE) && !defined(OSG_GL1_AVAILABLE) defineList["OSGTEXT_GLYPH_ALPHA_FORMAT_IS_RED"] = osg::StateSet::DefinePair("1", osg::StateAttribute::ON); #endif defineList[OE_LIGHTING_DEFINE] = osg::StateSet::DefinePair("", osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED); // The remaining of this method is exclusive so we don't corrupt the // stateset cache when creating text objects from multiple threads. -gw static Threading::Mutex mutex; Threading::ScopedMutexLock lock(mutex); if (!statesets.empty()) { for(osgText::Font::StateSets::iterator itr = statesets.begin(); itr != statesets.end(); ++itr) { if ((*itr)->getDefineList()==defineList) { // OSG_NOTICE<<"Text::createStateSet() : Matched DefineList, return StateSet "<<itr->get()<<std::endl; return itr->get(); } else { } } } osg::ref_ptr<osg::StateSet> stateset = new osg::StateSet; stateset->setDefineList(defineList); statesets.push_back(stateset.get()); stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN); stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF); stateset->setMode(GL_BLEND, osg::StateAttribute::ON); #if defined(OSG_GL_FIXED_FUNCTION_AVAILABLE) osg::DisplaySettings::ShaderHint shaderHint = osg::DisplaySettings::instance()->getShaderHint(); if (_shaderTechnique==osgText::NO_TEXT_SHADER && shaderHint==osg::DisplaySettings::SHADER_NONE) { stateset->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::ON); return stateset.release(); } #endif // set up the StateSet to use shaders stateset->addUniform(new osg::Uniform("glyphTexture", 0)); // osgEarth: add shaders VirtualProgram* vp = VirtualProgram::getOrCreate(stateset.get()); vp->setName("osgEarth::Text"); osgEarth::Shaders coreShaders; coreShaders.load(vp, coreShaders.TextVertex); coreShaders.load(vp, coreShaders.TextFragment); return stateset.release(); #else return 0L; #endif }
// 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 //terrainStateSet->setRenderBinDetails(0, "SORT_FRONT_TO_BACK"); // required for multipass tile rendering to work surfaceStateSet->setAttributeAndModes( new osg::Depth(osg::Depth::LEQUAL, 0, 1, true) ); surfaceStateSet->setAttributeAndModes( new osg::CullFace(), osg::StateAttribute::ON); // 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); surfaceStateSet->addUniform(new osg::Uniform("oe_terrain_color", _terrainOptions.color().get())); if (_terrainOptions.enableBlending() == true) { surfaceStateSet->setDefine("OE_TERRAIN_BLEND_IMAGERY"); } // 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); // Elevation? if (this->elevationTexturesRequired()) { surfaceStateSet->setDefine("OE_TERRAIN_RENDER_ELEVATION"); } // Normal mapping shaders: if ( this->normalTexturesRequired() ) { package.load(surfaceVP, package.NORMAL_MAP_VERT); package.load(surfaceVP, package.NORMAL_MAP_FRAG); surfaceStateSet->setDefine("OE_TERRAIN_RENDER_NORMAL_MAP"); } // Morphing? if (_terrainOptions.morphTerrain() == true || _terrainOptions.morphImagery() == true) { package.load(surfaceVP, package.MORPHING_VERT); if (_terrainOptions.morphImagery() == true) { surfaceStateSet->setDefine("OE_TERRAIN_MORPH_IMAGERY"); } if (_terrainOptions.morphTerrain() == true) { surfaceStateSet->setDefine("OE_TERRAIN_MORPH_GEOMETRY"); } } // 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; ImageLayerVector imageLayers; _update_mapf->getLayers(imageLayers); for( int i=0; i<imageLayers.size(); ++i ) { ImageLayer* layer = imageLayers.at(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.6 ); } } // Apply uniforms for sampler bindings: OE_DEBUG << LC << "Render Bindings:\n"; osg::ref_ptr<osg::Texture> tex = new osg::Texture2D(ImageUtils::createEmptyImage(1,1)); for (unsigned i = 0; i < _renderBindings.size(); ++i) { SamplerBinding& b = _renderBindings[i]; if (b.isActive()) { osg::Uniform* u = new osg::Uniform(b.samplerName().c_str(), b.unit()); terrainStateSet->addUniform( u ); OE_DEBUG << LC << " > Bound \"" << b.samplerName() << "\" to unit " << b.unit() << "\n"; terrainStateSet->setTextureAttribute(b.unit(), tex.get()); } } // 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->addUniform( new osg::Uniform("oe_layer_attenuationRange", _terrainOptions.attentuationDistance().get()) ); 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; } }
// 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(); // 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 ); // bind the vertex attributes generated by the tile compiler. vp->addBindAttribLocation( "oe_terrain_attr", osg::Drawable::ATTRIBUTE_6 ); vp->addBindAttribLocation( "oe_terrain_attr2", osg::Drawable::ATTRIBUTE_7 ); 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.loadFunction( vp, package.VertexModel ); package.loadFunction( vp, package.VertexView ); package.loadFunction( vp, package.Fragment ); // 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)); // 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. 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( 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", -1.0f) ); 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) ); } _stateUpdateRequired = false; } }
osg::Node* createFramebufferPass(App& app) { osg::Node* quad = createFramebufferQuad(app); osg::StateSet* stateset = quad->getOrCreateStateSet(); static const char* vertSource = "varying vec4 texcoord;\n" "void effect_vert(inout vec4 vertexView)\n" "{\n" " texcoord = gl_MultiTexCoord0; \n" "}\n"; static const char* fragSource = "#version 120\n" "#extension GL_ARB_texture_rectangle : enable\n" "uniform sampler2DRect gcolor;\n" "uniform sampler2DRect gnormal;\n" "uniform sampler2DRect gdepth;\n" "varying vec4 texcoord;\n" "void effect_frag(inout vec4 color)\n" "{\n" " color = texture2DRect(gcolor, texcoord.st); \n" " float depth = texture2DRect(gdepth, texcoord.st).r; \n" " vec3 normal = texture2DRect(gnormal,texcoord.st).xyz *2.0-1.0; \n" // sample radius in pixels: " float e = 5.0; \n" // sample the normals around our pixel and find the approximate // deviation from our center normal: " vec3 avgNormal =\n" " texture2DRect(gnormal, texcoord.st+vec2( e, e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2(-e, e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2(-e,-e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2( e,-e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2( 0, e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2( e, 0)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2( 0,-e)).xyz + \n" " texture2DRect(gnormal, texcoord.st+vec2(-e, 0)).xyz; \n" " avgNormal = normalize((avgNormal/8.0)*2.0-1.0); \n" " float deviation = clamp(dot(normal, avgNormal),0.0,1.0); \n" // set a blur factor based on the normal deviation, so that we // blur more around edges. " e = 2.5 * (1.0-deviation); \n" " vec4 blurColor = \n" " color + \n" " texture2DRect(gcolor, texcoord.st+vec2( e, e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2(-e, e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2(-e,-e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2( e,-e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2( 0, e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2( e, 0)) + \n" " texture2DRect(gcolor, texcoord.st+vec2( 0,-e)) + \n" " texture2DRect(gcolor, texcoord.st+vec2(-e, 0)); \n" " blurColor /= 9.0; \n" // blur the color and darken the edges at the same time " color.rgb = blurColor.rgb * deviation; \n" "}\n"; VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); vp->setFunction("effect_vert", vertSource, ShaderComp::LOCATION_VERTEX_VIEW); vp->setFunction("effect_frag", fragSource, ShaderComp::LOCATION_FRAGMENT_COLORING); stateset->setTextureAttributeAndModes(0, app.gcolor, 1); stateset->addUniform(new osg::Uniform("gcolor", 0)); stateset->setTextureAttributeAndModes(1, app.gnormal, 1); stateset->addUniform(new osg::Uniform("gnormal", 1)); stateset->setTextureAttributeAndModes(2, app.gdepth, 1); stateset->addUniform(new osg::Uniform("gdepth", 2)); stateset->setMode( GL_LIGHTING, 0 ); float w = app.gcolor->getTextureWidth(); float h = app.gcolor->getTextureHeight(); osg::Camera* camera = new osg::Camera(); camera->setReferenceFrame( osg::Transform::ABSOLUTE_RF ); camera->setViewMatrix( osg::Matrix::identity() ); camera->setProjectionMatrixAsOrtho2D( -w/2, (-w/2)+w, -h/2, (-h/2)+h ); camera->addChild( quad ); return camera; }
void MapNode::init() { // Take a reference to this object so that it doesn't get inadvertently // deleting during startup. It is possible that during startup, a driver // will load that will take a reference to the MapNode (like in a // ModelSource node operation) and we don't want that deleting the MapNode // out from under us. // This is paired by an unref_nodelete() at the end of this method. this->ref(); // Protect the MapNode from the Optimizer setDataVariance(osg::Object::DYNAMIC); // initialize 0Ls _terrainEngine = 0L; _terrainEngineContainer = 0L; _overlayDecorator = 0L; setName( "osgEarth::MapNode" ); // Since we have global uniforms in the stateset, mark it dynamic so it is immune to // multi-threaded overlap // TODO: do we need this anymore? there are no more global uniforms in here.. gw getOrCreateStateSet()->setDataVariance(osg::Object::DYNAMIC); _modelLayerCallback = new MapModelLayerCallback(this); _maskLayerNode = 0L; _lastNumBlacklistedFilenames = 0; // Set the global proxy settings // TODO: this should probably happen elsewhere, like in the registry? if ( _mapNodeOptions.proxySettings().isSet() ) { HTTPClient::setProxySettings( _mapNodeOptions.proxySettings().get() ); } // establish global driver options. These are OSG reader-writer options that // will make their way to any read* calls down the pipe const osgDB::Options* global_options = _map->getGlobalOptions(); osg::ref_ptr<osgDB::Options> local_options = global_options ? Registry::instance()->cloneOrCreateOptions( global_options ) : NULL; if ( local_options.valid() ) { OE_INFO << LC << "Options string = " << (local_options.valid()? local_options->getOptionString() : "<empty>") << std::endl; } // TODO: not sure why we call this here _map->setGlobalOptions( local_options.get() ); // load and attach the terrain engine, but don't initialize it until we need it const TerrainOptions& terrainOptions = _mapNodeOptions.getTerrainOptions(); _terrainEngine = TerrainEngineNodeFactory::create( _map.get(), terrainOptions ); _terrainEngineInitialized = false; // the engine needs a container so we can set lighting state on the container and // not on the terrain engine itself. Setting the dynamic variance will prevent // an optimizer from collapsing the empty group node. _terrainEngineContainer = new osg::Group(); _terrainEngineContainer->setDataVariance( osg::Object::DYNAMIC ); this->addChild( _terrainEngineContainer ); // initialize terrain-level lighting: if ( terrainOptions.enableLighting().isSet() ) { _terrainEngineContainer->getOrCreateStateSet()->setMode( GL_LIGHTING, terrainOptions.enableLighting().value() ? 1 : 0 ); } if ( _terrainEngine ) { // inform the terrain engine of the map information now so that it can properly // initialize it's CoordinateSystemNode. This is necessary in order to support // manipulators and to set up the texture compositor prior to frame-loop // initialization. _terrainEngine->preInitialize( _map.get(), terrainOptions ); _terrainEngineContainer->addChild( _terrainEngine ); } else { OE_WARN << "FAILED to create a terrain engine for this map" << std::endl; } // make a group for the model layers. // NOTE: for now, we are going to nullify any shader programs that occur above the model // group, since it does not YET support shader composition. Programs defined INSIDE a // model layer will still work OK though. _models = new osg::Group(); _models->setName( "osgEarth::MapNode.modelsGroup" ); addChild( _models.get() ); // make a group for overlay model layers: _overlayModels = new ObserverGroup(); //osg::Group(); _overlayModels->setName( "osgEarth::MapNode.overlayModelsGroup" ); // a decorator for overlay models: _overlayDecorator = new OverlayDecorator(); _overlayDecorator->setOverlayGraphTraversalMask( terrainOptions.secondaryTraversalMask().value() ); if ( _mapNodeOptions.overlayBlending().isSet() ) _overlayDecorator->setOverlayBlending( *_mapNodeOptions.overlayBlending() ); if ( _mapNodeOptions.overlayTextureSize().isSet() ) _overlayDecorator->setTextureSize( *_mapNodeOptions.overlayTextureSize() ); if ( _mapNodeOptions.overlayMipMapping().isSet() ) _overlayDecorator->setMipMapping( *_mapNodeOptions.overlayMipMapping() ); addTerrainDecorator( _overlayDecorator ); // install any pre-existing model layers: ModelLayerVector modelLayers; _map->getModelLayers( modelLayers ); int modelLayerIndex = 0; for( ModelLayerVector::const_iterator k = modelLayers.begin(); k != modelLayers.end(); k++, modelLayerIndex++ ) { onModelLayerAdded( k->get(), modelLayerIndex ); } _mapCallback = new MapNodeMapCallbackProxy(this); // install a layer callback for processing further map actions: _map->addMapCallback( _mapCallback.get() ); osg::StateSet* ss = getOrCreateStateSet(); if ( _mapNodeOptions.enableLighting().isSet() ) { ss->setMode( GL_LIGHTING, _mapNodeOptions.enableLighting().value() ? 1 : 0 ); } dirtyBound(); // Install top-level shader programs: if ( Registry::capabilities().supportsGLSL() ) { VirtualProgram* vp = new VirtualProgram(); vp->setName( "MapNode" ); vp->installDefaultColoringAndLightingShaders(); ss->setAttributeAndModes( vp, osg::StateAttribute::ON ); } // register for event traversals so we can deal with blacklisted filenames ADJUST_EVENT_TRAV_COUNT( this, 1 ); // remove the temporary reference. this->unref_nodelete(); }
void makeVisibleVP(osg::StateSet* ss) { VirtualProgram* vp = VirtualProgram::getOrCreate(ss); vp->setFunction("oe_instancing_setPos", IG_VS, ShaderComp::LOCATION_VERTEX_MODEL, -FLT_MAX); vp->addBindAttribLocation( "xfb_position", XFB_SLOT ); }