void setMatrices() { mat4 mv = view * model; prog.setUniform("ModelViewMatrix", mv); prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) )); prog.setUniform("MVP", projection * mv); }
void PlaneModelData::useMaterial(GLSLProgram const& prog) const { prog.setUniform("material.ambient", *reinterpret_cast<glm::vec3 const*>(material.ambient)); prog.setUniform("material.diffuse", *reinterpret_cast<glm::vec3 const*>(material.diffuse)); prog.setUniform("material.specular", *reinterpret_cast<glm::vec3 const*>(material.specular)); prog.setUniform("material.shininess", material.shininess); glActiveTexture(GL_TEXTURE0 + 5); glBindTexture(GL_TEXTURE_2D, (GLuint) material.texture1_map.user_ptr); }
/////////////////////////////////////////////////////////////////////////////// // Called to draw scene void RenderScene(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); mat4 mv = view * model; prog.setUniform("ModelViewMatrix", mv); prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) )); prog.setUniform("MVP", projection * mv); current->render(); }
void PlaneModelData::drawInstances(GLSLProgram const& prog) const { glBindVertexArray(modelVAO); useMaterial(prog); BOOST_FOREACH(DrawInstance const& inst, drawInst) { prog.setUniform("modelMatrix", inst.modelMatrix); prog.setUniform("tint", inst.tint); glDrawElements(GL_TRIANGLE_STRIP, NUM_INDICES, GL_UNSIGNED_BYTE, NULL); }
void OgroInvasion::customInit() { filename = g_programName + "/" + "Lenna.png"; try { glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "shader.vert"); glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "shader.frag"); } catch (GLSLProgramException& e) { printf("%s\n", e.what()); system("pause"); exit(EXIT_FAILURE); } glslProgram.link(); GLint vertexAttribLoc = glslProgram.getAttributeLocation("vVertex"); //quad vertices and indices glm::vec2 vertices[4]; GLushort indices[6]; vertices[0] = glm::vec2(0.0f, 0.0f); vertices[1] = glm::vec2(1.0f, 0.0f); vertices[2] = glm::vec2(1.0f, 1.0f); vertices[3] = glm::vec2(0.0f, 1.0f); GLushort* id = indices; *id++ = 0; *id++ = 1; *id++ = 2; *id++ = 0; *id++ = 2; *id++ = 3; glGenVertexArrays(1, &vaoID); glBindVertexArray(vaoID); glGenBuffers(1, &vboVerticesID); glGenBuffers(1, &vboIndicesID); glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glVertexAttribPointer(vertexAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); glEnableVertexAttribArray(vertexAttribLoc); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); mTexture = new Texture(filename); mTexture->load(); mTexture->activateTexture(0); // GL_TEXTURE0 glslProgram.setUniform("textureMap", 0); // GL_TEXTURE0 }
/////////////////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering context. // This is the first opportunity to do any OpenGL related tasks. void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); prog.compileShaderFromFile("phong.vert", GLSLShader::VERTEX); prog.compileShaderFromFile("phong.frag", GLSLShader::FRAGMENT); prog.link(); prog.use(); glEnable(GL_DEPTH_TEST); teapot = new VBOTeapot(13, mat4(1.0f)); //torus = new VBOTorus(0.7f, 0.3f, 50, 50); torus = new VBOTorus(1.75f, 0.75f, 50, 50); current = teapot; model = mat4(1.0f); model *= glm::translate(vec3(0.0f,0.0f,0.0f)); model *= glm::rotate(-90.0f, vec3(1.0f,0.0f,0.0f)); view = glm::lookAt(vec3(0.0f,3.0f,5.0f), vec3(0.0f,0.75f,0.0f), vec3(0.0f,1.0f,0.0f)); vec4 worldLight = vec4(5.0f,5.0f,2.0f,1.0f); prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f); prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f); prog.setUniform("Light.Position", view * worldLight ); prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f); prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f); prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f); prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f); prog.setUniform("Material.Shininess", 100.0f); }
/////////////////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering context. // This is the first opportunity to do any OpenGL related tasks. void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); glEnable(GL_DEPTH_TEST); prog.compileShaderFromFile("texture.vs", GLSLShader::VERTEX); prog.compileShaderFromFile("texture.fs", GLSLShader::FRAGMENT); prog.link(); prog.use(); cube = new VBOCube(); glActiveTexture(GL_TEXTURE0); GLuint tex_2d = SOIL_load_OGL_texture("brick1.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS|SOIL_FLAG_INVERT_Y); // Typical Texture Generation Using Data From The Bitmap glBindTexture(GL_TEXTURE_2D, tex_2d); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); prog.setUniform("Tex1", 0); view = glm::lookAt(vec3(1.0f,1.25f,1.25f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f)); projection = mat4(1.0f); prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f) ); prog.setUniform("Light.Intensity", vec3(1.0f,1.0f,1.0f) ); prog.setUniform("Material.Kd", 0.9f, 0.9f, 0.9f); prog.setUniform("Material.Ks", 0.95f, 0.95f, 0.95f); prog.setUniform("Material.Ka", 0.1f, 0.1f, 0.1f); prog.setUniform("Material.Shininess", 100.0f); }
void BlockModelData::drawInstances(GLSLProgram const& prog, Frustum const& cullFrustum) const { glBindVertexArray(modelVAO); useMaterial(prog); BOOST_FOREACH(DrawInstance const& inst, drawInst) { if (OrientedBoundingBox(boundingBox, inst.modelMatrix).frustumIntersect(cullFrustum) == IntersectionResult::OUTSIDE) { continue; } prog.setUniform("modelMatrix", inst.modelMatrix); prog.setUniform("tint", inst.tint); glDrawElements(GL_TRIANGLES, NUM_INDICES, GL_UNSIGNED_BYTE, NULL); } glBindVertexArray(0); }
/////////////////////////////////////////////////////////////////////////////// // Called to draw scene void RenderScene(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Time Based animation static CStopWatch rotTimer; float yRot = rotTimer.GetElapsedSeconds() * 60.0f; //model = glm::rotate(mat4(1.0f), yRot, vec3(0.0f, 1.0f, 0.0f)); model = mat4(1.0f); model *= glm::rotate(-35.0f, vec3(1.0f,0.0f,0.0f)); model *= glm::rotate(yRot, vec3(0.0f, 1.0f, 0.0f)); mat4 mv = view * model; prog.setUniform("ModelViewMatrix", mv); prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) )); prog.setUniform("MVP", projection * mv); torus->render(); }
/////////////////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering context. // This is the first opportunity to do any OpenGL related tasks. void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); prog.compileShaderFromFile("subroutine.vert", GLSLShader::VERTEX); prog.compileShaderFromFile("subroutine.frag", GLSLShader::FRAGMENT); prog.link(); prog.use(); glEnable(GL_DEPTH_TEST); plane = new VBOPlane(50.0f, 50.0f, 1, 1); teapot = new VBOTeapot(14, mat4(1.0f)); view = glm::lookAt(vec3(0.0f,0.0f,10.0f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f)); prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f)); prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f); prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f); prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f); prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f); prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f); prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f); prog.setUniform("Material.Shininess", 100.0f); }
void renderPlane(const struct aiNode *nd) { aiMatrix4x4 m = nd->mTransformation; m.Transpose(); GLfloat aux[16]; memcpy(aux, &m, sizeof(GLfloat) * 16); mat4 matrix = mstack.top() * glm::make_mat4(aux); mstack.push(matrix); for (GLuint n = 0; n < nd->mNumMeshes; ++n) { GLuint index = nd->mMeshes[n]; const aiMesh* mesh = scene->mMeshes[index]; d_program.setUniform("ModelView", mstack.top()); d_program.setUniform("Projection", pstack.top()); d_program.setUniform("MVP", pstack.top() * mstack.top()); d_program.setUniform("NormalMatrix", glm::inverseTranspose(mat3(mstack.top()) * mat3(g_modelview))); if (mesh->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) { glBindVertexArray(vaos[index]); glDrawElements(GL_TRIANGLES, index_count[index], GL_UNSIGNED_INT, 0); } else if (mesh->mPrimitiveTypes == aiPrimitiveType_POINT) { glBindVertexArray(vaos[index]); glDrawElements(GL_POINTS, index_count[index], GL_UNSIGNED_INT, 0); } else if (mesh->mPrimitiveTypes == aiPrimitiveType_LINE) { glBindVertexArray(vaos[index]); glDrawElements(GL_LINES, index_count[index], GL_UNSIGNED_INT, 0); } } for (GLuint n = 0; n < nd->mNumChildren; ++n) renderPlane(nd->mChildren[n]); mstack.pop(); }
void renderFn() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); g_program.use(); setPerspective(); glActiveTexture(GL_TEXTURE9); glBindTexture(GL_TEXTURE_2D, omap2); g_program.setUniform("MaxTessLevel", max_tess); g_program.setUniform("ModelView", g_modelview); g_program.setUniform("Projection", g_projection); g_program.setUniform("MVP", g_projection * g_modelview); g_program.setUniform("NormalMatrix", glm::inverseTranspose(mat3(g_modelview))); g_program.setUniform("MousePosition", mouse); g_program.setUniform("Time", elapsed); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); renderLand(); d_program.use(); glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &plv); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &plf); glActiveTexture(GL_TEXTURE9); glBindTexture(GL_TEXTURE_2D, plane); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); renderPlane(scene->mRootNode); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); d_program.setUniform("FrameTime", clockdiff); d_program.setUniform("Elapsed", elapsed); glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &pav); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &paf); renderParticles(); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); }
int main() { // Create and initialize window. setErrorCallbackAndInit(error_callback); GraphicsWindow* window = new GraphicsWindow(1200,800,"Test Window",NULL,NULL,key_callback); window->makeContextCurrent(); // Initalize glew. initGlew(); // Create and initialize Camera FreeCamera* camera = new FreeCamera(45.0f, 16.0f/9.0f, 0.0f, 0.0f, 0.1f, 10000.0f, 0.0004f, 3.0f, glm::vec3(0,0,-50), glm::vec3(0,1,0), glm::vec3(0,0,0), true); camera->setViewport(window->getWindowWidth(),window->getWindowHeight(),0.5f,0.5f); // Load accumulation shader for accumulating all the transparent matrials, as well as their alphas. GLSLProgram* defaultShader = new GLSLProgram(); defaultShader->initShaderProgram("Vert.glsl","","","","Frag.glsl"); // Load screen filling quad shader. GLSLProgram* screenFillingQuadShader = new GLSLProgram(); screenFillingQuadShader->initShaderProgram("screenFillingQuadVert.glsl","","","","screenFillingQuadFrag.glsl"); // Load accumulation shader for accumulating all the transparent matrials, as well as their alphas. GLSLProgram* accumTransparencyRevealageShader = new GLSLProgram(); accumTransparencyRevealageShader->initShaderProgram("AccumTransparencyRevealageVert.glsl","","","","AccumTransparencyRevealageFrag.glsl"); // Load Weighted Average shader, which will be used for final compositing (a variation of screen filling quad shader using multiple textures). GLSLProgram* newOITCoverageShader = new GLSLProgram(); newOITCoverageShader->initShaderProgram("NewOITCoverageVert.glsl","","","","NewOITCoverageFrag.glsl"); // Create screen filling quad. Quad* screenFillingQuad = new Quad(glm::vec3(-1.0,1.0,0), glm::vec3(-1.0,-1.0,0), glm::vec3(1.0,-1.0,0), glm::vec3(1.0,1.0,0), glm::vec3(0), 0, 0, 0); screenFillingQuad->initQuad(); screenFillingQuad->setGLSLProgram(*newOITCoverageShader); TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_red_base.png"); TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_2.png"); TextureManager::GetInstance().loadTexture("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_3.png"); Quad* quad1 = new Quad(glm::vec3(100+100,100+100,-1), glm::vec3(100+100,-100+100,-1), glm::vec3(-100+100,-100+100,-1), glm::vec3(-100+100,100+100,-1), glm::vec3(0), 10, 10, 0); quad1->initQuad(); quad1->initDefaultTexture(255,0,0,89); quad1->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_3.png")); Quad* quad2 = new Quad(glm::vec3(100+100,100+100,-20), glm::vec3(100+100,-100+100,-20), glm::vec3(-100+100,-100+100,-20), glm::vec3(-100+100,100+100,-20), glm::vec3(0), 10, 10, 0); quad2->initQuad(); quad2->initDefaultTexture(0,255,0,89); quad2->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_grey_base_2.png")); Quad* quad3 = new Quad(glm::vec3(100+100,100+100,20), glm::vec3(100+100,-100+100,20), glm::vec3(-100+100,-100+100,20), glm::vec3(-100+100,100+100,20), glm::vec3(0), 10, 10, 0); quad3->initQuad(); quad3->initDefaultTexture(0,0,255,89); quad3->setTexture(TextureManager::GetInstance().getTextureHandle("../Content/Textures/Particle_Smoke/smoke_particle_red_base.png")); Quad* quad4 = new Quad(glm::vec3(100+100,100+100,-40), glm::vec3(100+100,-100+100,-40), glm::vec3(-100+100,-100+100,-40), glm::vec3(-100+100,100+100,-40), glm::vec3(0), 10, 10, 0); quad4->initQuad(); quad4->initDefaultTexture(255,0,127,50); Quad* quad5 = new Quad(glm::vec3(100+100,100+100,40), glm::vec3(100+100,-100+100,40), glm::vec3(-100+100,-100+100,40), glm::vec3(-100+100,100+100,40), glm::vec3(0), 10, 10, 0); quad5->initQuad(); quad5->initDefaultTexture(255,127,0,50); ModelLoader* modelImporter = new ModelLoader(); modelImporter->importModel("../Content/Models/crytek-sponza/sponza.obj", processFlagsOnModelImport); // Create and initialize model Model* model = new Model(glm::vec3(0,0,0), "../Content/Models/crytek-sponza/"); model->loadModel(modelImporter->getScene()); // Create framebuffers std::vector<unsigned int> activeColorAttachmentsOpaque; std::vector<unsigned int> activeColorAttachmentsTransparent; Framebuffer* opaqueFrameBuffer = new Framebuffer(window->getWindowWidth(),window->getWindowHeight()); activeColorAttachmentsOpaque.push_back(0); opaqueFrameBuffer->setColorAttachment(0); //frameBuffer->setDepthAttachment(); opaqueFrameBuffer->setDepthStencilTexture(); opaqueFrameBuffer->unbind(); Framebuffer* accumFrameBuffer = new Framebuffer(window->getWindowWidth(),window->getWindowHeight()); activeColorAttachmentsTransparent.push_back(0); activeColorAttachmentsTransparent.push_back(1); accumFrameBuffer->setColorAttachment(0); accumFrameBuffer->setColorAttachment(1); //frameBuffer->setDepthAttachment(); accumFrameBuffer->setDepthStencilTexture(); accumFrameBuffer->unbind(); // Additional textures to pass for the second transparency render pass. std::vector<GLuint> additionalTextureHandles; additionalTextureHandles.push_back(accumFrameBuffer->getColorAttachment(0)); additionalTextureHandles.push_back(accumFrameBuffer->getColorAttachment(1)); std::vector<GLuint> opaqueTextureHandle; opaqueTextureHandle.push_back(opaqueFrameBuffer->getColorAttachment(0)); // Move this to "GraphicsWindow" glfwSetCursorPos(window->getWindowHandle(), (double) (window->getWindowWidth()/2.0), (double) (window->getWindowHeight()/2.0)); // Move this to "Camera" //glClearColor(0.4f,0.6f,0.94f,0.0f); glClearColor(0.0f,0.0f,0.0f,0.0f); const float clearColorWhite = 1.0f; const float clearColorBlack = 0.0f; // Sampler GLuint sampler = 0; glGenSamplers(1, &sampler); glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT); glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_REPEAT); glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST); check_gl_error(); // Render Loop while(!window->shouldClose()) { //glClearColor(0.0f,0.0f,0.0f,0.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); // Update camera camera->camControll(window->getWindowHandle()); camera->update(); // Update shader uniforms model->getCurrentGLSLProgram()->use(); model->getCurrentGLSLProgram()->setUniform("lightPosition", camera->getCamPos()); model->getCurrentGLSLProgram()->setUniform("camPosition", camera->getCamPos()); model->getCurrentGLSLProgram()->setUniform("viewMatrix", camera->getVMatrix()); model->getCurrentGLSLProgram()->setUniform("normalMatrix", camera->getTranspInvMVMatrix()); // Change this! model->getCurrentGLSLProgram()->setUniform("VPMatrix", camera->getVPMatrix()); opaqueFrameBuffer->clean(); opaqueFrameBuffer->bind(); opaqueFrameBuffer->bindForRenderPass(activeColorAttachmentsOpaque); model->renderOpaque(); //quad4->render(); //quad5->render(); //opaqueFrameBuffer->unbind(); //// Blitting the opaque scene depth to propperly depth test the transparen against it. //opaqueFrameBuffer->bindForReading(); //accumFrameBuffer->bindForWriting(); //glBlitFramebuffer(0, 0, window->getWindowWidth(), window->getWindowHeight(), 0, 0, window->getWindowWidth(), window->getWindowHeight(), // GL_DEPTH_BUFFER_BIT, GL_NEAREST); //opaqueFrameBuffer->unbind(); //_______________________________________________________________________________________________________________________________________________________________________________ // Acuumulation pass accumTransparencyRevealageShader->use(); accumTransparencyRevealageShader->setUniform("VPMatrix", camera->getVPMatrix()); model->setGLSLProgram(accumTransparencyRevealageShader); quad1->setGLSLProgram(*accumTransparencyRevealageShader); quad2->setGLSLProgram(*accumTransparencyRevealageShader); quad3->setGLSLProgram(*accumTransparencyRevealageShader); quad4->setGLSLProgram(*accumTransparencyRevealageShader); quad5->setGLSLProgram(*accumTransparencyRevealageShader); accumFrameBuffer->clean(); accumFrameBuffer->bind(); accumFrameBuffer->bindForRenderPass(activeColorAttachmentsTransparent); accumFrameBuffer->cleanColorAttachment(1,clearColorWhite); opaqueFrameBuffer->unbind(); // Blitting the opaque scene depth to propperly depth test the transparen against it. opaqueFrameBuffer->bindForReading(); accumFrameBuffer->bindForWriting(); glBlitFramebuffer(0, 0, window->getWindowWidth(), window->getWindowHeight(), 0, 0, window->getWindowWidth(), window->getWindowHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST); opaqueFrameBuffer->unbind(); accumFrameBuffer->bind(); accumFrameBuffer->bindForRenderPass(activeColorAttachmentsTransparent); glEnable(GL_BLEND); glBlendFunci(0, GL_ONE, GL_ONE); glBlendFunci(1, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA); //glEnable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glDisable(GL_CULL_FACE); model->renderTransparent(); quad1->render(); quad2->render(); quad3->render(); //quad4->render(); //quad5->render(); accumFrameBuffer->unbind(); model->setGLSLProgram(defaultShader); quad1->setGLSLProgram(*defaultShader); quad2->setGLSLProgram(*defaultShader); quad3->setGLSLProgram(*defaultShader); quad4->setGLSLProgram(*defaultShader); quad5->setGLSLProgram(*defaultShader); glDisable(GL_BLEND); //glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); //_______________________________________________________________________________________________________________________________________________________________________________ // Final compositing pass //screenFillingQuad->setGLSLProgram(*screenFillingQuadShader); //screenFillingQuad->getCurrentShaderProgram()->use(); //screenFillingQuad->renderWithAdditionalTextures(opaqueTextureHandle,sampler); newOITCoverageShader->use(); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA); screenFillingQuad->renderWithAdditionalTextures(additionalTextureHandles,sampler); glDepthMask(GL_TRUE); glDisable(GL_BLEND); //_______________________________________________________________________________________________________________________________________________________________________________ // For debug! //screenFillingQuad->setGLSLProgram(*screenFillingQuadShader); //screenFillingQuad->getCurrentShaderProgram()->use(); //screenFillingQuad->setTexture(opaqueFrameBuffer->getColorAttachment(0)); //screenFillingQuad->render(); accumFrameBuffer->clean(); window->swapBuffers(); glfwPollEvents(); check_gl_error(); } glfwTerminate(); window->release(); return 0; }
void loadAssets() { loadParticles(); loadPlane(); pstack.push(glm::perspective(45.0f, (GLfloat)window.GetWidth()/window.GetHeight(), 0.1f, 175.0f)); mstack.push(glm::lookAt(vec3(0, 2.7, 7), vec3(0, 2.4, 6), vec3(0, 1, 0))); // Load terrain shader if (!g_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "terrain-vert.glsl", GLSLShader::VERTEX)) { fprintf(stderr, "%s\n", g_program.log().c_str()); exit(1); } if (!g_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "terrain-frag.glsl", GLSLShader::FRAGMENT)) { fprintf(stderr, "%s\n", g_program.log().c_str()); exit(1); } if (!g_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "terrain-tc.glsl", GLSLShader::TESS_CONTROL)) { fprintf(stderr, "%s\n", g_program.log().c_str()); exit(1); } if (!g_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "terrain-te.glsl", GLSLShader::TESS_EVALUATION)) { fprintf(stderr, "%s\n", g_program.log().c_str()); exit(1); } if (!g_program.link()) { fprintf(stderr, "%s\n", g_program.log().c_str()); exit(1); } // Load plane shader if (!d_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "default-vert.glsl", GLSLShader::VERTEX)) { fprintf(stderr, "%s\n", d_program.log().c_str()); exit(1); } if (!d_program.compileShaderFromFile( ROOT_PATH_RELATIVE SHADER_DIR "default-frag.glsl", GLSLShader::FRAGMENT)) { fprintf(stderr, "%s\n", d_program.log().c_str()); exit(1); } const char *outputNames[] = { "Position" }; glTransformFeedbackVaryings(d_program.getHandle(), 1, outputNames, GL_SEPARATE_ATTRIBS); if (!d_program.link()) { fprintf(stderr, "%s\n", d_program.log().c_str()); exit(1); } g_program.use(); g_program.setUniform("Viewport", viewport); g_program.setUniform("MinTessLevel", 1.0f); g_program.setUniform("MaxTessLevel", max_tess); //g_program.setUniform("MaxTessLevel", 20.0f); g_program.setUniform("NearClip", 0.1f); g_program.setUniform("FarClip", 175.0f); g_program.setUniform("NearFog", 10.0f); g_program.setUniform("FarFog", 125.0f); g_program.setUniform("Light0.position", vec3(L0POSITION)); g_program.setUniform("Light0.La", vec3(L0AMBIENT)); g_program.setUniform("Light0.Ld", vec3(L0DIFFUSE)); GLuint terrainmap = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "heightmap-vlarge.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint watermap = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "watermap.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint ttex1 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "grass.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint ttex2 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "stonesnow.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint ttex3 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "water.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint ttex4 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "foam.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint nmap1 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "normalmap-vlarge.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint nmap2 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_NRM.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); GLuint omap1 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "occmap-vlarge.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); omap2 = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "watermap_OCC.jpg", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); plane = SOIL_load_OGL_texture ( ROOT_PATH_RELATIVE TEXTURE_DIR "F16_diffusemap2.tga", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_LOAD_L ); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, terrainmap); g_program.setUniform("TerrainMap", 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, watermap); g_program.setUniform("WaterMap", 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, ttex1); g_program.setUniform("TTex1", 2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, ttex2); g_program.setUniform("TTex2", 3); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, ttex3); g_program.setUniform("TTex3", 4); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, ttex4); g_program.setUniform("TTex4", 5); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, nmap1); g_program.setUniform("NMap1", 6); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, nmap2); g_program.setUniform("NMap2", 7); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE8); glBindTexture(GL_TEXTURE_2D, omap1); g_program.setUniform("OMap1", 8); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glActiveTexture(GL_TEXTURE9); glBindTexture(GL_TEXTURE_2D, omap2); g_program.setUniform("OMap2", 9); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); d_program.use(); plv = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderPlane"); plf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderPlane"); pav = glGetSubroutineIndex(d_program.getHandle(), GL_VERTEX_SHADER, "RenderParticles"); paf = glGetSubroutineIndex(d_program.getHandle(), GL_FRAGMENT_SHADER, "RenderParticles"); glActiveTexture(GL_TEXTURE9); glBindTexture(GL_TEXTURE_2D, plane); d_program.setUniform("PlaneTex", 9); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); d_program.setUniform("Light0.position", vec3(L0POSITION)); d_program.setUniform("Light0.La", vec3(L0AMBIENT)); d_program.setUniform("Light0.Ld", vec3(L0DIFFUSE)); loadLand(156, 100); }