void Demo::Display(float t) { glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer); gWorld = Matrix4::rotationY(t * 60 * 3.14159f / 180.f); gWorld *= Matrix4::rotationX(-90.0f * 3.14159f / 180.f); gTime = t; gExplode = 0.5 * t; vLightDirs = Vector4(-0.577f, 0.577f, -0.577f, 1.0f); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); mExtrudeEffect.Enable(); gModel.Draw(*this); glBindFramebuffer(GL_READ_FRAMEBUFFER, mFramebuffer); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBlitFramebuffer(0, 0, WindowWidth, WindowHeight, 0, 0, WindowWidth, WindowHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST); }
void Draw() { BeginDraw(); model.Draw(); EndDraw(); }
void Draw() { BeginDraw(); model.Draw(); left_thigh.Draw(); right_thigh.Draw(); EndDraw(); }
void Update() { MouseController(); glm::mat4 _projection; glm::mat4 _view; glm::mat4 _model; _projection = glm::perspective(45.0f, 800.0f/600.0f, 0.1f, 100.0f); glm::vec3 camDir(cosf(camPitch) * sinf(camYaw), sinf(camPitch), cosf(camPitch) * cosf(camYaw)); glm::vec3 camRight(sinf(camYaw - MATH_PI/2.0f), 0.0f, cosf(camYaw - MATH_PI/2.0f)); glm::vec3 camUp = cross(camRight, camDir); _view = glm::lookAt(camPos, camPos + camDir, camUp); KeyboardController(camDir, camRight, 0.0025f); _model = glm::translate(_model, glm::vec3(0.0f, -1.75f, 0.0f)); _model = glm::scale(_model, glm::vec3(0.2f, 0.2f, 0.2f)); _model = glm::rotate(_model, 180.0f*(MATH_PI/180.0f), glm::vec3(0.0f, 1.0f, 0.0f)); glUseProgram(shader.program); glUniformMatrix4fv(glGetUniformLocation(shader.program, "projection"), 1, GL_FALSE, glm::value_ptr(_projection)); glUniformMatrix4fv(glGetUniformLocation(shader.program, "view"), 1, GL_FALSE, glm::value_ptr(_view)); glUniformMatrix4fv(glGetUniformLocation(shader.program, "model"), 1, GL_FALSE, glm::value_ptr(_model)); glUniform3f(glGetUniformLocation(shader.program, "viewPos"), camPos.x, camPos.y, camPos.z); // Point light 1 glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].position"), 2.3f, -1.6f, -3.0f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].diffuse"), 1.0f, 1.0f, 1.0f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].constant"), 1.0f); glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].linear"), 0.009); glUniform1f(glGetUniformLocation(shader.program, "pointLights[0].quadratic"), 0.0032); // Point light 2 glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].position"), -1.7f, 0.9f, 1.0f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].diffuse"), 1.0f, 1.0f, 1.0f); glUniform3f(glGetUniformLocation(shader.program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].constant"), 1.0f); glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].linear"), 0.009); glUniform1f(glGetUniformLocation(shader.program, "pointLights[1].quadratic"), 0.0032); model.Draw(shader); }
void Display() { CHECK(); glMatrixMode(GL_MODELVIEW); glMultMatrixf( value_ptr(scale(vec3(3.0f))*translate<float>(0,-12.0,0)*rotate<float>(180,0,1,0)) ); { SaveAttrib save; glUseProgram( Program::Get("gouraud.vert+gouraud.frag")->Handle() ); glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glViewport(0, 0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE); mModel->Draw(); glBindFramebuffer(GL_FRAMEBUFFER, 0); } { SaveAttrib save; glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); int size = Util::GetFloat(GL_MAX_VIEWPORT_DIMS); Util::SetMatrix(GL_PROJECTION, ortho<float>(0, size, 0, size, -1, 1)); glViewport(0, 0, size, size); Util::SetMatrix(GL_MODELVIEW, mat4()); glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer2); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(*Program::Get("gauss_x.frag")); glBindTexture(GL_TEXTURE_2D, *mColor); Util::DrawRect(0,0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE); glBindFramebuffer(GL_FRAMEBUFFER, 0); glUseProgram(*Program::Get("gauss_y.frag")); glBindTexture(GL_TEXTURE_2D, *mColor2); Util::DrawRect(0,0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE); glUseProgram(*Program::Get("depth_view.frag")); glBindTexture(GL_TEXTURE_2D, *mColor); Util::DrawRect(0, 0, 256, 256); glBindTexture(GL_TEXTURE_2D, *mColor2); Util::DrawRect(256, 0, 256, 256); } }
void Demo::Display(float t) { if(mComputeEnabled) { mCompute.Enable(); mCompute.SetFloat(std::string("GlobalsCS.Time"), 1, &gChangesEveryFrame.Time); glDispatchCompute(32, 32, 1); } glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer); gWorld = Matrix4::rotationY(180.0f * 3.14159f / 180.f); gWorld *= Matrix4::rotationX(-90.0f * 3.14159f / 180.f); gTime = t; vLightDirs = Vector4(-0.577f, 0.577f, -0.577f, 1.0f); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); mEffect.Enable(); gModel.Draw(*this); glBindFramebuffer(GL_READ_FRAMEBUFFER, mFramebuffer); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); if(mPostFXEnabled) { glBindFramebuffer(GL_FRAMEBUFFER, 0); glDisable(GL_DEPTH_TEST); mPostProcessEffect.Enable(); //Make the colour and depth buffers available to shaders. glBindTexture(GL_TEXTURE_2D, mColTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); mPostProcessEffect.SetTexture("g_txColourBuffer", 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, mDepthTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glActiveTexture(GL_TEXTURE0); mPostProcessEffect.SetTexture("g_txDepthBuffer", 1); //Draw post processing quad. glBindVertexArray(mPostFXVAO); glEnableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mPostFXIndexBuffer); glBindBuffer(GL_ARRAY_BUFFER, mPostFXVertexBuffer); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(PostProcessVertex), 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); } else { glBindFramebuffer(GL_READ_FRAMEBUFFER, mFramebuffer); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBlitFramebuffer(0, 0, WindowWidth, WindowHeight, 0, 0, WindowWidth, WindowHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST); } }
int main(int , char**) { int width = 1280, height = 760; Display mainWindow(width, height, "DEngine"); //mainWindow.ShowCursor(false); mainWindow.WrapMouse(false); glm::vec3 lightPosition(-4.0f, 8.0f, -6.0f); Light sun(lightPosition, glm::vec3(1.0f, 1.0f, 1.0f), DIRECTIONAL_LIGHT); Camera camera(glm::vec3(0.0f, 2.0f, 1.0f)); camera.SetCameraMode(FLY); Shader simpleProgram; simpleProgram.LoadShaders("./SHADERS/SOURCE/NoNormal_vs.glsl", "./SHADERS/SOURCE/NoNormal_fs.glsl"); Shader skyBoxShaders; skyBoxShaders.LoadShaders("./SHADERS/SOURCE/skyBox_vs.glsl", "./SHADERS/SOURCE/skyBox_fs.glsl"); Shader shadowShaders; shadowShaders.LoadShaders("./SHADERS/SOURCE/ShadowDepth_vs.glsl", "./SHADERS/SOURCE/ShadowDepth_fs.glsl"); EventListener eventListener(&mainWindow, &camera, &simpleProgram); SkyBox sky; sky.LoadCubeMap("./Models/skybox"); Model box; box.LoadModelFromFile(".\\Models\\Box.obj"); box.TranslateModel(glm::vec3(0.0f, 2.0f, 0.0f)); box.meshes[0].AddTexture("./Models/textures/154.png", textureType::DIFFUSE_MAP); box.meshes[0].AddTexture("./Models/textures/154_norm.png", textureType::NORMAL_MAP); box.meshes[0].AddTexture("./Models/textures/154s.png", textureType::SPECULAR_MAP); box.TranslateModel(glm::vec3(0.0f, -0.5f, -2.0f)); Model floor; floor.LoadModelFromFile("./Models/Plane/plane.obj"); floor.meshes[0].AddTexture("./Models/textures/196.png", textureType::DIFFUSE_MAP); floor.meshes[0].AddTexture("./Models/textures/196_norm.png", textureType::NORMAL_MAP); floor.meshes[0].AddTexture("./Models/textures/196s.png", textureType::SPECULAR_MAP); floor.TranslateModel(glm::vec3(0.0f, -2.0f, 0.0f)); Clock clock; while (!mainWindow.isClosed) { eventListener.Listen(); clock.NewFrame(); //DRAWING SCENE TO SHADOWMAP //sun.StartDrawingShadows(shadowShaders.programID); // //glCullFace(GL_FRONT); ////nanosuit.Draw(&mainWindow, camera, &sun, shadowShaders); //box.Draw(&mainWindow, camera, &sun, shadowShaders); //floor.Draw(&mainWindow, camera, &sun, shadowShaders); // //sun.StopDrawingShadows(); // //glCullFace(GL_BACK); //glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //NORMAL DRAWING SCENE simpleProgram.UseProgram(); glUniformMatrix4fv(glGetUniformLocation(simpleProgram.programID, "lightSpaceMatrix"), 1, GL_FALSE, glm::value_ptr(sun.shadowMatrix)); glUniform1f(glGetUniformLocation(simpleProgram.programID, "time"), clock.time); //glActiveTexture(GL_TEXTURE15); //glBindTexture(GL_TEXTURE_2D, sun.shadowTexture.textureID); //glUniform1i(glGetUniformLocation(simpleProgram.programID, "depth_map"), 15); floor.Draw(&mainWindow, camera, &sun, simpleProgram); box.Draw(&mainWindow, camera, &sun, simpleProgram); //sky.Draw(&mainWindow, camera, skyBoxShaders); camera.Update(clock.deltaTime); mainWindow.Update(); } return 0; }
void App::Run() { if(SDL_Init(SDL_INIT_EVERYTHING) < 0){ logger << "SDL init failed"; throw 0; } SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG); constexpr u32 WindowWidth = 800; constexpr u32 WindowHeight = 600; window = SDL_CreateWindow("Cube mapping", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WindowWidth, WindowHeight, SDL_WINDOW_OPENGL); if(!window) { logger << "Window create failed"; throw 0; } glctx = SDL_GL_CreateContext(window); if(!glctx) { logger << "OpenGL context creation failed"; throw 0; } u32 vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); glDebugMessageCallbackARB(DebugCallback, nullptr); glClearColor(0.05,0.05,0.05,0); ShaderProgram forwardProgram{}; ShaderProgram bufferProgram{}; ShaderProgram deferProgram{}; { Shader vsh{"shaders/forward.vs"}; Shader fsh{"shaders/forward.fs"}; vsh.Compile(); fsh.Compile(); forwardProgram.Attach(vsh); forwardProgram.Attach(fsh); forwardProgram.Link(); forwardProgram.Use(); } { Shader vsh{"shaders/buffer.vs"}; Shader fsh{"shaders/buffer.fs"}; Shader defersh{"shaders/deferred.fs"}; vsh.Compile(); fsh.Compile(); bufferProgram.Attach(vsh); bufferProgram.Attach(fsh); bufferProgram.Link(); defersh.Compile(); deferProgram.Attach(vsh); deferProgram.Attach(defersh); deferProgram.Link(); } u32 forwardFBO, lightFBO; u32 fbTargets[4] {0}; { u32 fbTargetTypes[4] {GL_RGBA8, GL_RGBA32F, GL_RGBA8, GL_DEPTH_COMPONENT24}; u32 fbTargetFormats[4] {GL_RGBA, GL_RGB, GL_RGB, GL_DEPTH_COMPONENT}; u32 fbTargetAttach[4] {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_DEPTH_ATTACHMENT}; glGenFramebuffers(1, &forwardFBO); glBindFramebuffer(GL_FRAMEBUFFER, forwardFBO); glDrawBuffers(3, fbTargetAttach); glGenTextures(4, fbTargets); for(u32 i = 0; i < 4; i++) { glBindTexture(GL_TEXTURE_2D, fbTargets[i]); glTexImage2D(GL_TEXTURE_2D, 0, fbTargetTypes[i], WindowWidth, WindowHeight, 0, fbTargetFormats[i], GL_UNSIGNED_BYTE, nullptr); 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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D(GL_FRAMEBUFFER, fbTargetAttach[i], GL_TEXTURE_2D, fbTargets[i], 0); } } u32 lightDepthBuffer; glGenFramebuffers(1, &lightFBO); glBindFramebuffer(GL_FRAMEBUFFER, lightFBO); glGenTextures(1, &lightDepthBuffer); glBindTexture(GL_TEXTURE_2D, lightDepthBuffer); constexpr u32 shadowmapSize = 2048; glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, shadowmapSize, shadowmapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, nullptr); 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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, lightDepthBuffer, 0); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); mat4 projectionMatrix = glm::perspective((f32)PI/4.f, 4.f/3.f, 0.001f, 1000.0f); mat4 viewMatrix; mat4 modelMatrix = mat4(1.f); constexpr f32 lightSize = 25.f; mat4 lightProjMatrix = glm::ortho(-lightSize, lightSize, -lightSize, lightSize, 0.1f, 100.0f); mat4 lightViewMatrix = glm::translate(0.f, 0.f, -30.f) * glm::rotate<f32>(PI/4.f, 1, 0, 0) * glm::rotate<f32>(PI/4.f, 0, 1, 0) ; glPointSize(4.f); u32 quad; { std::vector<vec2> verts = { vec2{-1, 1}, vec2{ 1,-1}, vec2{ 1, 1}, vec2{-1, 1}, vec2{-1,-1}, vec2{ 1,-1}, }; glGenBuffers(1, &quad); glBindBuffer(GL_ARRAY_BUFFER, quad); glBufferData(GL_ARRAY_BUFFER, verts.size()*sizeof(vec2), verts.data(), GL_STATIC_DRAW); } glBindBuffer(GL_ARRAY_BUFFER, 0); Model model; model.Load("models/scene.obj"); glEnableVertexAttribArray(forwardProgram.GetAttribute("vertex")); glEnableVertexAttribArray(forwardProgram.GetAttribute("normal")); u32 displayBuffer = 0; vec2 cameraRot {0,0}; vec3 cameraPos {0,1.f,4.f}; f32 dt = 0.001f; f32 t = 0.f; s8 keys[5] = {false}; bool renderFromLight = false; using std::chrono::duration; using std::chrono::duration_cast; using std::chrono::high_resolution_clock; auto begin = high_resolution_clock::now(); while(running) { SDL_Event e; while(SDL_PollEvent(&e)) { switch (e.type) { case SDL_QUIT: running = false; break; case SDL_KEYDOWN: { switch(e.key.keysym.sym) { case SDLK_ESCAPE: running = false; break; case SDLK_1: displayBuffer = 0; break; case SDLK_2: displayBuffer = 1; break; case SDLK_3: displayBuffer = 2; break; case SDLK_4: displayBuffer = 3; break; case SDLK_5: displayBuffer = 4; break; case SDLK_6: displayBuffer = 5; break; case SDLK_w: keys[0] = true; break; case SDLK_s: keys[1] = true; break; case SDLK_a: keys[2] = true; break; case SDLK_d: keys[3] = true; break; case SDLK_LSHIFT: keys[4] = true; break; case SDLK_l: renderFromLight ^= true; break; } } break; case SDL_KEYUP: { switch(e.key.keysym.sym) { case SDLK_w: keys[0] = false; break; case SDLK_s: keys[1] = false; break; case SDLK_a: keys[2] = false; break; case SDLK_d: keys[3] = false; break; case SDLK_LSHIFT: keys[4] = false; break; } } break; default: break; } } { s32 mx, my; SDL_GetMouseState(&mx, &my); f32 mdx = mx / (f32)WindowWidth * 2.f - 1.f; f32 mdy = my / (f32)WindowHeight * 2.f - 1.f; SDL_WarpMouseInWindow(window, WindowWidth/2, WindowHeight/2); auto nyaw = mdx * 2.0 * PI * dt * 7.f; auto npitch = mdy * 2.0 * PI * dt * 7.f; constexpr f32 limit = PI/2.f; cameraRot.x = clamp(cameraRot.x + npitch, -limit, limit); cameraRot.y += nyaw; auto rotMatrix = mat4(1.f); rotMatrix = glm::rotate(rotMatrix, cameraRot.x, vec3{1,0,0}); rotMatrix = glm::rotate(rotMatrix, cameraRot.y, vec3{0,1,0}); vec4 inputDir { keys[3] - keys[2], 0, keys[1] - keys[0], 0 }; inputDir = inputDir * rotMatrix; cameraPos += vec3(inputDir) * dt * 6.f * (1.f + keys[4]*3.f); if(!renderFromLight) viewMatrix = glm::translate(rotMatrix, -cameraPos); } lightViewMatrix = glm::translate(0.f, 0.f, -25.f) * glm::rotate<f32>(PI/4.f + cos(t/8.f) * PI/6.f, 1, 0, 0) * glm::rotate<f32>(PI/16.f*t, 0, 1, 0); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // Forward forwardProgram.Use(); glBindFramebuffer(GL_FRAMEBUFFER, forwardFBO); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glUniformMatrix4fv(forwardProgram.GetUniform("model"), 1, GL_FALSE, glm::value_ptr(modelMatrix)); if(renderFromLight) { glUniformMatrix4fv(forwardProgram.GetUniform("view"), 1, GL_FALSE, glm::value_ptr(lightViewMatrix)); glUniformMatrix4fv(forwardProgram.GetUniform("projection"), 1, GL_FALSE, glm::value_ptr(lightProjMatrix)); }else{ glUniformMatrix4fv(forwardProgram.GetUniform("view"), 1, GL_FALSE, glm::value_ptr(viewMatrix)); glUniformMatrix4fv(forwardProgram.GetUniform("projection"), 1, GL_FALSE, glm::value_ptr(projectionMatrix)); } model.Draw(forwardProgram); glBindFramebuffer(GL_FRAMEBUFFER, lightFBO); glViewport(0,0,shadowmapSize,shadowmapSize); glClear(GL_DEPTH_BUFFER_BIT); glUniformMatrix4fv(forwardProgram.GetUniform("view"), 1, false, glm::value_ptr(lightViewMatrix)); glUniformMatrix4fv(forwardProgram.GetUniform("projection"), 1, false, glm::value_ptr(lightProjMatrix)); model.Draw(forwardProgram); glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(0,0,WindowWidth,WindowHeight); // Post if(!displayBuffer){ deferProgram.Use(); glUniformMatrix4fv(deferProgram.GetUniform("lightView"), 1, false, glm::value_ptr(lightViewMatrix)); glUniformMatrix4fv(deferProgram.GetUniform("lightProj"), 1, false, glm::value_ptr(lightProjMatrix)); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, fbTargets[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, fbTargets[1]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, fbTargets[2]); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, fbTargets[3]); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, lightDepthBuffer); glUniform1i(deferProgram.GetUniform("colorBuffer"), 0); glUniform1i(deferProgram.GetUniform("positionBuffer"), 1); glUniform1i(deferProgram.GetUniform("normalBuffer"), 2); glUniform1i(deferProgram.GetUniform("depthBuffer"), 3); glUniform1i(deferProgram.GetUniform("lightDepth"), 4); }else{ bufferProgram.Use(); glActiveTexture(GL_TEXTURE0); if(displayBuffer == 5) { glBindTexture(GL_TEXTURE_2D, lightDepthBuffer); }else{ glBindTexture(GL_TEXTURE_2D, fbTargets[displayBuffer-1]); } glUniform1i(bufferProgram.GetUniform("buffer"), 0); } glBindBuffer(GL_ARRAY_BUFFER, quad); glVertexAttribPointer(deferProgram.GetAttribute("vertex"), 2, GL_FLOAT, false, 0, 0); glDrawArrays(GL_TRIANGLES, 0, 6); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindTexture(GL_TEXTURE_2D, 0); SDL_GL_SwapWindow(window); auto end = high_resolution_clock::now(); dt = duration_cast<duration<f32>>(end-begin).count(); t += dt; begin = end; } }
void World::Draw() { Renderer::BeginFrame(); // Set shader to use glUseProgram(Renderer::GetShaderProgramID()); // This looks for the MVP Uniform variable in the Vertex Program GLuint VPMatrixLocation = glGetUniformLocation(Renderer::GetShaderProgramID(), "ViewProjectionTransform"); GLuint WorldMatrixID = glGetUniformLocation(Renderer::GetShaderProgramID(), "WorldTransform"); GLuint ViewMatrixID = glGetUniformLocation(Renderer::GetShaderProgramID(), "ViewTransform"); GLuint ProjMatrixID = glGetUniformLocation(Renderer::GetShaderProgramID(), "ProjectionTransform"); SetLighting(); SetCoefficient(); // Send the view projection constants to the shader mat4 VP = mCamera[mCurrentCamera]->GetViewProjectionMatrix(); mat4 View = mCamera[mCurrentCamera]->GetViewMatrix(); glm::mat4 World(1.0f); mat4 Projection = mCamera[mCurrentCamera]->GetProjectionMatrix(); glUniformMatrix4fv(VPMatrixLocation, 1, GL_FALSE, &VP[0][0]); glUniformMatrix4fv(WorldMatrixID, 1, GL_FALSE, &World[0][0]); glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &View[0][0]); glUniformMatrix4fv(ProjMatrixID, 1, GL_FALSE, &Projection[0][0]); if (mObstacles) { for (Obstacles::obstacle_vector_itr it = mObstacles->getObstacles().begin(); it != mObstacles->getObstacles().end(); ++it) { Model* model = (*it).second; model->Draw(); } } // Draw models for (vector<Model*>::iterator it = mModel.begin(); it < mModel.end(); ++it) { (*it)->Draw(); } if (DRAW_BOUNDING_VOLUME) { for (Obstacles::obstacle_vector_itr it = mObstacles->getObstacles().begin(); it != mObstacles->getObstacles().end(); ++it) { Model* model = (*it).second; Model* bvm = model->GetBoundingVolumeModel(); if (bvm) { bvm->Draw(); } } for (vector<Model*>::iterator it = mModel.begin(); it < mModel.end(); ++it) { Model* bvm = (*it)->GetBoundingVolumeModel(); if (bvm) { bvm->Draw(); } } } if (DRAW_ANIM_PATH) { // Draw Path Lines // Set Shader for path lines unsigned int prevShader = Renderer::GetCurrentShader(); Renderer::SetShader(SHADER_PATH_LINES); glUseProgram(Renderer::GetShaderProgramID()); // Send the view projection constants to the shader VPMatrixLocation = glGetUniformLocation(Renderer::GetShaderProgramID(), "ViewProjectionTransform"); glUniformMatrix4fv(VPMatrixLocation, 1, GL_FALSE, &VP[0][0]); for (vector<Animation*>::iterator it = mAnimation.begin(); it < mAnimation.end(); ++it) { mat4 VP = mCamera[mCurrentCamera]->GetViewProjectionMatrix(); glUniformMatrix4fv(VPMatrixLocation, 1, GL_FALSE, &VP[0][0]); (*it)->Draw(); } for (vector<AnimationKey*>::iterator it = mAnimationKey.begin(); it < mAnimationKey.end(); ++it) { mat4 VP = mCamera[mCurrentCamera]->GetViewProjectionMatrix(); glUniformMatrix4fv(VPMatrixLocation, 1, GL_FALSE, &VP[0][0]); (*it)->Draw(); } // Restore previous shader Renderer::SetShader((ShaderType)prevShader); } Renderer::CheckForErrors(); if (mSkyboxModel) { mSkyboxModel->Draw(); } // Draw Spline if (mSplineModel) { mSplineModel->Draw(); Model* bvm = mSplineModel->GetBoundingVolumeModel(); if (DRAW_BOUNDING_VOLUME && bvm) { bvm->Draw(); } } // Draw Billboards mpBillboardList->Draw(); mTopGun->Draw(); Renderer::EndFrame(); }