Shadows WIP

- create 2D texture (depthmap)

include/Engine/Rendering/DirectionalLightJob.h

@@ -15,13 +15,14 @@ struct DirectionalLightJob : RenderJob
     DirectionalLightJob(ComponentWrapper transformComponent, ComponentWrapper directionalLightComponent, World* m_World)
         : RenderJob()
     {
-
-        Direction = glm::vec4(0,0,-1,0) * glm::inverse(Transform::AbsoluteOrientation(m_World, transformComponent.EntityID));
+        Orientation = Transform::AbsoluteOrientation(m_World, transformComponent.EntityID);
+        Direction = glm::vec4(0,0,-1,0) * glm::inverse(Orientation);
         //Direction = glm::vec4((glm::vec3)directionalLightComponent["Direction"], 0.f);
         Color = (glm::vec4)directionalLightComponent["Color"];
         Intensity = (double)directionalLightComponent["Intensity"];
     };
 
+    glm::quat Orientation;
     glm::vec4 Direction;
     glm::vec4 Color;
     float Intensity;

include/Engine/Rendering/Renderer.h

@@ -22,6 +22,7 @@
 #include "../Core/Transform.h"
 #include "imgui/imgui.h"
 #include "TextPass.h"
+#include "ShadowPass.h"
 
 class Renderer : public IRenderer
 {
@@ -57,6 +58,7 @@ private:
     DrawScreenQuadPass* m_DrawScreenQuadPass;
     DrawBloomPass* m_DrawBloomPass;
     DrawColorCorrectionPass* m_DrawColorCorrectionPass;
+    ShadowPass* m_ShadowPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();

include/Engine/Rendering/ShadowPass.cpp

@@ -0,0 +1,124 @@
+#include "ShadowPass.h"
+
+ShadowPass::ShadowPass(IRenderer * renderer)
+{
+    m_Renderer = renderer;
+
+    //InitializeTextures();
+    InitializeFrameBuffers();
+    InitializeShaderPrograms();
+}
+
+ShadowPass::~ShadowPass()
+{
+
+}
+
+
+void ShadowPass::InitializeFrameBuffers()
+{
+    
+//     glGenRenderbuffers(1, &m_DepthFBO);
+//     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthFBO);
+//     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+    // Depth texture
+    glGenTextures(1, &m_DepthMap);
+    glBindTexture(GL_TEXTURE_2D, m_DepthMap);
+    //glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 1024, 1024, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 1024, 1024, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
+    //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, 1024, 1024, 0, GL_RGB, GL_FLOAT, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    m_DepthBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthMap, GL_DEPTH_ATTACHMENT)));
+    //m_DepthBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthMap, GL_COLOR_ATTACHMENT0)));
+    m_DepthBuffer.Generate();
+
+    GLERROR("depthMap failed");
+
+}
+
+void ShadowPass::InitializeShaderPrograms()
+{
+    m_ShadowProgram = ResourceManager::Load<ShaderProgram>("#ShadowProgram");
+    m_ShadowProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Shadow.vert.glsl")));
+    m_ShadowProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Shadow.frag.glsl")));
+    m_ShadowProgram->Compile();
+    m_ShadowProgram->BindFragDataLocation(0, "ShadowMap");
+    m_ShadowProgram->Link();
+}
+
+void ShadowPass::ClearBuffer()
+{
+    m_DepthBuffer.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_DepthBuffer.Unbind();
+}
+
+void ShadowPass::Draw(RenderScene & scene)
+{
+    ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
+
+    GLuint shaderHandle = m_ShadowProgram->GetHandle();
+    glDrawBuffer(GL_NONE);
+    glReadBuffer(GL_NONE);
+    m_ShadowProgram->Bind();
+
+    //if (scene.ClearDepth) {
+    //    glClear(GL_COLOR_BUFFER_BIT);
+    //}
+
+    for (auto &job : scene.DirectionalLightJobs) {
+        auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
+        
+        if(directionalLightJob) {
+  
+            GLfloat near_plane = 1.0f, far_plane = 200.5f;
+            glm::mat4 lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane);
+
+            // broken?
+            //glm::mat4 lightView = glm::lookAt(-glm::normalize(glm::vec3(directionalLightJob->Direction)), glm::vec3(0,0,0), glm::vec3(0,1,0));
+            glm::mat4 lightView = glm::lookAt(glm::vec3(50.f, 50.f, 50.f), glm::vec3(0.f, 0.f, 0.f), glm::vec3(0.f, 1.f, 0.f));
+            //glm::mat4 lightSpaceMatrix = lightProjection * lightView;
+
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+
+            GLERROR("ShadowLight ERROR");
+
+            for (auto &objectJob : scene.OpaqueObjects) {
+                auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+                
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+
+                glBindVertexArray(modelJob->Model->VAO);
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+                glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
+
+                GLERROR("Shadow Draw ERROR");
+
+            }
+          
+        }
+
+        m_DepthBuffer.Unbind();
+
+        delete state;
+
+
+    }
+
+
+
+
+    //m_ShadowProgram->Unbind();
+
+
+
+
+
+}

include/Engine/Rendering/ShadowPass.h

@@ -0,0 +1,50 @@
+#ifndef ShadowPass_h_
+#define ShadowPass_h_
+
+#include "IRenderer.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "../Core/EventBroker.h"
+#include "../Core/World.h"
+#include "ShadowPassState.h"
+
+//#include "ShadowPassState.h" // not created yet
+
+
+
+class ShadowPass
+{
+public:
+    
+    ShadowPass(IRenderer* renderer);
+    ~ShadowPass();
+    
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+    void ClearBuffer();
+    void Draw(RenderScene& scene);
+
+ 
+
+    GLuint DepthMap() const { return m_DepthMap; }
+
+
+private:
+
+   
+
+    EventBroker* m_EventBroker;
+
+    const IRenderer* m_Renderer;
+
+    GLuint m_DepthMap;
+
+    FrameBuffer m_DepthBuffer;
+
+    ShaderProgram* m_ShadowProgram;
+
+    GLuint m_DepthFBO;
+
+};
+
+#endif

include/Engine/Rendering/ShadowPassState.h

@@ -0,0 +1,15 @@
+#ifndef ShadowPassState_h_
+#define ShadowPassState_h_
+
+#include "Rendering/RenderState.h"
+
+class ShadowPassState : public RenderState
+{
+public:
+    ShadowPassState(GLuint frameBuffer);
+    ~ShadowPassState();
+
+private:
+};
+
+#endif

resources/Shaders/Shadow.frag.glsl

@@ -0,0 +1,18 @@
+#version 430
+
+
+
+in VertexData{
+	vec3 Position;
+}Input;
+
+//layout(location = 0 ) out vec4 ShadowMap;
+layout(location = 0 ) out float ShadowMap;
+
+void main()
+{
+	//ShadowMap = vec4(vec3(gl_FragCoord.z), 1.0);
+	//ShadowMap = gl_FragCoord.z;
+}
+
+

resources/Shaders/Shadow.vert.glsl

@@ -0,0 +1,17 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{	
+	Output.Position = Position;
+	gl_Position = P * V * M * vec4(Position, 1.0);
+}

src/Engine/Rendering/FrameBuffer.cpp

@@ -58,7 +58,7 @@ void FrameBuffer::Generate()
         }
         
 
-        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT) {
+        if ((*it)->m_ResourceType == GL_TEXTURE_2D) {
             attachments.push_back((*it)->m_Attachment);
         }
     }

src/Engine/Rendering/Renderer.cpp

@@ -93,7 +93,7 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking\0Shadow");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -102,11 +102,13 @@ void Renderer::Draw(RenderFrame& frame)
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
+    m_ShadowPass->ClearBuffer();
 
     for (auto scene : frame.RenderScenes){
         
         SortRenderJobsByDepth(*scene);
         m_PickingPass->Draw(*scene);
+        m_ShadowPass->Draw(*scene);
         m_LightCullingPass->GenerateNewFrustum(*scene);
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
@@ -133,6 +135,10 @@ void Renderer::Draw(RenderFrame& frame)
     }
     if (m_DebugTextureToDraw == 4) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
+    } 
+    if (m_DebugTextureToDraw == 5) {
+        m_DrawScreenQuadPass->Draw(m_ShadowPass->DepthMap());
+       // m_DrawScreenQuadPass->Draw();
     }
 
     m_ImGuiRenderPass->Draw();
@@ -177,4 +183,5 @@ void Renderer::InitializeRenderPasses()
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
+    m_ShadowPass = new ShadowPass(this);
 }

src/Engine/Rendering/ShadowPassState.cpp

@@ -0,0 +1,16 @@
+#include "Rendering/ShadowPassState.h"
+
+ShadowPassState::ShadowPassState(GLuint frameBuffer)
+{
+    GLERROR("---2");
+    BindFramebuffer(frameBuffer);
+    GLERROR("---3");
+    Enable(GL_DEPTH_TEST);
+    Enable(GL_CULL_FACE);
+    Disable(GL_BLEND);
+}
+
+ShadowPassState::~ShadowPassState()
+{
+
+}