GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName, std::string vertString, std::string fragString) { GLSLProgram* prog = GetShader(vertName, fragName,vertString, fragString); assert(prog != NULL); prog->use(); return prog; }
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName) { GLSLProgram* prog = GetShader(vertName, fragName); assert(prog != NULL); prog->use(); return prog; }
/////////////////////////////////////////////////////////////////////////////// // 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); }
/////////////////////////////////////////////////////////////////////////////// // 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 ); 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 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); }
void Renderer::init(GLSLProgram & shader) { setProjectionMatrix(30,1, 1, -100, projection); shader.use(); shader.setUniformMatrix4fv("projectionMatrix", projection); shader.unuse(); }
void CascadedShadowMap::buildShadowMaps(Camera *camera, View *view, DirectLight *light) { //Profiler::getInstance()->startProfile("Build Shadow Maps"); float nSlice[] = {0.0, m_nSlices[0], m_nSlices[1], m_nSlices[2], 1.0}; Frustum *frustum = new Frustum(); frustum->getFrustum(camera, view); m_shadowMaps[3]->bind(); glClearDepth(1.0); glClear(GL_DEPTH_BUFFER_BIT); glDisable(GL_CULL_FACE); for (int i=0; i<4; i++) { Camera *lightCamera = createLightCamera(nSlice[i],nSlice[i+1],camera,view,light); View *lightView = createLightView(nSlice[i],nSlice[i+1],camera,lightCamera,view,frustum); Frustum *lightFrustum = new Frustum(); lightFrustum->getOrthoFrustum(lightCamera,lightView); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); m_shadowMaps[i]->bind(); glClearDepth(1.0); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); glPushAttrib( GL_VIEWPORT_BIT ); glViewport( 0, 0, m_nSize, m_nSize); lightView->use3D(false); GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("DirectShadow"); glslProgram->use(); glm::mat4 cameraMat = glm::mat4(1.0f); cameraMat = lightCamera->transformToMatrix(cameraMat); m_m4LightMatrix[i] = MatrixManager::getInstance()->getMatrix4(PROJECTION) * cameraMat; MatrixManager::getInstance()->putMatrix4(MODELVIEW, cameraMat); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); SceneManager::getInstance()->draw("DirectShadow"); glslProgram->disable(); glPopAttrib(); m_shadowMaps[i]->unbind(); delete lightCamera; delete lightView; delete lightFrustum; } glEnable(GL_CULL_FACE); //Profiler::getInstance()->endProfile(); }
void HelloGLSL::onRender() { glslProgram.use(); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, 3); glslProgram.unUse(); glBindVertexArray(0); }
void MainGraphicsWidget::voxelRender() { VoxelGrid::getInstance()->buildVoxels(m_lightBuffer->getLight()); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f)); view->viewport(); view->use3D(true); camera->transform(); GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Voxel"); glslProgram->use(); glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor"); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]); glm::mat4 cameraInverse = glm::mat4(1.0); cameraInverse = camera->transformToMatrix(cameraInverse); cameraInverse = glm::inverse(cameraInverse); glslProgram->sendUniform("invCameraMatrix", &cameraInverse[0][0]); glslProgram->sendUniform("worldSize", WORLD_SIZE); //glslProgram->sendUniform("numVoxels", VOXEL_SIZE); //glslProgram->sendUniform("mipLevel", VoxelGrid::getInstance()->getMipLevel()); int mipFactor = pow(2.0, VoxelGrid::getInstance()->getMipLevel()); glActiveTexture(GL_TEXTURE8); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(VoxelGrid::getInstance()->getMipLevel()); glslProgram->sendUniform("voxelmap", 8); //glEnable(GL_POINT_SMOOTH); glPointSize(10.0f*mipFactor); float voxelWidth = (float)WORLD_SIZE / (float)VOXEL_SIZE * mipFactor; glBegin(GL_POINTS); for (float x=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); x<(WORLD_SIZE/2.0); x+=voxelWidth) { for (float y=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); y<(WORLD_SIZE/2.0); y+=voxelWidth) { for (float z=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); z<(WORLD_SIZE/2.0); z+=voxelWidth) { glVertex3f(x,y,z); } } } glEnd(); glslProgram->disable(); }
void OgroInvasion::onRender() { glslProgram.use(); glBindVertexArray(vaoID); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr); glBindVertexArray(0); glslProgram.unUse(); }
/////////////////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering context. // This is the first opportunity to do any OpenGL related tasks. void SetupRC() { // Black background glClearColor(0.0f , 0.0f , 0.0f , 1.0f ); prog.compileShaderFromString (szIdentityShaderVP, GLSLShader:: VERTEX); prog.compileShaderFromString (szIdentityShaderFP, GLSLShader:: FRAGMENT); prog.link (); prog.use (); /////////////////// Create the VBO //////////////////// GLfloat positionData [] = { -0.8f, -0.8f , 0.0f , 0.8f, -0.8f, 0.0f, 0.0f, 0.8f, 0.0f }; GLfloat colorData[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // Create and populate the buffer objects GLuint vboHandles[2]; glGenBuffers(2, vboHandles); GLuint positionBufferHandle = vboHandles[0]; GLuint colorBufferHandle = vboHandles[1]; glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle); glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(GLfloat), positionData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle); glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(GLfloat), colorData, GL_STATIC_DRAW); // Create and set-up the vertex array object glGenVertexArrays( 1, &vaoHandle ); glBindVertexArray(vaoHandle); glEnableVertexAttribArray(0); // Vertex position glEnableVertexAttribArray(1); // Vertex color glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle); glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL ); glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle); glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte *)NULL ); }
void MainGraphicsWidget::forwardRender() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f)); view->viewport(); view->use3D(true); camera->transform(); GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Basic"); glslProgram->use(); glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor"); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); glBindAttribLocation(glslProgram->getHandle(), 1, "v_texture"); glBindAttribLocation(glslProgram->getHandle(), 2, "v_normal"); glBindAttribLocation(glslProgram->getHandle(), 3, "v_tangent"); glBindAttribLocation(glslProgram->getHandle(), 4, "v_bitangent"); glslProgram->sendUniform("light.direction", 1.0f,-5.0f,2.0f); glslProgram->sendUniform("light.color", 1.0f,1.0f,1.0f); glslProgram->sendUniform("light.ambient", 0.7f); glslProgram->sendUniform("light.diffuse", 0.6f); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]); glslProgram->sendUniform("curveGeometry", false); glm::mat4 cameraInverse = glm::mat4(1.0); cameraInverse = camera->transformToMatrix(cameraInverse); cameraInverse = glm::inverse(cameraInverse); glslProgram->sendUniform("inverseCameraMatrix", &cameraInverse[0][0]); glslProgram->sendUniform("cameraPos", camera->getEyeX(), camera->getEyeY(), camera->getEyeZ()); MaterialManager::getInstance()->getMaterial("Default")->sendToShader("Basic"); myGrid->draw(); SceneManager::getInstance()->draw("Basic"); glslProgram->disable(); SceneManager::getInstance()->drawTransformers(); }
void draw() { glClearDepth(1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glGenBuffers(1, &_vboID); float vertexData[12]; float height = 1.0f; float width = 1.0f; float x = -1.0f; float y = -1.0f; //First Triangle vertexData[0] = x + width; vertexData[1] = y + height; vertexData[2] = x; vertexData[3] = y + height; vertexData[4] = x; vertexData[5] = y; //Second Triangle vertexData[6] = x; vertexData[7] = y; vertexData[8] = x + width; vertexData[9] = y; vertexData[10] = x + width; vertexData[11] = y + height; _Program.use(); glBindBuffer(GL_ARRAY_BUFFER, _vboID); glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); _Program.unuse(); SDL_GL_SwapWindow(_window); }
int compile_link_shaders(GLSLProgram& prog, int num_shaders, ...) { va_list shader_list; va_start(shader_list, num_shaders); int type; char *file= NULL; GLSLProgram tmp_prog; // Iterate over this argument list for (int i=0; i<num_shaders; ++i) { type = va_arg(shader_list, int);// Number of attributes file = va_arg(shader_list, char*); if (!tmp_prog.compile_shader_file(file, GLSLShader::GLSLShaderType(type))) { printf("%s shader failed to compile!\n%s", file, tmp_prog.log().c_str()); return 0; } } va_end(shader_list); if (!tmp_prog.link()) { printf("Shader program failed to link!\n%s", tmp_prog.log().c_str()); return 0; } if (prog.isLinked()) prog.delete_program(); prog = tmp_prog; prog.use(); return 1; }
GLuint Model::getVAOForContext(GLSLProgram &shader, QGLContext *context){ if (!vaoHashContainer_.contains(context)) { glGenVertexArrays(1, &vaoID_); glBindVertexArray(vaoID_); shader.use(); glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID_); glEnableVertexAttribArray(shader["vVertex"]); glVertexAttribPointer(shader["vVertex"], 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0); if (shader.isActive(shader["vNormal"])) { glEnableVertexAttribArray(shader["vNormal"]); glVertexAttribPointer(shader["vNormal"], 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal)) ); } if (shader.isActive(shader["vUV"])) { glEnableVertexAttribArray(shader["vUV"]); glVertexAttribPointer(shader["vUV"], 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, uv)) ); } if (materials_.size()==1) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID_); glBindVertexArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); vaoHashContainer_.insert(context, vaoID_); shader.unUse(); } return vaoHashContainer_[context]; }
void IndirectBuffer::drawToBuffer(GLuint nDepthTex, GLuint nTangentTex, GLuint nBiangentTex, GLuint nNormalTex, GLuint nDiffuseTex, View *view, Camera *camera) { GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Indirect"); glslProgram->use(); bind(); GLenum mrt[] = {GL_COLOR_ATTACHMENT0_EXT}; glDrawBuffers(1, mrt); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushAttrib( GL_VIEWPORT_BIT ); glViewport( 0, 0, getWidth(), getHeight()); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); camera->transform(); view->use3D(true); glm::mat4 m4InvMVP = MatrixManager::getInstance()->getMatrix4(PROJECTION) * MatrixManager::getInstance()->getMatrix4(MODELVIEW); m4InvMVP = glm::inverse(m4InvMVP); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); view->use3D(false); glBindFragDataLocation(glslProgram->getHandle(), 0, "glossyBuffer"); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); glBindAttribLocation(glslProgram->getHandle(), 1, "v_texture"); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glslProgram->sendUniform("inverseMVPMatrix", &m4InvMVP[0][0]); glslProgram->sendUniform("worldSize", WORLD_SIZE); glslProgram->sendUniform("numVoxels", VOXEL_SIZE); glActiveTexture(GL_TEXTURE8); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(0); glActiveTexture(GL_TEXTURE9); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(1); glActiveTexture(GL_TEXTURE10); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(2); glActiveTexture(GL_TEXTURE11); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(3); glslProgram->sendUniform("voxelmap[0]", 8); glslProgram->sendUniform("voxelmap[1]", 9); glslProgram->sendUniform("voxelmap[2]", 10); glslProgram->sendUniform("voxelmap[3]", 11); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, nDepthTex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, nTangentTex); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, nBiangentTex); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, nNormalTex); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, nDiffuseTex); glslProgram->sendUniform("depthTex",0); glslProgram->sendUniform("tanTex",1); glslProgram->sendUniform("bitanTex",2); glslProgram->sendUniform("normalTex",3); glslProgram->sendUniform("diffuseTex",4); drawScreenShader(0,0,1.0f,1.0f); glFinish(); glslProgram->disable(); unbind(); }
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 SceneParticlesInstanced::compileAndLinkShader (GLSLProgram& glslProg, const char* vertexPath, const char* fragmentPath, const char* geometryPath) { // "shader/particleinstanced.vs" if( !glslProg.compileShaderFromFile(vertexPath, GLSLShader::VERTEX) ) { printf("Vertex shader failed to compile!\n%s", glslProg.log().c_str()); do { cout << '\n' << "Press a key to continue..."; } while (cin.get() != '\n'); exit(1); } // "shader/particleinstanced.fs" if( !glslProg.compileShaderFromFile(fragmentPath, GLSLShader::FRAGMENT)) { printf("Fragment shader failed to compile!\n%s", glslProg.log().c_str()); do { cout << '\n' << "Press a key to continue..."; } while (cin.get() != '\n'); exit(1); } if (geometryPath != NULL && geometryPath[0] != '\0') { // compile geometry shader if (!glslProg.compileShaderFromFile(geometryPath, GLSLShader::GEOMETRY)) { printf("Geometry shader failed to compile!\n%s", glslProg.log().c_str()); do { cout << '\n' << "Press a key to continue..."; } while (cin.get() != '\n'); exit(1); } } if( !glslProg.link() ) { printf("Shader program failed to link!\n%s", glslProg.log().c_str()); do { cout << '\n' << "Press a key to continue..."; } while (cin.get() != '\n'); exit(1); } glslProg.use(); }
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); }
int main() { GLFWwindow* window = nullptr; if(!init(window)) { system("pause"); exit(0); } glClearColor(0.0, 0.0, 0.0, 0.0); //set up audio engine SoundSystemClass sounds; GLSLProgram shaders; //load shaders, compile and link shaders.compileShaderFromFile("triangle.v.glsl", VERTEX); shaders.compileShaderFromFile("triangle.f.glsl", FRAGMENT); shaders.link(); shaders.use(); Screen* currentScreen; MainMenuScreen *mms = new MainMenuScreen(&sounds, &shaders); currentScreen = mms; //Text t(glm::vec3(0, 0, 0), glm::vec4(1.0, 0.0, 0.0, 1.0), 40, 40, "arial_0.png", "arial.fnt"); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //create projection matrix glm::mat4 projectionMatrix = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f); double lastTime = glfwGetTime(), currentTime; while(!glfwWindowShouldClose(window) && currentScreen != nullptr) { //calculate delta time currentTime = glfwGetTime(); double deltaTime = currentTime - lastTime; //draw glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); currentScreen->Draw(); glfwSwapBuffers(window); //update Screen* next = currentScreen->Update(deltaTime); //if returned screen is null, pop current screen if(next != currentScreen) { delete currentScreen; currentScreen = next; } //else continue with current top of stack glfwPollEvents(); lastTime = currentTime; } glfwDestroyWindow(window); glfwTerminate(); return 0; }