Merge branch 'master' of https://github.com/teamfisk/TacticalZ into SSAO

Conflicts:
	include/Engine/Rendering/Renderer.h
	src/Engine/Rendering/Renderer.cpp

src/Engine/Rendering/DrawBloomPass.cpp

@@ -120,6 +120,15 @@ void DrawBloomPass::Draw(GLuint texture)
     GLERROR("DrawBloomPass::Draw: END");
 }
 
+
+void DrawBloomPass::OnWindowResize()
+{
+    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_GaussianFrameBuffer_vert.Generate();
+    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_GaussianFrameBuffer_horiz.Generate();
+}
+
 void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
     glGenTextures(1, texture);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -276,6 +276,27 @@ void DrawFinalPass::ClearBuffer()
     m_FinalPassFrameBuffer.Unbind();
 }
 
+
+void DrawFinalPass::OnWindowResize()
+{
+    //InitializeFrameBuffers();
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_FinalPassFrameBuffer.Generate();
+
+
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferLowRes);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
+
+    GenerateTexture(&m_SceneTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_FinalPassFrameBufferLowRes.Generate();
+    GLERROR("Error changing texture resolutions");
+}
+
 void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
     glGenTextures(1, texture);
@@ -694,9 +715,6 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
             glDrawElements(GL_TRIANGLES, spriteJob->EndIndex - spriteJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(spriteJob->StartIndex*sizeof(unsigned int)));
         }
     }
-
-    
-
    // m_SpriteProgram->Unbind();
 }
 
@@ -710,7 +728,7 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
 	GLERROR("Bind 4 uniform");
 
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 	GLERROR("Bind 5 uniform");
 
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
@@ -743,6 +761,8 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
     glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
 	GLERROR("Bind 19 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+    GLERROR("Bind 20 uniform");
+    glUniform1f(glGetUniformLocation(shaderHandle, "GlowIntensity"), job->GlowIntensity);
     GLERROR("END");
 }
 
@@ -769,7 +789,7 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 		GLERROR("Bind 3 uniform");
 	}
 	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
-	glUniform2f(Location_ScreenDimensions, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	glUniform2f(Location_ScreenDimensions, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 	GLERROR("Bind 5 uniform");
 
 	GLint Location_FillPercentage = glGetUniformLocation(shaderHandle, "FillPercentage");
@@ -787,6 +807,11 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 	GLint Location_AmbientColor = glGetUniformLocation(shaderHandle, "AmbientColor");
 	glUniform4fv(Location_AmbientColor, 1, glm::value_ptr(scene.AmbientColor));
 
+    GLERROR("Bind 10 uniform");
+    GLint Location_GlowIntensity = glGetUniformLocation(shaderHandle, "GlowIntensity");
+
+    glUniform1f(Location_GlowIntensity, job->GlowIntensity);
+
 	GLERROR("END");
 }
 

src/Engine/Rendering/FrameBuffer.cpp

@@ -72,8 +72,8 @@ void FrameBuffer::Generate()
 
     GLenum* bufferTextures = &attachments[0];
     glDrawBuffers(attachments.size(), bufferTextures);
-    if(GLERROR("4")) {
-        printf("hello");
+    if (GLERROR("GLBufferAttachement error")) {
+        printf(": AttachmentSize %i", attachments.size());
     }
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {

src/Engine/Rendering/LightCullingPass.cpp

@@ -110,6 +110,34 @@ void LightCullingPass::FillLightList(RenderScene& scene)
     }
 }
 
+
+void LightCullingPass::OnWindowResize()
+{
+    SetSSBOSizes();
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_FrustumSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Frustum)*m_NumberOfTiles, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_FrustumSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(LightSource) * 200, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_LightSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightGridSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(LightGrid)*m_NumberOfTiles, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_LightGridSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightOffsetSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightOffset), &m_LightOffset, GL_DYNAMIC_COPY);
+    GLERROR("m_LightOffsetSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightIndexSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float)*m_NumberOfTiles*MAX_LIGHTS_PER_TILE, m_LightIndex, GL_DYNAMIC_COPY);
+    GLERROR("m_LightIndexSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+}
+
 void LightCullingPass::InitializeSSBOs()
 {
     glGenBuffers(1, &m_FrustumSSBO);

src/Engine/Rendering/PickingPass.cpp

@@ -15,6 +15,8 @@ PickingPass::~PickingPass()
 
 }
 
+
+
 void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
@@ -245,6 +247,52 @@ void PickingPass::Draw(RenderScene& scene)
         }
     }
 
+    for (auto& job : scene.Jobs.SpriteJob) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if (!spriteJob->Pickable) {
+            continue;
+        }
+        RenderState jobState;
+
+        if (spriteJob) {
+            if (spriteJob->Depth == 0) {
+                jobState.Disable(GL_DEPTH_TEST);
+            }
+            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+
+            PickingInfo pickInfo;
+            pickInfo.Entity = spriteJob->Entity;
+            pickInfo.World = spriteJob->World;
+            pickInfo.Camera = scene.Camera;
+
+            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+            if (color != m_EntityColors.end()) {
+                pickColor[0] = color->second[0];
+                pickColor[1] = color->second[1];
+            } else {
+                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+                if (m_ColorCounter[0] > 255) {
+                    m_ColorCounter[0] = 0;
+                    m_ColorCounter[1] += 1;
+                } else {
+                    m_ColorCounter[0] += 1;
+                }
+            }
+
+            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+
+            m_PickingProgram->Bind();
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(spriteJob->Matrix));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+            glBindVertexArray(spriteJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, spriteJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, spriteJob->EndIndex - spriteJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(spriteJob->StartIndex * sizeof(unsigned int)));
+        }
+    }
+
  /*   for (auto &job : scene.Jobs.TransparentShieldedObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
@@ -317,8 +365,6 @@ void PickingPass::Draw(RenderScene& scene)
     delete state;
 }
 
-
-
 void PickingPass::ClearPicking()
 {
     m_PickingColorsToEntity.clear();
@@ -332,6 +378,15 @@ void PickingPass::ClearPicking()
     m_PickingBuffer.Unbind();
 }
 
+
+void PickingPass::OnWindowResize()
+{
+    InitializeTextures();
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    m_PickingBuffer.Generate();
+}
+
 PickData PickingPass::Pick(glm::vec2 screenCoord)
 {
     int fbWidth;

src/Engine/Rendering/Renderer.cpp

@@ -1,5 +1,7 @@
 #include "Rendering/Renderer.h"
 
+std::unordered_map<GLFWwindow*, Renderer*> Renderer::m_WindowToRenderer;
+
 void Renderer::Initialize()
 {
 	InitializeWindow();
@@ -12,7 +14,6 @@ void Renderer::Initialize()
     m_TextPass = new TextPass();
     m_TextPass->Initialize();
 
-
    /* m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
     m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");*/
@@ -20,6 +21,17 @@ void Renderer::Initialize()
     m_ImGuiRenderPass = new ImGuiRenderPass(this, m_EventBroker);
 }
 
+void Renderer::glfwFrameBufferCallback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+    Renderer* currentRenderer = m_WindowToRenderer[window];
+    currentRenderer->m_ViewportSize = Rectangle(width, height);
+    currentRenderer->m_DrawFinalPass->OnWindowResize();
+    currentRenderer->m_LightCullingPass->OnWindowResize();
+    currentRenderer->m_PickingPass->OnWindowResize();
+    currentRenderer->m_DrawBloomPass->OnWindowResize();
+}
+
 void Renderer::InitializeWindow()
 {
 	// Initialize GLFW
@@ -39,6 +51,7 @@ void Renderer::InitializeWindow()
 		LOG_ERROR("GLFW: Failed to create window");
 		exit(EXIT_FAILURE);
 	}
+    glfwSetFramebufferSizeCallback(m_Window, &glfwFrameBufferCallback);
 	glfwMakeContextCurrent(m_Window);
 
 	// GL version info
@@ -59,8 +72,10 @@ void Renderer::InitializeWindow()
 		exit(EXIT_FAILURE);
 	}
 
+    m_WindowToRenderer[m_Window] = this;
+
     int windowSize[2];
-    glfwGetWindowSize(m_Window, &windowSize[0], &windowSize[1]);
+    glfwGetFramebufferSize(m_Window, &windowSize[0], &windowSize[1]);
     m_ViewportSize = Rectangle(windowSize[0], windowSize[1]);
 }
 
@@ -107,9 +122,11 @@ void Renderer::Draw(RenderFrame& frame)
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     //Clear other buffers
+    PerformanceTimer::StartTimer("Renderer-ClearBuffers");
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
+    PerformanceTimer::StopTimer("Renderer-ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
 		m_PickingPass->Draw(*scene);
 		GLERROR("Drawing pickingpass");
@@ -118,27 +135,38 @@ void Renderer::Draw(RenderFrame& frame)
 	GLuint ao = m_SSAOPass->SSAOTexture();
     for (auto scene : frame.RenderScenes){
         
+        PerformanceTimer::StartTimer("Renderer-Depth");
         SortRenderJobsByDepth(*scene);
         GLERROR("SortByDepth");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Drawing PickingPass");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Generate Frustrums");
         m_LightCullingPass->GenerateNewFrustum(*scene);
         GLERROR("Generate frustums");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Filling Light List");
         m_LightCullingPass->FillLightList(*scene);
         GLERROR("Filling light list");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Light Culling");
         m_LightCullingPass->CullLights(*scene);
         GLERROR("LightCulling");
 		m_DrawFinalPass->Draw(*scene, ao);
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
         GLERROR("Draw Geometry+Light");
         //m_DrawScenePass->Draw(*scene);
 
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Text");
         m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
         GLERROR("Draw Text");
-
+        PerformanceTimer::StopTimer("Renderer-Draw Text");
     }
+    PerformanceTimer::StartTimer("Renderer-Draw Bloom");
     m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
-
+    PerformanceTimer::StopTimer("Renderer-Draw Bloom");
     if (m_DebugTextureToDraw == 0) {
+        PerformanceTimer::StartTimer("Renderer-Color Correction Pass");
         m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), frame.Gamma, frame.Exposure);
+        PerformanceTimer::StopTimer("Renderer-Color Correction Pass");
     }
+    PerformanceTimer::StartTimer("Renderer-Misc Debug Draws");
     if (m_DebugTextureToDraw == 1) {
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
     }
@@ -157,13 +185,16 @@ void Renderer::Draw(RenderFrame& frame)
     if (m_DebugTextureToDraw == 6) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
+    PerformanceTimer::StopTimer("Renderer-Misc Debug Draws");
 	if (m_DebugTextureToDraw == 7) {
 		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
 	}
 
+    PerformanceTimer::StartTimer("Renderer-ImGuiRenderPass");
     m_ImGuiRenderPass->Draw();
     GLERROR("Imgui draw");
     glfwSwapBuffers(m_Window);
+    PerformanceTimer::StopTimer("Renderer-ImGuiRenderPass");
 }
 
 PickData Renderer::Pick(glm::vec2 screenCoord)