The depth buffer to be used for shadows is also objectified. (20210622)

ounols · Jun 21, 2021 · 7b76fcc · 7b76fcc
1 parent 524efd2
commit 7b76fcc
Show file tree

Hide file tree

Showing 5 changed files with 75 additions and 47 deletions.
diff --git a/src/Component/SComponent.h b/src/Component/SComponent.h
@@ -48,7 +48,7 @@ namespace CSE {
             return this;
         }
 
-        void SetValue(std::string name_str, Arguments value) override {}
+        virtual void SetValue(std::string name_str, Arguments value) override {}
 
         std::string PrintValue() const override { return std::string(); }
 

diff --git a/src/Manager/LightMgr.cpp b/src/Manager/LightMgr.cpp
@@ -84,41 +84,6 @@ void LightMgr::AttachLightToShader(const GLProgramHandle* handle) const {
     glUniform1i(handle->Uniforms.LightSize, m_objects.size());
 }
 
-void LightMgr::RenderShadowMap(GLProgramHandle* handle) const {
-    if(handle == nullptr) return;
-    glViewport(0, 0, (GLsizei) SHADOW_WIDTH, (GLsizei) SHADOW_HEIGHT);
-
-    glUseProgram(handle->Program);
-
-    // Initialize various state.
-    glEnableVertexAttribArray(handle->Attributes.Position);
-    glEnableVertexAttribArray(handle->Attributes.Weight);
-    glEnableVertexAttribArray(handle->Attributes.JointId);
-
-    m_shadowCount = 0;
-    for (const auto& light : m_objects) {
-        if(light->m_disableShadow) continue;
-        const auto camera = light->GetCameraMatrixStruct();
-
-        light->BindDepthBuffer();
-        for (const auto& shadowObject : m_shadowObject) {
-            if(!shadowObject->isRenderActive) continue;
-            const auto& shadow_transform = static_cast<RenderComponent*>(shadowObject)->GetGameObject()->GetTransform();
-
-            if(SHADOW_DISTANCE < vec3::Distance(camera.cameraPosition, shadow_transform->m_position))
-                continue;
-
-            shadowObject->SetMatrix(camera, handle);
-            shadowObject->Render(handle);
-        }
-        ++m_shadowCount;
-    }
-    glDisableVertexAttribArray(handle->Attributes.Position);
-    glDisableVertexAttribArray(handle->Attributes.Weight);
-    glDisableVertexAttribArray(handle->Attributes.JointId);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
 void LightMgr::Init() {
 
 }
@@ -131,6 +96,23 @@ void LightMgr::RemoveShadowObject(SIRender* object) {
     m_shadowObject.remove(object);
 }
 
+const std::list<SIRender*>& LightMgr::GetShadowObject() const {
+    return m_shadowObject;
+}
+
+void LightMgr::RefreshShadowCount(int shadowCount) const {
+    if(shadowCount < 0) {
+        int tempCount = 0;
+        for (const auto& light : m_objects) {
+            if(light->m_disableShadow) continue;
+            ++tempCount;
+        }
+        m_shadowCount = tempCount;
+        return;
+    }
+    m_shadowCount = shadowCount;
+}
+
 //void LightMgr::AttachDirectionalLight(const GLProgramHandle* handle, const SLight* light, int index) const {
 //
 //

diff --git a/src/Manager/LightMgr.h b/src/Manager/LightMgr.h
@@ -12,14 +12,13 @@ namespace CSE {
     public:
         const int SHADOW_WIDTH = 1024;
         const int SHADOW_HEIGHT = 1024;
-        const float SHADOW_DISTANCE = 10.f;
+        constexpr static float SHADOW_DISTANCE = 10.f;
 
     public:
         explicit LightMgr();
         ~LightMgr();
 
         void AttachLightToShader(const GLProgramHandle* handle) const;
-        void RenderShadowMap(GLProgramHandle* handle) const;
 
         void Init() override;
 
@@ -30,6 +29,10 @@ namespace CSE {
             return m_shadowCount;
         }
 
+        void RefreshShadowCount(int shadowCount = -1) const;
+
+        const std::list<SIRender*>& GetShadowObject() const;
+
     private:
         STexture* m_currentSkybox = nullptr;
         std::list<SIRender*> m_shadowObject;

diff --git a/src/Manager/RenderMgr.cpp b/src/Manager/RenderMgr.cpp
@@ -4,6 +4,7 @@
 #include "../Util/Render/SFrameBuffer.h"
 #include "../Util/Render/SEnvironmentMgr.h"
 #include "CameraMgr.h"
+#include "../Component/RenderComponent.h"
 // #include <iostream>
 
 using namespace CSE;
@@ -40,19 +41,27 @@ void RenderMgr::SetViewport(int width, int height) {
 void RenderMgr::Render() const {
     // Render Order : Depth Buffers -> Render Buffers -> Main Render Buffer
 
-    lightMgr->RenderShadowMap(m_environmentMgr->GetShadowEnvironment());
+    // 1. Render depth buffer for shadows.
+    const auto& lightObjects = lightMgr->GetAll();
+    const auto& shadowObjects = lightMgr->GetShadowObject();
+    const auto& shadowEnvironment = m_environmentMgr->GetShadowEnvironment();
+    for (const auto& light : lightObjects) {
+        if(light->m_disableShadow) continue;
+        RenderShadowInstance(*light, *shadowEnvironment, shadowObjects);
+    }
+    lightMgr->RefreshShadowCount();
 
     const auto& cameraObjects = cameraMgr->GetAll();
     const auto& mainCamera = cameraMgr->GetCurrentCamera();
 
-    // Render active sub cameras.
+    // 2. Render active sub cameras.
     for (const auto& camera : cameraObjects) {
-        if(!camera->GetIsEnable() || camera == mainCamera) continue;
+        if(!camera->GetIsEnable() || camera == mainCamera || camera->GetFrameBuffer() == nullptr) continue;
         RenderInstance(*camera);
     }
 
     if(mainCamera == nullptr) return;
-    // Main Render Buffer
+    // 3. Main Render Buffer
     RenderInstance(*mainCamera);
 
 }
@@ -72,7 +81,6 @@ void RenderMgr::RenderInstance(const CameraBase& camera, const GLProgramHandle*
             customHandlerID = m_environmentMgr->GetShadowEnvironment()->Program;
         }
         frameBuffer->AttachFrameBuffer();
-        glViewport(0, 0, (GLsizei) frameBuffer->GetWidth(), (GLsizei) frameBuffer->GetHeight());
     }
     OrderRenderLayer orderRenderLayer(m_rendersLayer.begin(), m_rendersLayer.end());
 
@@ -87,8 +95,6 @@ void RenderMgr::RenderInstance(const CameraBase& camera, const GLProgramHandle*
             if (programPair.first == nullptr) continue;
             if (renderComp.empty()) continue;
 
-            glCullFace(GL_BACK);
-            glFrontFace(GL_CCW);
             glUseProgram(customHandlerID < 0 ? handler.Program : customHandlerID);
             //Attach Light
             lightMgr->AttachLightToShader(&handler);
@@ -122,8 +128,44 @@ void RenderMgr::RenderInstance(const CameraBase& camera, const GLProgramHandle*
 
 }
 
-void RenderMgr::RenderShadowInstance(const CameraBase& camera, const GLProgramHandle* handle) const {
+void RenderMgr::RenderShadowInstance(const CameraBase& camera, const GLProgramHandle& custom_handler,
+                                     const std::list<SIRender*>& render_objects) const {
+    const auto cameraMatrix = camera.GetCameraMatrixStruct();
+    const auto& frameBuffer = camera.GetFrameBuffer();
+    int customHandlerID = custom_handler.Program;
+    if(frameBuffer == nullptr) {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, (GLsizei) m_width, (GLsizei) m_height);
+    }
+    else {
+        // If the framebuffer is a depth buffer
+        if(frameBuffer->GetBufferType() == SFrameBuffer::DEPTH) {
+            customHandlerID = m_environmentMgr->GetShadowEnvironment()->Program;
+        }
+        frameBuffer->AttachFrameBuffer();
+    }
+
+    glUseProgram(customHandlerID);
+    // Initialize various state.
+    glEnableVertexAttribArray(custom_handler.Attributes.Position);
+    glEnableVertexAttribArray(custom_handler.Attributes.Weight);
+    glEnableVertexAttribArray(custom_handler.Attributes.JointId);
+
+    glClear(GL_DEPTH_BUFFER_BIT);
+    for (const auto& shadowObject : render_objects) {
+        if(!shadowObject->isRenderActive) continue;
+        const auto& shadow_transform = static_cast<RenderComponent*>(shadowObject)->GetGameObject()->GetTransform();
 
+        if(LightMgr::SHADOW_DISTANCE < vec3::Distance(cameraMatrix.cameraPosition, shadow_transform->m_position))
+            continue;
+
+        shadowObject->SetMatrix(cameraMatrix, &custom_handler);
+        shadowObject->Render(&custom_handler);
+    }
+    glDisableVertexAttribArray(custom_handler.Attributes.Position);
+    glDisableVertexAttribArray(custom_handler.Attributes.Weight);
+    glDisableVertexAttribArray(custom_handler.Attributes.JointId);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 void RenderMgr::Exterminate() {

diff --git a/src/Manager/RenderMgr.h b/src/Manager/RenderMgr.h
@@ -25,7 +25,8 @@ namespace CSE {
 
     private:
         void RenderInstance(const CameraBase& camera, const GLProgramHandle* custom_handler = nullptr) const;
-        void RenderShadowInstance(const CameraBase& camera, const GLProgramHandle* handle) const;
+        void RenderShadowInstance(const CameraBase& camera, const GLProgramHandle& custom_handler,
+                                  const std::list<SIRender*>& render_objects = std::list<SIRender*>()) const;
 
         void Exterminate();