/////////////////////////////////////////////////////////////////////////////// // Called to draw scene void RenderScene(void) { // Clear the window with current clearing color glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); modelViewMatrix.PushMatrix(); M3DMatrix44f mCamera; cameraFrame.GetCameraMatrix(mCamera); modelViewMatrix.MultMatrix(mCamera); // Reflection step... draw cube upside down, the floor // blended on top of it if(nStep == 5) { glDisable(GL_CULL_FACE); modelViewMatrix.PushMatrix(); modelViewMatrix.Scale(1.0f, -1.0f, 1.0f); modelViewMatrix.Translate(0.0f, 2.0f, 0.0f); modelViewMatrix.Rotate(35.0f, 0.0f, 1.0f, 0.0f); RenderBlock(); modelViewMatrix.PopMatrix(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); RenderFloor(); glDisable(GL_BLEND); } modelViewMatrix.PushMatrix(); // Draw normally modelViewMatrix.Rotate(35.0f, 0.0f, 1.0f, 0.0f); RenderBlock(); modelViewMatrix.PopMatrix(); // If not the reflection pass, draw floor last if(nStep != 5) RenderFloor(); modelViewMatrix.PopMatrix(); // Flush drawing commands glutSwapBuffers(); }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLES2ParticleSystem::RenderScene() { HandleInput(); UpdateParticles(); UpdateFramerateCounter(); float time_delta = PVRShellGetTime() / 10000.0f; PVRTVec3 vFrom = PVRTVec3((float) sin(time_delta) * 50.0f, 30.0f, (float) cos(time_delta) * 50.0f); m_mView = PVRTMat4::LookAtRH(vFrom, PVRTVec3(0.0f, 5.0f, 0.0f), PVRTVec3(0.0f, 1.0f, 0.0f)); m_mViewProjection = m_mProjection * m_mView; // Clear colour and depth buffers glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Enables depth testing glEnable(GL_DEPTH_TEST); // Render floor RenderFloor(); for (unsigned int i=0; i < g_cuiNumSpheres; i++) RenderSphere(g_caSpheres[i].aPosition, g_caSpheres[i].fRadius); // Render particles RenderParticles(); // Display info text. char lower_buffer[64]; unsigned int numParticles = m_pParticleSystem->GetNumberOfParticles(); sprintf(lower_buffer, "No. of Particles: %d", numParticles); m_Print3D.DisplayDefaultTitle("Particle System", NULL, ePVRTPrint3DSDKLogo); m_Print3D.Print3D(2.0f, 90.0f, 1.0f, 0xFFFFFFFF, "No. of Particles: %d", numParticles); m_Print3D.Flush(); return true; }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLESParticles::RenderScene() { int i; PVRTMat4 mRotY; // Clear colour and depth buffers myglClearColor(f2vt(0.0f), f2vt(0.0f), f2vt(0.0f), f2vt(1.0f)); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Enables depth testing glEnable(GL_DEPTH_TEST); // Modify per-frame variables controlling the particle mouvements. float fSpeedCtrl = (float) (PVRTFSIN(m_fRot*0.01f)+1.0f)/2.0f; float fStopNo = 0.8f; float fStep = 0.1f; if(fSpeedCtrl > fStopNo) fStep = 0.0f; // Generate particles as needed. if((m_i32NumParticles < (int) g_ui32MaxParticles) && (fSpeedCtrl <= fStopNo)) { int num_to_gen = (int) (RandPositiveFloat()*(g_ui32MaxParticles/100.0)); if(num_to_gen == 0) num_to_gen = 1; for(i = 0; (i < num_to_gen) && (m_i32NumParticles < (int) g_ui32MaxParticles); ++i) SpawnParticle(&m_Particles[m_i32NumParticles++]); } // Build rotation matrix around axis Y. mRotY = PVRTMat4::RotationY(f2vt((m_fRot2*PVRT_PIf)/180.0f)); for(i = 0; i < m_i32NumParticles; ++i) { // Transform particle with rotation matrix m_sParticleVTXPSBuf[i].x = VERTTYPEMUL(mRotY.f[ 0], m_Particles[i].m_fPosition.x) + VERTTYPEMUL(mRotY.f[ 4], m_Particles[i].m_fPosition.y) + VERTTYPEMUL(mRotY.f[ 8], m_Particles[i].m_fPosition.z) + mRotY.f[12]; m_sParticleVTXPSBuf[i].y = VERTTYPEMUL(mRotY.f[ 1], m_Particles[i].m_fPosition.x) + VERTTYPEMUL(mRotY.f[ 5], m_Particles[i].m_fPosition.y) + VERTTYPEMUL(mRotY.f[ 9], m_Particles[i].m_fPosition.z) + mRotY.f[13]; m_sParticleVTXPSBuf[i].z = VERTTYPEMUL(mRotY.f[ 2], m_Particles[i].m_fPosition.x) + VERTTYPEMUL(mRotY.f[ 6], m_Particles[i].m_fPosition.y) + VERTTYPEMUL(mRotY.f[10], m_Particles[i].m_fPosition.z) + mRotY.f[14]; m_sParticleVTXPSBuf[i].fSize = m_Particles[i].m_fSize; m_sNormalColour[i].r = vt2b(m_Particles[i].m_fColour.x); m_sNormalColour[i].g = vt2b(m_Particles[i].m_fColour.y); m_sNormalColour[i].b = vt2b(m_Particles[i].m_fColour.z); m_sNormalColour[i].a = (unsigned char)255; m_sReflectColour[i].r = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.x, g_fFactor)); m_sReflectColour[i].g = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.y, g_fFactor)); m_sReflectColour[i].b = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.z, g_fFactor)); m_sReflectColour[i].a = (unsigned char)255; } glBindBuffer(GL_ARRAY_BUFFER, m_i32VertVboID); glBufferData(GL_ARRAY_BUFFER, sizeof(SVtxPointSprite)*m_i32NumParticles, m_sParticleVTXPSBuf,GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, m_i32ColAVboID); glBufferData(GL_ARRAY_BUFFER, sizeof(SColors)*m_i32NumParticles, m_sNormalColour,GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, m_i32ColBVboID); glBufferData(GL_ARRAY_BUFFER, sizeof(SColors)*m_i32NumParticles, m_sReflectColour,GL_DYNAMIC_DRAW); // clean up render states glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); glEnable(GL_LIGHTING); // Draw floor. // Save modelview matrix glMatrixMode(GL_MODELVIEW); glPushMatrix(); myglRotate(f2vt(-m_fRot), f2vt(0.0f), f2vt(1.0f), f2vt(0.0f)); // setup render states glDisable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); // Set texture and texture environment glBindTexture(GL_TEXTURE_2D, m_ui32FloorTexName); glBlendFunc(GL_ONE, GL_ONE); // Render floor RenderFloor(); // clean up render states glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); glEnable(GL_LIGHTING); glPopMatrix(); // Render particles reflections. // set up render states glDisable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); glDepthFunc(GL_ALWAYS); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); myglTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, m_ui32TexName); // Set model view matrix glMatrixMode(GL_MODELVIEW); glPushMatrix(); myglScale(f2vt(1.0f), f2vt(-1.0f), f2vt(1.0f)); myglTranslate(f2vt(0.0f), f2vt(0.01f), f2vt(0.0f)); glEnable(GL_POINT_SPRITE_OES); if(((int)(m_i32NumParticles * 0.5f)) > 0) RenderParticle(((int)(m_i32NumParticles*0.5f)),true); glPopMatrix(); // Render particles. // Sets the model view matrix glMatrixMode(GL_MODELVIEW); glPushMatrix(); if(m_i32NumParticles > 0) RenderParticle(m_i32NumParticles,false); glPopMatrix(); glDisable(GL_POINT_SPRITE_OES); PVRTVec3 Force = PVRTVec3(f2vt(0.0f), f2vt(0.0f), f2vt(0.0f)); Force.x = f2vt(1000.0f*(float)PVRTFSIN(m_fRot*0.01f)); for(i = 0; i < m_i32NumParticles; ++i) { /* Move the particle. If the particle exceeds its lifetime, create a new one in its place. */ if(m_Particles[i].Step(f2vt(fStep), Force)) SpawnParticle(&m_Particles[i]); } // clean up render states glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); glEnable(GL_LIGHTING); // Increase rotation angles m_fRot += 1; m_fRot2 = m_fRot + 36; // Unbinds the vertex buffer if we are using OpenGL ES 1.1 glBindBuffer(GL_ARRAY_BUFFER, 0); // Display info text. m_Print3D.DisplayDefaultTitle("Particles", "Using point sprites", ePVRTPrint3DSDKLogo); m_Print3D.Flush(); return true; }
int main() { // msaa glfwWindowHint(GLFW_SAMPLES, 4); GLFWwindow * window = initWindow(windowWidth, windowHeight); if (!window) { glfwTerminate(); return -1; } glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, cursor_callback); glfwSetScrollCallback(window, scroll_callback); glEnable(GL_DEPTH_TEST); // prepare texture loading library(devil) init_texture_loading(); //plane Shader simpleDepthShader("data/shaders/shadow_mapping_depth.vs", "data/shaders/shadow_mapping_depth.frag"); Model ourModel("data/models/nanosuit/nanosuit.obj"); GLfloat planeVertices[] = { // Positions // Normals // Texture Coords 2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 0.0f, -2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 2.0f, -2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 0.0f, 2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 2.0f, 2.0f, -2.0f, 0.0f, -2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 2.0f }; // Setup plane VAO xzhs GLuint planeVBO; GLuint woodTexture; GLuint rockTexture; glGenVertexArrays(1, &planeVAO); glGenBuffers(1, &planeVBO); glBindVertexArray(planeVAO); glBindBuffer(GL_ARRAY_BUFFER, planeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glBindVertexArray(0); // Load textures woodTexture = load_texture("data/textures/wood.png"); rockTexture = load_texture("data/textures/rock.jpg"); // Configure depth map FBO const GLuint SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024; GLuint depthMapFBO; glGenFramebuffers(1, &depthMapFBO); // - Create depth texture GLuint depthMap; glGenTextures(1, &depthMap); glBindTexture(GL_TEXTURE_2D, depthMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); GLfloat borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f }; glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(0.1f, 0.1f, 0.1f, 1.0f); //xzhe Shader shaders("data/shaders/shader.vert", "data/shaders/shader.frag"); Shader colorShaders("data/shaders/shaderColorUniform.vert", "data/shaders/shaderColorUniform.frag"); Shader domeShaders("data/shaders/dome.vert", "data/shaders/dome.frag"); Shader lightShaders("data/shaders/lightShader.vert", "data/shaders/lightShader.frag"); Shader spriteShaders("data/shaders/spriteShader.vert", "data/shaders/spriteShader.frag"); Shader starShaders("data/shaders/spriteShader.vert", "data/shaders/stars.frag"); std::cout << "Loading models..." << std::endl; Model dome("data/models/geodesic_dome.obj"); Model landscape("data/models/landscape.obj"); std::cout << "Models loaded!" << std::endl; std::cout << "Loading extra textures..." << std::endl; GLuint domeColor = load_texture("data/textures/sky.png", true, GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT); GLuint domeGlow = load_texture("data/textures/glow.png", true, GL_MIRRORED_REPEAT, GL_MIRRORED_REPEAT); Sprite sun("data/textures/sun.png"); Sprite moon("data/textures/moon.png"); Sprite star("data/textures/star.png"); // enable blending! glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // enable msaa(multisample anti-aliasing) glEnable(GL_MULTISAMPLE); std::vector<glm::mat4> starModels(256); for (auto& m : starModels) { m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(1.0f, 0.0f, 0.0f)); m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 1.0f, 0.0f)); m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 0.0f, 1.0f)); m = glm::translate(m, glm::vec3(5.0f, 0.0f, 0.0f)); m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(1.0f, 0.0f, 0.0f)); m = glm::rotate(m, glm::radians(rand_rotate()), glm::vec3(0.0f, 1.0f, 0.0f)); } double last_frame = glfwGetTime(); while (!glfwWindowShouldClose(window)) { double current_frame = glfwGetTime(); double delta_time = current_frame - last_frame; last_frame = current_frame; glfwPollEvents(); do_movement(delta_time); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glViewport(0, 0, windowWidth, windowHeight); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)windowWidth / (float)windowHeight, 0.1f, 100.0f); glm::mat4 view = camera.GetViewMatrix(); // sun float sunAngle = current_frame * 30.0f; glm::mat4 sunModel; sunModel = glm::rotate(sunModel, glm::radians(sunAngle), glm::vec3(0.0f, 0.0f, 1.0f)); sunModel = glm::translate(sunModel, glm::vec3(3.5f, 0.0f, 0.0f)); glm::vec3 sunPos = glm::vec3(sunModel * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)); // moon float moonAngle = sunAngle + 180.0f; glm::mat4 moonModel; moonModel = glm::rotate(moonModel, glm::radians(moonAngle), glm::vec3(0.0f, 0.0f, 1.0f)); moonModel = glm::translate(moonModel, glm::vec3(3.5f, 0.0f, 0.0f)); // directional light DirLight dirLight(-sunPos, glm::vec3(0.8f, 0.8f, 0.8f)); // point light GLfloat light_pos_angle = glm::radians(60.0f * current_frame); glm::vec3 light_pos(1.2f + sin(light_pos_angle), 0.0f, 2.0f + cos(light_pos_angle)); glm::vec3 lightColor(1.0f, 1.0f, 1.0f); lightColor.r = sin(current_frame * 2.0f); lightColor.g = sin(current_frame * 0.7f); lightColor.b = sin(current_frame * 1.3f); PointLight pointLight(light_pos, lightColor * 0.5f); // spot light SpotLight spotLight(camera.Position, camera.Front, glm::vec3((GLfloat)flash_light_on)); shaders.Use(); shaders.SetUniform("view", view); shaders.SetUniform("projection", projection); shaders.SetUniform("ViewPos", camera.Position); dirLight.SetUniforms(shaders, "dirLight"); pointLight.SetUniforms(shaders, "pointLights[0]"); shaders.SetUniform("pointLightCount", 0); spotLight.SetUniforms(shaders, "spotLight"); shaders.SetUniform("material.shininess", 16.0f); colorShaders.Use(); colorShaders.SetUniform("view", view); colorShaders.SetUniform("projection", projection); colorShaders.SetUniform("ViewPos", camera.Position); dirLight.SetUniforms(colorShaders, "dirLight"); //pointLight.SetUniforms(colorShaders, "pointLights[0]"); colorShaders.SetUniform("pointLightCount", 0); spotLight.SetUniforms(colorShaders, "spotLight"); colorShaders.SetUniform("material.shininess", 1.8f); // make the dome and landscape pinned glm::mat4 pinnedView = glm::lookAt(glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f) + camera.Front, glm::vec3(0.0f, 1.0f, 0.0f)); if (enable_stars) { // stars starShaders.Use(); starShaders.SetUniform("view", view); starShaders.SetUniform("projection", projection); starShaders.SetUniform("groundBases[0]", 1.0f, 0.0f, 0.0f); starShaders.SetUniform("groundBases[1]", 0.0f, 0.0f, 1.0f); starShaders.SetUniform("groundUp", 0.0f, 1.0f, 0.0f); starShaders.SetUniform("sunPos", sunPos); for (const auto& m : starModels) { glm::mat4 model = glm::rotate(glm::mat4(), glm::radians(sunAngle), glm::vec3(0.0f, 0.0f, 1.0f)) * m; starShaders.SetUniform("model", model); star.Draw(starShaders); } } colorShaders.Use(); glm::mat4 lmodel; lmodel = glm::scale(lmodel, glm::vec3(3.0f, 3.0f, 3.0f)); lmodel = glm::translate(lmodel, glm::vec3(0.0f, 0.1f, 0.0f)); lmodel = glm::rotate(lmodel, glm::radians(30.0f), glm::vec3(0.0f, 1.0f, 0.0f)); glm::mat3 normalMatrix = glm::mat3(glm::transpose(glm::inverse(lmodel))); colorShaders.SetUniform("view", view); colorShaders.SetUniform("model", lmodel); colorShaders.SetUniform("normalMatrix", normalMatrix); colorShaders.SetUniform("Color", glm::vec4(0.93f, 0.79f, 0.69f, 1.0f)); landscape.Draw(colorShaders, false); domeShaders.Use(); domeShaders.SetUniform("view", view); domeShaders.SetUniform("projection", projection); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, domeColor); glActiveTexture(GL_TEXTURE8); glBindTexture(GL_TEXTURE_2D, domeGlow); domeShaders.SetUniform("domeColor", 7); domeShaders.SetUniform("glow", 8); glm::mat4 dmodel; dmodel = glm::scale(dmodel, glm::vec3(4.0f, 4.0f, 4.0f)); domeShaders.SetUniform("model", dmodel); domeShaders.SetUniform("sunPos", sunPos); dome.Draw(domeShaders, false); // cheating billboarding to make the sun and moon always face the camera glm::mat4 sunModelView = view * sunModel; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) sunModelView[i][j] = (GLfloat)(i == j); sunModelView = glm::scale(sunModelView, glm::vec3(0.5f, 0.5f, 0.5f)); glm::mat4 moonModelView = view * moonModel; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) moonModelView[i][j] = (GLfloat)(i == j); moonModelView = glm::scale(moonModelView, glm::vec3(0.5f, 0.5f, 0.5f)); spriteShaders.Use(); spriteShaders.SetUniform("view", glm::mat4()); spriteShaders.SetUniform("projection", projection); spriteShaders.SetUniform("model", sunModelView); sun.Draw(spriteShaders); spriteShaders.SetUniform("model", moonModelView); moon.Draw(spriteShaders); //xzhs // Set texture samples shaders.Use(); glActiveTexture(GL_TEXTURE13); glBindTexture(GL_TEXTURE_2D, woodTexture); glActiveTexture(GL_TEXTURE14); glBindTexture(GL_TEXTURE_2D, rockTexture); glActiveTexture(GL_TEXTURE15); glBindTexture(GL_TEXTURE_2D, depthMap); shaders.SetUniform("material.texture_diffuse1", 14); shaders.SetUniform("material.texture_specular1", 14); shaders.SetUniform("shadowMap", 15); // 1. Render depth of scene to texture (from light's perspective) // - Get light projection/view matrix. glm::mat4 lightProjection, lightView; glm::mat4 lightSpaceMatrix; GLfloat near_plane = 1.0f, far_plane = 7.5f; lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane); lightView = glm::lookAt(sunPos, glm::vec3(0.0f), glm::vec3(1.0)); lightSpaceMatrix = lightProjection * lightView; // - now render scene from light's point of view simpleDepthShader.Use(); simpleDepthShader.SetUniform("lightSpaceMatrix", lightSpaceMatrix); glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT); glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO); glClear(GL_DEPTH_BUFFER_BIT); RenderFloor(simpleDepthShader); RenderCubes(simpleDepthShader); glm::mat4 nmodel; nmodel = glm::translate(nmodel, glm::vec3(0.1f, 0.3f, -0.5f)); nmodel = glm::rotate(nmodel, glm::radians(70.0f), glm::vec3(0.0f, 1.0f, 0.0f)); nmodel = glm::scale(nmodel, glm::vec3(0.05f, 0.05f, 0.05f)); simpleDepthShader.SetUniform("model", nmodel); ourModel.Draw(simpleDepthShader); glBindFramebuffer(GL_FRAMEBUFFER, 0); // 2. Render scene as normal glViewport(0, 0, windowWidth, windowHeight); //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); shaders.Use(); shaders.SetUniform("projection", projection); shaders.SetUniform("view", view); shaders.SetUniform("ViewPos", camera.Position); // Set light uniforms // PointLight sunPointLight(sunPos, glm::vec3(0.02f, 0.02f, 0.02f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.5f, 0.5f, 0.5f)); // sunPointLight.SetUniforms(shaders, "pointLights[0]"); // shaders.SetUniform("pointLightCount", 0); dirLight.SetUniforms(shaders, "dirLight"); shaders.SetUniform("pointLightCount", 0); shaders.SetUniform("lightSpaceMatrix", lightSpaceMatrix); shaders.SetUniform("material.texture_diffuse1", 14); shaders.SetUniform("material.texture_specular1", 14); shaders.SetUniform("shadowMap", 15); RenderFloor(shaders); shaders.SetUniform("material.texture_diffuse1", 13); shaders.SetUniform("material.texture_specular1", 13); RenderCubes(shaders); shaders.SetUniform("model", nmodel); ourModel.Draw(shaders); //xzhe glfwSwapBuffers(window); } glfwTerminate(); return 0; }
void Render(float dt) { static unsigned int frameIndex = 0; frameIndex++; ovrFrameTiming timing = ovrHmd_BeginFrame(s_hmd, 0); // ovrSensorState ss = ovrHmd_GetSensorState(s_hmd, timing.ScanoutMidpointSeconds); // TODO: Use this for head tracking... // TODO: Use player height from SDK glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // render into fbo glBindFramebuffer(GL_FRAMEBUFFER, s_fbo); // TODO: enable this when we have more complex rendering. glEnable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); static float t = 0.0; t += dt; // clear render target glViewport(0, 0, s_renderTargetSize.w, s_renderTargetSize.h); glClearColor(s_clearColor.x, s_clearColor.y, s_clearColor.z, s_clearColor.w); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); for (int i = 0; i < 2; i++) { ovrEyeType eye = s_hmdDesc.EyeRenderOrder[i]; ovrPosef pose = ovrHmd_BeginEyeRender(s_hmd, eye); glViewport(s_eyeTexture[eye].Header.RenderViewport.Pos.x, s_eyeTexture[eye].Header.RenderViewport.Pos.y, s_eyeTexture[eye].Header.RenderViewport.Size.w, s_eyeTexture[eye].Header.RenderViewport.Size.h); Quatf q(pose.Orientation.x, pose.Orientation.y, pose.Orientation.z, pose.Orientation.w); Vector3f p(pose.Position.x, pose.Position.y, pose.Position.z); Matrixf cameraMatrix = Matrixf::QuatTrans(q, s_cameraPos); Matrixf viewCenter = cameraMatrix.OrthoInverse(); // let ovr compute projection matrix, cause it's hard. ovrMatrix4f ovrProj = ovrMatrix4f_Projection(s_eyeRenderDesc[eye].Fov, 0.1f, 10000.0f, true); // convert to abaci matrix Matrixf projMatrix = Matrixf::Rows(Vector4f(ovrProj.M[0][0], ovrProj.M[0][1], ovrProj.M[0][2], ovrProj.M[0][3]), Vector4f(ovrProj.M[1][0], ovrProj.M[1][1], ovrProj.M[1][2], ovrProj.M[1][3]), Vector4f(ovrProj.M[2][0], ovrProj.M[2][1], ovrProj.M[2][2], ovrProj.M[2][3]), Vector4f(ovrProj.M[3][0], ovrProj.M[3][1], ovrProj.M[3][2], ovrProj.M[3][3])); // use EyeRenderDesc.ViewAdjust to do eye offset. Matrixf viewMatrix = viewCenter * Matrixf::Trans(Vector3f(s_eyeRenderDesc[eye].ViewAdjust.x, s_eyeRenderDesc[eye].ViewAdjust.y, s_eyeRenderDesc[eye].ViewAdjust.z)); // compute model matrix for terminal const float kTermScale = 0.001f; const Vector3f termOrigin(-2 * kFeetToMeters, 6.75f * kFeetToMeters, -2.5 * kFeetToMeters); Matrixf modelMatrix = Matrixf::ScaleQuatTrans(Vector3f(kTermScale, -kTermScale, kTermScale), Quatf::AxisAngle(Vector3f(0, 1, 0), 0), termOrigin); RenderBegin(); RenderFloor(projMatrix, viewMatrix, 0.0f); RenderTextBegin(projMatrix, viewMatrix, modelMatrix); for (int j = 0; j < win_get_text_count(); j++) { gb::Text* text = (gb::Text*)win_get_text(j); if (text) { RenderText(text->GetQuadVec()); } } RenderTextEnd(); RenderEnd(); ovrHmd_EndEyeRender(s_hmd, eye, pose, &s_eyeTexture[eye]); } ovrHmd_EndFrame(s_hmd); }