void Renderer::renderReflections(float camNear, float camFar) { if (!m_shaderRLR) init(m_windowWidth, m_windowHeight); bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderRLR->bind(); m_shaderRLR->sendSampler2D("positionTexture", m_gBuffer->getColorTexture(0), 0); m_shaderRLR->sendSampler2D("normalTexture", m_gBuffer->getColorTexture(1), 1); m_shaderRLR->sendSampler2D("colorTexture", getLastFBO()->getColorTexture(2), 2); m_shaderRLR->sendSampler2D("depthBuffer", m_gBuffer->getDepthTexture(), 3); m_shaderRLR->sendMat4("projectionMatrix", m_currentProjectionMatrix); m_shaderRLR->sendInt("screenWidth", m_windowWidth); m_shaderRLR->sendInt("screenHeight", m_windowHeight); m_shaderRLR->sendFloat("zNear", camNear); m_shaderRLR->sendFloat("zFar", camFar); m_shaderRLR->sendFloat("reflectivity", *m_screenSpaceReflectionsStrength); m_sfq.renderGeometry(); m_shaderRLR->unbind(); unbindFBO(); }
void RiftAppSkeleton::display_buffered(bool setViewport) const { bindFBO(m_renderBuffer, m_fboScale); _drawSceneMono(); unbindFBO(); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); if (setViewport) { const int w = m_Cfg.OGL.Header.RTSize.w; const int h = m_Cfg.OGL.Header.RTSize.h; glViewport(0, 0, w, h); } // Present FBO to screen const GLuint prog = m_presentFbo.prog(); glUseProgram(prog); m_presentFbo.bindVAO(); { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_renderBuffer.tex); glUniform1i(m_presentFbo.GetUniLoc("fboTex"), 0); // This is the only uniform that changes per-frame glUniform1f(m_presentFbo.GetUniLoc("fboScale"), m_fboScale); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } glBindVertexArray(0); glUseProgram(0); }
void Renderer::renderDeferredShading() { if (!m_shaderDSLighting || !m_shaderDSCompositing) init(m_windowWidth, m_windowHeight); if (!m_dsLightColor || !m_dsLightRootNode) throw std::string("Error in renderDeferredShading - Light Color or Light Root Node was not set"); FBO *a = new FBO(m_windowWidth,m_windowHeight,3,false,false); a->bind(); glCullFace(GL_FRONT); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderDSLighting->bind(); m_shaderDSLighting->sendMat4("viewMatrix", m_currentViewMatrix); m_shaderDSLighting->sendMat4("projectionMatrix", m_currentProjectionMatrix); m_shaderDSLighting->sendSampler2D("positionMap", m_gBuffer->getColorTexture(0), 0); m_shaderDSLighting->sendSampler2D("normalMap", m_gBuffer->getColorTexture(1), 1); m_shaderDSLighting->sendInt("windowWidth", m_windowWidth); m_shaderDSLighting->sendInt("windowHeight", m_windowHeight); m_shaderDSLighting->sendVec3("lightColor", *m_dsLightColor); m_dsLightRootNode->render(*m_shaderDSLighting); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); glClearColor(1.0, 1.0, 1.0, 0.0); m_shaderDSLighting->unbind(); a->unbind(); //COMPOSITING TEIL =============================== bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderDSCompositing->bind(); m_shaderDSCompositing->sendSampler2D("colorMap", getLastFBO()->getColorTexture(2), 0); m_shaderDSCompositing->sendSampler2D("lightMap", a->getColorTexture(2), 1); m_sfq.renderGeometry(); m_shaderDSCompositing->unbind(); unbindFBO(); delete a; }
void RiftAppSkeleton::RenderThumbnails() { std::vector<Pane*>& panes = m_paneScene.m_panes; for (std::vector<Pane*>::iterator it = panes.begin(); it != panes.end(); ++it) { ShaderPane* pP = reinterpret_cast<ShaderPane*>(*it); if (pP == NULL) continue; ShaderToy* pSt = pP->m_pShadertoy; // Render a view of the shader to the FBO // We must keep the previously bound FBO and restore GLint bound_fbo = 0; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo); bindFBO(pP->m_paneRenderBuffer); //pP->DrawToFBO(); { const glm::vec3 hp = pSt->GetHeadPos(); const glm::vec3 LookVec(0.0f, 0.0f, -1.0f); const glm::vec3 up(0.0f, 1.0f, 0.0f); ovrPosef eyePose; eyePose.Orientation = OVR::Quatf(); eyePose.Position = OVR::Vector3f(); const OVR::Matrix4f view = _MakeModelviewMatrix( eyePose, OVR::Vector3f(0.0f), static_cast<float>(M_PI), OVR::Vector3f(hp.x, hp.y, hp.z)); const glm::mat4 persp = glm::perspective( 90.0f, static_cast<float>(pP->m_paneRenderBuffer.w) / static_cast<float>(pP->m_paneRenderBuffer.h), 0.004f, 500.0f); const bool wasDrawing = m_shaderToyScene.m_bDraw; m_shaderToyScene.m_bDraw = true; m_shaderToyScene.SetShaderToy(pSt); m_shaderToyScene.RenderForOneEye(&view.Transposed().M[0][0], glm::value_ptr(persp)); m_shaderToyScene.m_bDraw = wasDrawing; m_shaderToyScene.SetShaderToy(NULL); } unbindFBO(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, bound_fbo); } }
void Renderer::renderBlur() { if (!m_shaderBlur) init(m_windowWidth, m_windowHeight); bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderBlur->bind(); m_shaderBlur->sendSampler2D("image", getLastFBO()->getColorTexture(2), 2); m_shaderBlur->sendFloat("blurstrength", *m_blurStrength); m_sfq.renderGeometry(); m_shaderBlur->unbind(); unbindFBO(); }
void PaneScene::RenderPrePass() const { // We must keep the previously bound FBO and restore GLint bound_fbo = 0; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo); for (std::vector<Pane*>::const_iterator it = m_panes.begin(); it != m_panes.end(); ++it) { const Pane* pP = *it; if (pP == NULL) continue; bindFBO(pP->m_paneRenderBuffer); pP->DrawToFBO(); unbindFBO(); } glBindFramebuffer(GL_FRAMEBUFFER, bound_fbo); }
void Renderer::renderAntiAliasing() { if (!m_shaderFXAA) init(m_windowWidth, m_windowHeight); bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderFXAA->bind(); m_shaderFXAA->sendSampler2D("colorTexture", getLastFBO()->getColorTexture(2), 2); m_shaderFXAA->sendInt("fboWidth", m_windowWidth); m_shaderFXAA->sendInt("fboHeight", m_windowHeight); m_sfq.renderGeometry(); m_shaderFXAA->unbind(); unbindFBO(); }
void Renderer::renderDoF(Scene& scene) { if (!m_shaderDepth || !m_shaderDoF) init(m_windowWidth, m_windowHeight); m_smFBO->bind(); //Clear Shadow Map glClear(GL_DEPTH_BUFFER_BIT); //Set the shader for the light pass. This shader is highly optimized because the scene depth is the only thing that matters here! m_shaderDepth->bind(); m_shaderDepth->sendMat4("viewMatrix", m_currentViewMatrix); m_shaderDepth->sendMat4("projectionMatrix", m_currentProjectionMatrix); //Render the scene scene.render(*m_shaderDepth); //Restore the default framebuffer m_shaderDepth->unbind(); m_smFBO->unbind(); bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderDoF->bind(); m_shaderDoF->sendSampler2D("tex", getLastFBO()->getColorTexture(2), 2); m_shaderDoF->sendSampler2D("depth", m_smFBO->getDepthTexture(), 1); m_shaderDoF->sendFloat("focus_depth", *m_focusDepth); m_sfq.renderGeometry(); m_shaderDoF->unbind(); unbindFBO(); }
void Renderer::renderSSAO() { if (!m_shaderSSAOcalc || !m_shaderSSAOblur || !m_shaderSSAOfinal) init(m_windowWidth, m_windowHeight); FBO *a = new FBO(m_windowWidth, m_windowHeight, 3, false, false); FBO *b = new FBO(m_windowWidth, m_windowHeight, 3, false, false); a->bind(); glClearColor(1, 1, 1, 1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderSSAOcalc->bind(); m_shaderSSAOcalc->sendSampler2D("positionMap", m_gBuffer->getColorTexture(0), 0); m_shaderSSAOcalc->sendSampler2D("normalMap", m_gBuffer->getColorTexture(1), 1); m_shaderSSAOcalc->sendMat4("sceneProjectionMatrix", m_currentProjectionMatrix); m_shaderSSAOcalc->sendFloat("radius", *m_ssaoRadius); m_shaderSSAOcalc->sendFloat("quality", *m_ssaoQuality); m_sfq.renderGeometry(); m_shaderSSAOcalc->unbind(); a->unbind(); //Blur #1 SSAO calculation b->bind(); //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderSSAOblur->bind(); m_shaderSSAOblur->sendSampler2D("colortexture", a->getColorTexture(2), 0); m_shaderSSAOblur->sendInt("secondPass", 0); m_sfq.renderGeometry(); m_shaderSSAOblur->unbind(); b->unbind(); //Blur #2 SSAO calculation a->bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderSSAOblur->bind(); m_shaderSSAOblur->sendSampler2D("colortexture", b->getColorTexture(2), 0); m_shaderSSAOblur->sendFloat("secondPass", 1); m_sfq.renderGeometry(); m_shaderSSAOblur->unbind(); a->unbind(); glClearColor(0, 0, 0, 0); //COLOR COMPOSITING bindFBO(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_shaderSSAOfinal->bind(); m_shaderSSAOfinal->sendSampler2D("colorMap", getLastFBO()->getColorTexture(2), 0); m_shaderSSAOfinal->sendSampler2D("ssaoMap", a->getColorTexture(2), 1); m_sfq.renderGeometry(); m_shaderSSAOfinal->unbind(); unbindFBO(); delete a; delete b; }
void RiftAppSkeleton::display_sdk() //const { ovrHmd hmd = m_Hmd; if (hmd == NULL) return; //const ovrFrameTiming hmdFrameTiming = ovrHmd_BeginFrame(m_Hmd, 0); bindFBO(m_renderBuffer); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // For passing to EndFrame once rendering is done ovrPosef renderPose[2]; ovrTexture eyeTexture[2]; for (int eyeIndex=0; eyeIndex<ovrEye_Count; eyeIndex++) { const ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex]; const ovrPosef eyePose = ovrHmd_GetEyePose(m_Hmd, eye); m_eyeOri = eyePose.Orientation; // cache this for movement direction _StoreHmdPose(eyePose); const ovrGLTexture& otex = l_EyeTexture[eye]; const ovrRecti& rvp = otex.OGL.Header.RenderViewport; glViewport( rvp.Pos.x, rvp.Pos.y, rvp.Size.w, rvp.Size.h ); const OVR::Matrix4f proj = ovrMatrix4f_Projection( m_EyeRenderDesc[eye].Fov, 0.01f, 10000.0f, true); const OVR::Matrix4f view = _MakeModelviewMatrix( eyePose, -OVR::Vector3f(m_EyeRenderDesc[eye].ViewAdjust), // not sure why negative... m_chassisYaw, m_chassisPos); const OVR::Matrix4f scaledView = _MakeModelviewMatrix( eyePose, -OVR::Vector3f(m_EyeRenderDesc[eye].ViewAdjust), // not sure why negative... m_chassisYaw, m_chassisPos, m_headSize); _resetGLState(); _DrawScenes(&view.Transposed().M[0][0], &proj.Transposed().M[0][0], rvp, &scaledView.Transposed().M[0][0]); renderPose[eyeIndex] = eyePose; eyeTexture[eyeIndex] = l_EyeTexture[eye].Texture; } unbindFBO(); ovrHmd_EndFrame(m_Hmd, renderPose, eyeTexture); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glUseProgram(0); }
///@todo Even though this function shares most of its code with client rendering, /// which appears to work fine, it is non-convergable. It appears that the projection /// matrices for each eye are too far apart? Could be modelview... void RiftAppSkeleton::display_stereo_undistorted() //const { ovrHmd hmd = m_Hmd; if (hmd == NULL) return; //ovrFrameTiming hmdFrameTiming = ovrHmd_BeginFrameTiming(hmd, 0); bindFBO(m_renderBuffer, m_fboScale); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); for (int eyeIndex = 0; eyeIndex < ovrEye_Count; eyeIndex++) { ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex]; ovrPosef eyePose = ovrHmd_GetEyePose(hmd, eye); const ovrGLTexture& otex = l_EyeTexture[eye]; const ovrRecti& rvp = otex.OGL.Header.RenderViewport; const ovrRecti rsc = { static_cast<int>(m_fboScale * rvp.Pos.x), static_cast<int>(m_fboScale * rvp.Pos.y), static_cast<int>(m_fboScale * rvp.Size.w), static_cast<int>(m_fboScale * rvp.Size.h) }; glViewport(rsc.Pos.x, rsc.Pos.y, rsc.Size.w, rsc.Size.h); OVR::Quatf orientation = OVR::Quatf(eyePose.Orientation); OVR::Matrix4f proj = ovrMatrix4f_Projection( m_EyeRenderDesc[eye].Fov, 0.01f, 10000.0f, true); //m_EyeRenderDesc[eye].DistortedViewport; OVR::Vector3f EyePos = m_chassisPos; OVR::Matrix4f view = OVR::Matrix4f(orientation.Inverted()) * OVR::Matrix4f::RotationY(m_chassisYaw) * OVR::Matrix4f::Translation(-EyePos); OVR::Matrix4f eyeview = OVR::Matrix4f::Translation(m_EyeRenderDesc[eye].ViewAdjust) * view; _resetGLState(); _DrawScenes(&eyeview.Transposed().M[0][0], &proj.Transposed().M[0][0], rvp); } unbindFBO(); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); // Present FBO to screen const GLuint prog = m_presentFbo.prog(); glUseProgram(prog); m_presentFbo.bindVAO(); { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_renderBuffer.tex); glUniform1i(m_presentFbo.GetUniLoc("fboTex"), 0); // This is the only uniform that changes per-frame glUniform1f(m_presentFbo.GetUniLoc("fboScale"), m_fboScale); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } glBindVertexArray(0); glUseProgram(0); ovrHmd_EndFrameTiming(hmd); }
void RiftAppSkeleton::display_client() //const { ovrHmd hmd = m_Hmd; if (hmd == NULL) return; //ovrFrameTiming hmdFrameTiming = ovrHmd_BeginFrameTiming(hmd, 0); bindFBO(m_renderBuffer, m_fboScale); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); for (int eyeIndex = 0; eyeIndex < ovrEye_Count; eyeIndex++) { const ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex]; const ovrPosef eyePose = ovrHmd_GetEyePose(hmd, eye); m_eyeOri = eyePose.Orientation; // cache this for movement direction _StoreHmdPose(eyePose); const ovrGLTexture& otex = l_EyeTexture[eye]; const ovrRecti& rvp = otex.OGL.Header.RenderViewport; const ovrRecti rsc = { static_cast<int>(m_fboScale * rvp.Pos.x), static_cast<int>(m_fboScale * rvp.Pos.y), static_cast<int>(m_fboScale * rvp.Size.w), static_cast<int>(m_fboScale * rvp.Size.h) }; glViewport(rsc.Pos.x, rsc.Pos.y, rsc.Size.w, rsc.Size.h); const OVR::Matrix4f proj = ovrMatrix4f_Projection( m_EyeRenderDesc[eye].Fov, 0.01f, 10000.0f, true); ///@todo Should we be using this variable? //m_EyeRenderDesc[eye].DistortedViewport; const OVR::Matrix4f view = _MakeModelviewMatrix( eyePose, m_EyeRenderDesc[eye].ViewAdjust, m_chassisYaw, m_chassisPos); const OVR::Matrix4f scaledView = _MakeModelviewMatrix( eyePose, m_EyeRenderDesc[eye].ViewAdjust, m_chassisYaw, m_chassisPos, m_headSize); _resetGLState(); _DrawScenes(&view.Transposed().M[0][0], &proj.Transposed().M[0][0], rsc, &scaledView.Transposed().M[0][0]); } unbindFBO(); // Set full viewport...? const int w = m_Cfg.OGL.Header.RTSize.w; const int h = m_Cfg.OGL.Header.RTSize.h; glViewport(0, 0, w, h); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); // Now draw the distortion mesh... for(int eyeNum = 0; eyeNum < 2; eyeNum++) { const ShaderWithVariables& eyeShader = eyeNum == 0 ? m_presentDistMeshL : m_presentDistMeshR; const GLuint prog = eyeShader.prog(); glUseProgram(prog); //glBindVertexArray(eyeShader.m_vao); { const ovrDistortionMesh& mesh = m_DistMeshes[eyeNum]; glBindBuffer(GL_ARRAY_BUFFER, 0); const int a_pos = glGetAttribLocation(prog, "vPosition"); glVertexAttribPointer(a_pos, 4, GL_FLOAT, GL_FALSE, sizeof(ovrDistortionVertex), &mesh.pVertexData[0].ScreenPosNDC.x); glEnableVertexAttribArray(a_pos); const int a_texR = glGetAttribLocation(prog, "vTexR"); if (a_texR > -1) { glVertexAttribPointer(a_texR, 2, GL_FLOAT, GL_FALSE, sizeof(ovrDistortionVertex), &mesh.pVertexData[0].TanEyeAnglesR); glEnableVertexAttribArray(a_texR); } const int a_texG = glGetAttribLocation(prog, "vTexG"); if (a_texG > -1) { glVertexAttribPointer(a_texG, 2, GL_FLOAT, GL_FALSE, sizeof(ovrDistortionVertex), &mesh.pVertexData[0].TanEyeAnglesG); glEnableVertexAttribArray(a_texG); } const int a_texB = glGetAttribLocation(prog, "vTexB"); if (a_texB > -1) { glVertexAttribPointer(a_texB, 2, GL_FLOAT, GL_FALSE, sizeof(ovrDistortionVertex), &mesh.pVertexData[0].TanEyeAnglesB); glEnableVertexAttribArray(a_texB); } ovrVector2f uvoff = m_uvScaleOffsetOut[2*eyeNum + 1]; //DistortionData.UVScaleOffset[eyeNum][0]; ovrVector2f uvscale = m_uvScaleOffsetOut[2*eyeNum + 0]; //DistortionData.UVScaleOffset[eyeNum][1]; glUniform2f(eyeShader.GetUniLoc("EyeToSourceUVOffset"), uvoff.x, uvoff.y); glUniform2f(eyeShader.GetUniLoc("EyeToSourceUVScale"), uvscale.x, uvscale.y); #if 0 // Setup shader constants DistortionData.Shaders->SetUniform2f( "EyeToSourceUVScale", DistortionData.UVScaleOffset[eyeNum][0].x, DistortionData.UVScaleOffset[eyeNum][0].y); DistortionData.Shaders->SetUniform2f( "EyeToSourceUVOffset", DistortionData.UVScaleOffset[eyeNum][1].x, DistortionData.UVScaleOffset[eyeNum][1].y); if (distortionCaps & ovrDistortionCap_TimeWarp) { // TIMEWARP - Additional shader constants required ovrMatrix4f timeWarpMatrices[2]; ovrHmd_GetEyeTimewarpMatrices(HMD, (ovrEyeType)eyeNum, eyeRenderPoses[eyeNum], timeWarpMatrices); //WARNING!!! These matrices are transposed in SetUniform4x4f, before being used by the shader. DistortionData.Shaders->SetUniform4x4f("EyeRotationStart", Matrix4f(timeWarpMatrices[0])); DistortionData.Shaders->SetUniform4x4f("EyeRotationEnd", Matrix4f(timeWarpMatrices[1])); } // Perform distortion pRender->Render( &distortionShaderFill, DistortionData.MeshVBs[eyeNum], DistortionData.MeshIBs[eyeNum]); #endif glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_renderBuffer.tex); glUniform1i(eyeShader.GetUniLoc("fboTex"), 0); // This is the only uniform that changes per-frame glUniform1f(eyeShader.GetUniLoc("fboScale"), m_fboScale); glDrawElements( GL_TRIANGLES, mesh.IndexCount, GL_UNSIGNED_SHORT, &mesh.pIndexData[0]); } glBindVertexArray(0); glUseProgram(0); } ovrHmd_EndFrameTiming(hmd); }