void PointDrawable::setupState() { // Create the singleton state set for the shader. This stateset will be // shared by all PointDrawable instances so OSG will sort them together. if (!_sharedStateSet.valid()) { static Threading::Mutex s_mutex; s_mutex.lock(); if (!_sharedStateSet.valid()) { _sharedStateSet = new osg::StateSet(); _sharedStateSet->setTextureAttributeAndModes(0, new osg::PointSprite(), osg::StateAttribute::ON); if (_gpu) { VirtualProgram* vp = VirtualProgram::getOrCreate(_sharedStateSet.get()); Shaders shaders; shaders.load(vp, shaders.PointDrawable); _sharedStateSet->setMode(GL_PROGRAM_POINT_SIZE, 1); } else { //todo } s_isCoreProfile = Registry::capabilities().isCoreProfile(); } s_mutex.unlock(); } }
void ContourMap::onUninstall(TerrainEngineNode* engine) { if ( engine ) { osg::StateSet* stateset = engine->getStateSet(); if ( stateset ) { stateset->removeUniform( _xferMin.get() ); stateset->removeUniform( _xferRange.get() ); stateset->removeUniform( _xferSampler.get() ); stateset->removeUniform( _opacityUniform.get() ); stateset->removeTextureAttribute( _unit, osg::StateAttribute::TEXTURE ); VirtualProgram* vp = VirtualProgram::get(stateset); if ( vp ) { Shaders pkg; pkg.unload(vp, pkg.ContourMap_Vertex); pkg.unload(vp, pkg.ContourMap_Fragment); } } if ( _unit >= 0 ) { engine->getResources()->releaseTextureImageUnit( _unit ); _unit = -1; } } }
void ShaderComposer::addShaderToProgram(Program* program, const Shaders& shaders) { ShaderMainMap::iterator itr = _shaderMainMap.find(shaders); if (itr == _shaderMainMap.end()) { // no vertex shader in map yet, need to compose a new main shader osg::Shader* mainShader = composeMain(shaders); _shaderMainMap[shaders] = mainShader; program->addShader(mainShader); } else { program->addShader(itr->second.get()); } for(Shaders::const_iterator itr = shaders.begin(); itr != shaders.end(); ++itr) { Shader* shader = const_cast<Shader*>(*itr); if (!(shader->getShaderSource().empty()) || shader->getShaderBinary()) { program->addShader(shader); } } }
void BumpMapTerrainEffect::onUninstall(TerrainEngineNode* engine) { osg::StateSet* stateset = engine->getStateSet(); if ( stateset ) { if ( _bumpMapTex.valid() ) { stateset->removeUniform("oe_bumpmap_maxRange"); stateset->removeUniform("oe_bumpmap_octaves"); stateset->removeUniform( _scaleUniform.get() ); stateset->removeUniform( _intensityUniform.get() ); stateset->removeUniform( _bumpMapTexUniform.get() ); stateset->removeTextureAttribute( _bumpMapUnit, osg::StateAttribute::TEXTURE ); } VirtualProgram* vp = VirtualProgram::get(stateset); if ( vp ) { Shaders pkg; pkg.unloadAll( vp ); } } if ( _bumpMapUnit >= 0 ) { engine->getResources()->releaseTextureImageUnit( _bumpMapUnit ); _bumpMapUnit = -1; } }
void LogarithmicDepthBuffer::install(osg::Camera* camera) { if ( camera && _supported ) { // install the shader component: osg::StateSet* stateset = camera->getOrCreateStateSet(); if ( _useFragDepth ) { stateset->addUniform( new osg::Uniform(C_UNIFORM, (float)NEAR_RES_COEFF) ); } VirtualProgram* vp = VirtualProgram::getOrCreate( stateset ); Shaders pkg; if ( _useFragDepth ) { pkg.loadFunction( vp, pkg.LogDepthBuffer_VertFile ); pkg.loadFunction( vp, pkg.LogDepthBuffer_FragFile ); } else { pkg.loadFunction( vp, pkg.LogDepthBuffer_VertOnly_VertFile ); } osg::ref_ptr<osg::Camera::DrawCallback> next = camera->getPreDrawCallback(); if ( dynamic_cast<SetFarPlaneUniformCallback*>(next.get()) ) next = static_cast<SetFarPlaneUniformCallback*>(next.get())->_next.get(); stateset->addUniform( _FCUniform.get() ); camera->setPreDrawCallback( new SetFarPlaneUniformCallback(_FCUniform.get(), next.get()) ); } }
void BumpMapTerrainEffect::onInstall(TerrainEngineNode* engine) { if ( engine && _bumpMapTex.valid() ) { osg::StateSet* stateset = engine->getTerrainStateSet(); // install the NormalMap texture array: if ( engine->getResources()->reserveTextureImageUnit(_bumpMapUnit, "BumpMap") ) { // NormalMap sampler _bumpMapTexUniform = stateset->getOrCreateUniform(BUMP_SAMPLER, osg::Uniform::SAMPLER_2D); _bumpMapTexUniform->set( _bumpMapUnit ); stateset->setTextureAttribute( _bumpMapUnit, _bumpMapTex.get(), osg::StateAttribute::ON ); // configure shaders VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); Shaders package; package.define( "OE_USE_NORMAL_MAP", engine->normalTexturesRequired() ); package.loadFunction( vp, package.VertexModel ); package.loadFunction( vp, package.VertexView ); package.loadFunction( vp, _octaves <= 1? package.FragmentSimple : package.FragmentProgressive ); if ( _octaves > 1 ) stateset->addUniform(new osg::Uniform("oe_bumpmap_octaves", _octaves)); stateset->addUniform(new osg::Uniform("oe_bumpmap_maxRange", _maxRange)); stateset->addUniform( _scaleUniform.get() ); stateset->addUniform( _intensityUniform.get() ); } } }
RexTerrainEngineNode::RexTerrainEngineNode() : TerrainEngineNode ( ), _terrain ( 0L ), _update_mapf ( 0L ), _tileCount ( 0 ), _tileCreationTime ( 0.0 ), _batchUpdateInProgress( false ), _refreshRequired ( false ), _stateUpdateRequired ( false ) { // 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); 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 LogarithmicDepthBuffer::uninstall(osg::Camera* camera) { if ( camera && _supported ) { SetFarPlaneUniformCallback* dc = dynamic_cast<SetFarPlaneUniformCallback*>(camera->getPreDrawCallback()); if ( dc ) { osg::ref_ptr<osg::Camera::DrawCallback> next = dc->_next.get(); camera->setPreDrawCallback( next.get() ); } osg::StateSet* stateset = camera->getStateSet(); if ( stateset ) { VirtualProgram* vp = VirtualProgram::get( camera->getStateSet() ); if ( vp ) { Shaders pkg; pkg.unloadFunction( vp, pkg.LogDepthBuffer_FragFile ); pkg.unloadFunction( vp, pkg.LogDepthBuffer_VertFile ); pkg.unloadFunction( vp, pkg.LogDepthBuffer_VertOnly_VertFile ); } stateset->removeUniform( FC_UNIFORM ); stateset->removeUniform( C_UNIFORM ); } } }
int main( int argc, char **argv ) { try { size_t N = 13; size_t bufSize = 4 * N; float *buf = new float[bufSize]; for( size_t i = 0; i < N; ++i ) { buf[4*i] = cosf( 2 * 3.1415f * float( i ) / float( N - 1 ) ); buf[4*i+1] = sinf( 2 * 3.1415f * float( i ) / float( N - 1 ) ); buf[4*i+2] = 0.0f; buf[4*i+3] = 1.0f; std::cout << buf[4*i] << " " << buf[4*i+1]; std::cout << " " << buf[4*i+2] << " " << buf[4*i+3] << "\n"; } Shaders shaders; shaders.addToVertexList( nBodyShaders::vertex1 ); shaders.addToFragmentList( nBodyShaders::fragment1 ); NBodyWindow window{ "N-Body Simulation", GlutWrapper::NDEBUG }; window.init( argc, argv, 500, 500, &shaders, bufSize, buf ); window.run(); delete [] buf; return 0; } catch( const std::exception &e ) { std::cerr << "Error: " << e.what() << "\n"; return 1; } }
void FogEffect::attach( osg::StateSet* stateSet ) { VirtualProgram* vp = VirtualProgram::getOrCreate( stateSet ); Shaders pkg; pkg.load( vp, pkg.Fog_Vertex ); pkg.load( vp, pkg.Fog_Fragment ); _statesets.push_back(stateSet); }
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)); // shader package: Shaders shaders; if ( uninstall ) { OE_TEST << LC << "Removing depth offset shaders" << std::endl; // uninstall uniforms and shaders. osg::StateSet* s = _graph->getStateSet(); s->removeUniform( _minBiasUniform.get() ); s->removeUniform( _maxBiasUniform.get() ); s->removeUniform( _minRangeUniform.get() ); s->removeUniform( _maxRangeUniform.get() ); shaders.unloadFunction( VirtualProgram::get(s), shaders.DepthOffsetVertex ); } if ( install ) { OE_TEST << LC << "Installing depth offset shaders" << std::endl; // install uniforms and shaders. osg::StateSet* s = graph->getOrCreateStateSet(); s->addUniform( _minBiasUniform.get() ); s->addUniform( _maxBiasUniform.get() ); s->addUniform( _minRangeUniform.get() ); s->addUniform( _maxRangeUniform.get() ); shaders.loadFunction(VirtualProgram::getOrCreate(s), shaders.DepthOffsetVertex); } 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 FogEffect::detach( osg::StateSet* stateSet ) { VirtualProgram* vp = VirtualProgram::get(stateSet); if ( vp ) { Shaders pkg; pkg.unload( vp, pkg.Fog_Vertex ); pkg.unload( vp, pkg.Fog_Fragment ); } }
void AlphaEffect::detach(osg::StateSet* stateset) { if ( stateset && _installed ) { stateset->removeUniform( _alphaUniform.get() ); VirtualProgram* vp = VirtualProgram::get( stateset ); if ( vp ) { Shaders pkg; pkg.unload( vp, pkg.AlphaEffectFragment ); } } }
void DrawInstanced::remove(osg::StateSet* stateset) { if ( !stateset ) return; VirtualProgram* vp = VirtualProgram::get(stateset); if ( !vp ) return; Shaders pkg; pkg.unload( vp, pkg.InstancingVertex ); stateset->removeUniform("oe_di_postex_TBO"); }
void AlphaEffect::install(osg::StateSet* stateset) { if (stateset) { VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); if (vp) { vp->setName( "osgEarth.AlphaEffect" ); Shaders pkg; pkg.load(vp, pkg.AlphaEffectFragment); stateset->addUniform(_alphaUniform.get()); } } }
void Mesh::Draw(Shaders & shader) { unsigned int diffuseNr = 1; unsigned int specularNr = 1; unsigned int normalNr = 1; unsigned int heightNr = 1; for(size_t i = 0; i < this->_textures.size(); i++) { glActiveTexture(GL_TEXTURE0 + i); // activate proper texture unit before binding // retrieve texture number (the N in diffuse_textureN) std::string number; std::string name = this->_textures[i]._type; if(name == "texture_diffuse") number = std::to_string(diffuseNr++); else if(name == "texture_specular") number = std::to_string(specularNr++); else if(name == "texture_normal") number = std::to_string(normalNr++); else if(name == "texture_height") number = std::to_string(heightNr++); glUniform1i(glGetUniformLocation(shader.ID(), (name + number).c_str()), i); glBindTexture(GL_TEXTURE_2D, this->_textures[i]._id); } // draw mesh glBindVertexArray(VAO); glDrawElements(GL_TRIANGLES, this->_indices.size(), GL_UNSIGNED_INT, 0); glBindVertexArray(0); glActiveTexture(GL_TEXTURE0); }
int _tmain(int argc, _TCHAR* argv[]) { ESContext esContext; esInitContext ( &esContext ); esCreateWindow ( &esContext, "Hello Model", Globals::screenWidth, Globals::screenHeight, ES_WINDOW_RGB | ES_WINDOW_DEPTH); if ( Init ( &esContext ) != 0 ) return 0; if (ppShaders.Init("../Resources/Shaders/PPShaderVS.vs", "../Resources/Shaders/PPShaderFS.fs") != 0) return 0; esRegisterDrawFunc ( &esContext, Draw ); esRegisterUpdateFunc ( &esContext, Update ); esRegisterKeyFunc ( &esContext, Key); esMainLoop ( &esContext ); //releasing OpenGL resources CleanUp(); //identifying memory leaks MemoryDump(); printf("Press any key...\n"); _getch(); return 0; }
int Init ( ESContext *esContext ) { glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f ); //triangle data (heap) Vertex verticesData[3]; RotationMatrix.SetIdentity(); verticesData[0].pos.x = 0.0f; verticesData[0].pos.y = 0.5f; verticesData[0].pos.z = 0.0f; verticesData[1].pos.x = -0.5f; verticesData[1].pos.y = -0.5f; verticesData[1].pos.z = 0.0f; verticesData[2].pos.x = 0.5f; verticesData[2].pos.y = -0.5f; verticesData[2].pos.z = 0.0f; verticesData[0].color.x = 0.5f; verticesData[0].color.y = 1.0f; verticesData[0].color.z = 0.3f; verticesData[1].color.x = 0.0f; verticesData[1].color.y = 0.3f; verticesData[1].color.z = 0.0f; verticesData[2].color.x = 0.1f; verticesData[2].color.y = 0.1f; verticesData[2].color.z = 0.3f; //buffer object glGenBuffers(1, &vboId); //buffer object name generation glBindBuffer(GL_ARRAY_BUFFER, vboId); //buffer object binding glBufferData(GL_ARRAY_BUFFER, sizeof(verticesData), verticesData, GL_STATIC_DRAW); //creation and initializion of buffer onject storage glBindBuffer(GL_ARRAY_BUFFER, 0); //creation of shaders and program return myShaders.Init("../Resources/Shaders/TriangleShaderVS.vs", "../Resources/Shaders/TriangleShaderFS.fs"); }
bool Application::Init(std::string title, int xpos, int ypos, int width,int height, int flags) { std::string tempTitle; tempTitle= title + " " + GIT_DESCRIBE_VERSION; if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { return false; } //if (SDL_CreateWindowAndRenderer(width, height, SDL_WINDOW_OPENGL, &pWindow, &pRenderer) < 0) pWindow = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_SHOWN|SDL_WINDOW_OPENGL); if (pWindow == NULL) { return false; } mainContext = SDL_GL_CreateContext(pWindow); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetSwapInterval(1); GLenum glewError = glewInit(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); //Initialize Modelview Matrix glMatrixMode(GL_MODELVIEW); glLoadIdentity(); AudioManager::Get().Init(); bRunning = true; Shaders * pTempShader = new Shaders(); pTempShader->LoadFromFile("simple"); return true; }
int Init ( ESContext *esContext ) { glClearColor ( 0.0f, 0.0f, 0.0f, 1.0f ); glEnable(GL_DEPTH_TEST); //triangle data (heap) FILE *pFile; fopen_s(&pFile, "../Resources/Models/Woman1.nfg", "r"); fscanf_s(pFile, "NrVertices: %d", &vertices); Vertex *verticesData = new Vertex[vertices]; for (int i = 0; i<vertices; i++) { fscanf_s(pFile, " %*d. pos:[%f, %f, %f]; norm:[%*f, %*f, %*f]; binorm:[%*f, %*f, %*f]; tgt:[%*f, %*f, %*f]; uv:[%f, %f]; ", &verticesData[i].pos.x, &verticesData[i].pos.y, &verticesData[i].pos.z, &verticesData[i].uv.x, &verticesData[i].uv.y); } //buffer object glGenBuffers(1, &vboId); //buffer object name generation glBindBuffer(GL_ARRAY_BUFFER, vboId); //buffer object binding glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vertices, verticesData, GL_STATIC_DRAW); //creation and initializion of buffer onject storage glBindBuffer(GL_ARRAY_BUFFER, 0); fscanf_s(pFile, "NrIndices: %d", &indices); Index *indicesData = new Index[indices]; for (int i = 0; i<indices/3; i++) { fscanf_s(pFile, " %*d. %u, %u, %u ", &indicesData[i].x, &indicesData[i].y, &indicesData[i].z); } glGenBuffers(1, &iboId); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboId); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*indices, indicesData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); fclose(pFile); glGenTextures(1, &textureHandle); glBindTexture(GL_TEXTURE_2D, textureHandle); int width, height, bpp; char* bufferTGA = LoadTGA("../Resources/Textures/Woman1.tga", &width, &height, &bpp); if (bpp == 24) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, bufferTGA); } else { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bufferTGA); } delete []bufferTGA; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenerateMipmap(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); delete []verticesData; delete []indicesData; //creation of shaders and program return myShaders.Init("../Resources/Shaders/TriangleShaderVS.vs", "../Resources/Shaders/TriangleShaderFS.fs"); }
void GeodeticGraticule::installEffect() { if (_mapNode.valid() == false) return; // shader components osg::StateSet* stateset = _mapNode->getTerrainEngine()->getSurfaceStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); // configure shaders Shaders package; package.load(vp, package.Graticule_Vertex); package.load(vp, package.Graticule_Fragment); stateset->addUniform(new osg::Uniform(COLOR_UNIFORM, options().color().get())); stateset->addUniform(new osg::Uniform(WIDTH_UNIFORM, options().lineWidth().get())); }
void GraticuleTerrainEffect::onUninstall(TerrainEngineNode* engine) { osg::StateSet* stateset = engine->getTerrainStateSet(); if ( stateset ) { VirtualProgram* vp = VirtualProgram::get(stateset); if ( vp ) { Shaders package; package.unloadFunction( vp, package.Graticule_Vertex ); package.unloadFunction( vp, package.Graticule_Fragment ); stateset->removeUniform( GraticuleOptions::resolutionUniformName() ); stateset->removeUniform( GraticuleOptions::colorUniformName() ); stateset->removeUniform( GraticuleOptions::lineWidthUniformName() ); } } }
GroundPlane::GroundPlane(Shaders& shaders) : mesh_{ createIndexBufferObject(ground_indices), { createArrayBufferObject( ground_vertices, shaders.getAttributes(Attribute::VERTEX), 3), createArrayBufferObject( ground_normals, shaders.getAttributes(Attribute::NORMAL), 3), } }, model_matrix_(shaders, glm::rotate(glm::scale(glm::mat4(), glm::vec3(20.0f)), 90.0f, glm::vec3(1, 0, 0))), blue_uniform_(shaders.getUniforms(Uniform::BLUE)) { }
void BumpMapTerrainEffect::onInstall(TerrainEngineNode* engine) { if ( engine && _bumpMapTex.valid() ) { osg::StateSet* stateset = engine->getSurfaceStateSet(); // install the NormalMap texture array: if ( engine->getResources()->reserveTextureImageUnit(_bumpMapUnit, "BumpMap") ) { // NormalMap sampler _bumpMapTexUniform = stateset->getOrCreateUniform(BUMP_SAMPLER, osg::Uniform::SAMPLER_2D); _bumpMapTexUniform->set( _bumpMapUnit ); stateset->setTextureAttribute( _bumpMapUnit, _bumpMapTex.get() ); // configure shaders VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); Shaders package; package.define( "OE_USE_NORMAL_MAP", false ); //engine->normalTexturesRequired() ); //package.load( vp, package.VertexModel ); package.load( vp, package.VertexView ); package.load( vp, _octaves <= 1? package.FragmentSimple : package.FragmentProgressive ); if ( _octaves > 1 ) stateset->addUniform(new osg::Uniform("oe_bumpmap_octaves", _octaves)); stateset->addUniform(new osg::Uniform("oe_bumpmap_maxRange", _maxRange)); stateset->addUniform(new osg::Uniform("oe_bumpmap_slopeFactor", 1.0f)); stateset->addUniform(new osg::Uniform("oe_bumpmap_baseLOD", (float)_baseLOD)); stateset->addUniform( _scaleUniform.get() ); stateset->addUniform( _intensityUniform.get() ); } else { OE_WARN << LC << "Failed to allocation a texture image unit!\n"; } } }
RexTerrainEngineNode::RexTerrainEngineNode() : TerrainEngineNode ( ), _terrain ( 0L ), _update_mapf ( 0L ), _tileCount ( 0 ), _tileCreationTime ( 0.0 ), _batchUpdateInProgress( false ), _refreshRequired ( false ), _stateUpdateRequired ( false ), _selectionInfo ( 0L ) { // unique ID for this engine: _uid = Registry::instance()->createUID(); // always require elevation. _requireElevationTextures = true; // Register our render bins protos. { // Mutex because addRenderBinPrototype isn't thread-safe. Threading::ScopedMutexLock lock(_renderBinMutex); // generate uniquely named render bin prototypes for this engine: //_surfaceRenderBinPrototype = new SurfaceBin(); //osgUtil::RenderBin::addRenderBinPrototype( _surfaceRenderBinPrototype->getName(), _surfaceRenderBinPrototype.get() ); } // 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); Shaders package; package.load(vp, package.SDK); } _surfaceSS = new osg::StateSet(); }
void GeodeticGraticule::removeEffect() { if (_mapNode.valid() == false) return; osg::StateSet* stateset = _mapNode->getTerrainEngine()->getSurfaceStateSet(); if ( stateset ) { VirtualProgram* vp = VirtualProgram::get(stateset); if ( vp ) { Shaders package; package.unload( vp, package.Graticule_Vertex ); package.unload( vp, package.Graticule_Fragment ); stateset->removeUniform( COLOR_UNIFORM ); stateset->removeUniform( WIDTH_UNIFORM ); } } }
int Init ( ESContext *esContext ) { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glEnable(GL_DEPTH_TEST); m.SetIdentity(); woman.loadModel("../Resources/Models/Woman1.nfg"); woman.loadTexture("../Resources/Textures/Woman1.tga"); //creation of shaders and program return myShaders.Init("../Resources/Shaders/TriangleShaderVS.vs", "../Resources/Shaders/TriangleShaderFS.fs"); }
void NormalMapTerrainEffect::onUninstall(TerrainEngineNode* engine) { osg::StateSet* stateset = engine->getStateSet(); if ( stateset ) { VirtualProgram* vp = VirtualProgram::get(stateset); if ( vp ) { Shaders package; package.unloadFunction( vp, package.Vertex ); package.unloadFunction( vp, package.Fragment ); } stateset->removeUniform( NORMAL_SAMPLER ); } if ( _normalMapUnit >= 0 ) { engine->getResources()->releaseTextureImageUnit( _normalMapUnit ); _normalMapUnit = -1; } }
void NormalMapTerrainEffect::onInstall(TerrainEngineNode* engine) { if ( engine ) { engine->requireNormalTextures(); engine->getResources()->reserveTextureImageUnit(_normalMapUnit, "NormalMap"); engine->addTileNodeCallback( new NormalTexInstaller(this, _normalMapUnit) ); // shader components osg::StateSet* stateset = engine->getTerrainStateSet(); VirtualProgram* vp = VirtualProgram::getOrCreate(stateset); // configure shaders Shaders package; package.loadFunction( vp, package.Vertex ); package.loadFunction( vp, package.Fragment ); stateset->addUniform( new osg::Uniform(NORMAL_SAMPLER, _normalMapUnit) ); } }
void Sprite::Render(const Shaders& program) { program.UseProgram(); glBindVertexArray(m_vertexArrayBuffer); glm::mat4 modelMatrix; modelMatrix = glm::translate(modelMatrix, m_translateVal); modelMatrix = glm::translate(modelMatrix, glm::vec3((m_size.x / 2.0f) * m_scaleVal.x, (m_size.y / -2.0f) * m_scaleVal.y, 0.0f)); modelMatrix = glm::rotate(modelMatrix, glm::radians(m_angle), glm::vec3(0.0f, 0.0f, 1.0f)); modelMatrix = glm::translate(modelMatrix, glm::vec3((m_size.x / -2.0f) * m_scaleVal.x, (m_size.y / 2.0f) * m_scaleVal.y, 0.0f)); modelMatrix = glm::scale(modelMatrix, glm::vec3(m_scaleVal, 1.0f)); m_texture.Use(program.GetProgram()); program.SetUniformFloatVec4(m_color, "color"); program.SetUniformFloatMat4(Win_Window::GetInstance().GetProjection(), "projectionMatrix"); program.SetUniformFloatMat4(modelMatrix, "modelMatrix"); glDrawArrays(GL_TRIANGLES, 0, 6); glBindVertexArray(0); }