diff --git a/include/Engine/Rendering/DrawBloomPass.h b/include/Engine/Rendering/DrawBloomPass.h new file mode 100644 index 00000000..539d6957 --- /dev/null +++ b/include/Engine/Rendering/DrawBloomPass.h @@ -0,0 +1,53 @@ +#ifndef DrawBloomPass_h__ +#define DrawBloomPass_h__ + +#include "IRenderer.h" +#include "DrawBloomPassState.h" +//#include "LightCullingPass.h" Finalpass om den skall skickas in +#include "FrameBuffer.h" +#include "ShaderProgram.h" +//#include "Util/UnorderedMapVec2.h" +#include "Texture.h" + +class DrawBloomPass +{ +public: + DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ ); + ~DrawBloomPass() { } + void InitializeTextures(); + void InitializeFrameBuffers(); + void InitializeShaderPrograms(); + void InitializeBuffers(); + void ClearBuffer(); + + void FillGaussianBuffer(FrameBuffer* fb); + + void Draw(GLuint texture); + + //Getters + //Return the blurred result of the texture that was sent into draw + GLuint GaussianTexture() const { return m_GaussianTexture_vert; } + + +private: + void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const; + + Texture* m_WhiteTexture; + Model* m_ScreenQuad; + + const IRenderer* m_Renderer; + //const LightCullingPass* m_LightCullingPass + GLuint m_iterations = 9; + + GLuint m_GaussianTexture_horiz; + GLuint m_GaussianTexture_vert; + + FrameBuffer m_GaussianFrameBuffer_horiz; + FrameBuffer m_GaussianFrameBuffer_vert; + + ShaderProgram* m_GaussianProgram_horiz; + ShaderProgram* m_GaussianProgram_vert; + +}; + +#endif \ No newline at end of file diff --git a/include/Engine/Rendering/DrawBloomPassState.h b/include/Engine/Rendering/DrawBloomPassState.h new file mode 100644 index 00000000..7f2094cf --- /dev/null +++ b/include/Engine/Rendering/DrawBloomPassState.h @@ -0,0 +1,15 @@ +#ifndef DrawBloomPassState_h__ +#define DrawBloomPassState_h__ + +#include "Rendering/RenderState.h" + +class DrawBloomPassState : public RenderState +{ +public: + DrawBloomPassState(); + ~DrawBloomPassState(); +private: + +}; + +#endif \ No newline at end of file diff --git a/include/Engine/Rendering/DrawColorCorrectionPass.h b/include/Engine/Rendering/DrawColorCorrectionPass.h new file mode 100644 index 00000000..e9a7e281 --- /dev/null +++ b/include/Engine/Rendering/DrawColorCorrectionPass.h @@ -0,0 +1,29 @@ +#ifndef DrawColorCorrectionPass_h__ +#define DrawColorCorrectionPass_h__ + +#include "IRenderer.h" +#include "DrawScreenQuadPassState.h" +#include "FrameBuffer.h" +#include "ShaderProgram.h" +//#include "Util/UnorderedMapVec2.h" +#include "Texture.h" + +class DrawColorCorrectionPass +{ +public: + DrawColorCorrectionPass(IRenderer* renderer); + ~DrawColorCorrectionPass() { } + void InitializeFrameBuffers(); + void InitializeShaderPrograms(); + + void Draw(GLuint sceneTexture, GLuint bloomTexture); +private: + const IRenderer* m_Renderer; + + ShaderProgram* m_ColorCorrectionProgram; + + Model* m_ScreenQuad; + GLfloat m_Exposure; +}; + +#endif \ No newline at end of file diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h index 20c7249d..caf68f24 100644 --- a/include/Engine/Rendering/DrawFinalPass.h +++ b/include/Engine/Rendering/DrawFinalPass.h @@ -17,16 +17,25 @@ public: void InitializeTextures(); void InitializeFrameBuffers(); void InitializeShaderPrograms(); - void Draw(RenderScene& scene); + void ClearBuffer(); - //Getters - + //Return the texture that is used in later stages to apply the bloom effect + GLuint BloomTexture() const { return m_BloomTexture; } + //Return the texture with diffuse and lighting of the scene. + GLuint SceneTexture() const { return m_SceneTexture; } private: void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const; + void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const; Texture* m_WhiteTexture; + Texture* m_BlackTexture; + + FrameBuffer m_FinalPassFrameBuffer; + GLuint m_BloomTexture; + GLuint m_SceneTexture; + GLuint m_DepthBuffer; const IRenderer* m_Renderer; const LightCullingPass* m_LightCullingPass; diff --git a/include/Engine/Rendering/DrawFinalPassState.h b/include/Engine/Rendering/DrawFinalPassState.h index 72d8e392..10b840e9 100644 --- a/include/Engine/Rendering/DrawFinalPassState.h +++ b/include/Engine/Rendering/DrawFinalPassState.h @@ -6,7 +6,7 @@ class DrawFinalPassState : public RenderState { public: - DrawFinalPassState(); + DrawFinalPassState(GLuint frameBuffer); ~DrawFinalPassState(); private: diff --git a/include/Engine/Rendering/DrawScreenQuadPass.h b/include/Engine/Rendering/DrawScreenQuadPass.h new file mode 100644 index 00000000..117e9e1e --- /dev/null +++ b/include/Engine/Rendering/DrawScreenQuadPass.h @@ -0,0 +1,28 @@ +#ifndef DrawScreenQuadPass_h__ +#define DrawScreenQuadPass_h__ + +#include "IRenderer.h" +#include "DrawScreenQuadPassState.h" +#include "FrameBuffer.h" +#include "ShaderProgram.h" +//#include "Util/UnorderedMapVec2.h" +#include "Texture.h" + +class DrawScreenQuadPass +{ +public: + DrawScreenQuadPass(IRenderer* renderer); + ~DrawScreenQuadPass() { } + void InitializeFrameBuffers(); + void InitializeShaderPrograms(); + + void Draw(GLuint texture); +private: + const IRenderer* m_Renderer; + + ShaderProgram* m_DrawQuadProgram; + + Model* m_ScreenQuad; +}; + +#endif \ No newline at end of file diff --git a/include/Engine/Rendering/DrawScreenQuadPassState.h b/include/Engine/Rendering/DrawScreenQuadPassState.h new file mode 100644 index 00000000..63ab4729 --- /dev/null +++ b/include/Engine/Rendering/DrawScreenQuadPassState.h @@ -0,0 +1,15 @@ +#ifndef DrawScreenQuadPassState_h__ +#define DrawScreenQuadPassState_h__ + +#include "Rendering/RenderState.h" + +class DrawScreenQuadPassState : public RenderState +{ +public: + DrawScreenQuadPassState(); + ~DrawScreenQuadPassState(); +private: + +}; + +#endif \ No newline at end of file diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h index 7e124e3c..d84f41d5 100644 --- a/include/Engine/Rendering/Renderer.h +++ b/include/Engine/Rendering/Renderer.h @@ -13,10 +13,14 @@ #include "PickingPass.h" #include "LightCullingPass.h" #include "DrawFinalPass.h" +#include "DrawScreenQuadPass.h" +#include "DrawBloomPass.h" +#include "DrawColorCorrectionPass.h" #include "../Core/EventBroker.h" #include "ImGuiRenderPass.h" #include "Camera.h" #include "../Core/Transform.h" +#include "imgui/imgui.h" #include "TextPass.h" class Renderer : public IRenderer @@ -44,10 +48,15 @@ private: Model* m_UnitQuad; Model* m_UnitSphere; + int m_DebugTextureToDraw = 0; + PickingPass* m_PickingPass; LightCullingPass* m_LightCullingPass; ImGuiRenderPass* m_ImGuiRenderPass; DrawFinalPass* m_DrawFinalPass; + DrawScreenQuadPass* m_DrawScreenQuadPass; + DrawBloomPass* m_DrawBloomPass; + DrawColorCorrectionPass* m_DrawColorCorrectionPass; //----------------------Functions----------------------// void InitializeWindow(); @@ -57,14 +66,13 @@ private: //TODO: Renderer: Get InputUpdate out of renderer void InputUpdate(double dt); //void PickingPass(RenderQueueCollection& rq); - void DrawScreenQuad(GLuint textureToDraw); + //void DrawScreenQuad(GLuint textureToDraw); static bool DepthSort(const std::shared_ptr &i, const std::shared_ptr &j) { return (i->Depth < j->Depth); } void SortRenderJobsByDepth(RenderScene &scene); void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type); //--------------------ShaderPrograms-------------------// - ShaderProgram* m_BasicForwardProgram; - ShaderProgram* m_DrawScreenQuadProgram; + ShaderProgram* m_BasicForwardProgram; }; #endif \ No newline at end of file diff --git a/include/Engine/Rendering/Util/CommonFunctions.h b/include/Engine/Rendering/Util/CommonFunctions.h new file mode 100644 index 00000000..b262568c --- /dev/null +++ b/include/Engine/Rendering/Util/CommonFunctions.h @@ -0,0 +1,17 @@ +#ifndef CommonFuntions_h__ +#define CommonFuntions_h__ + +#include "../../Common.h" +#include "../../OpenGL.h" +#include "../../GLM.h" + +class CommonFuntions +{ +public: + CommonFuntions() = delete; + +private: + +}; + +#endif \ No newline at end of file diff --git a/resources/Shaders/DrawColorCorrection.frag.glsl b/resources/Shaders/DrawColorCorrection.frag.glsl new file mode 100644 index 00000000..8d13992a --- /dev/null +++ b/resources/Shaders/DrawColorCorrection.frag.glsl @@ -0,0 +1,32 @@ +#version 430 + +layout (binding = 0) uniform sampler2D SceneTexture; +layout (binding = 1) uniform sampler2D BloomTexture; +uniform float Exposure; + +in VertexData{ + vec2 TextureCoordinate; +}Input; + +out vec4 fragmentColor; + +void main() +{ + const float gamma = 2.2; + vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate); + vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate); + hdrColor += bloomColor; + + //Toon mapping thingy + vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure); + + //gamme correction + result = pow(result, vec3(1.0 / gamma)); + + fragmentColor = vec4(result, 1.0); + //fragmentColor = hdrColor; + //fragmentColor = bloomColor; + //fragmentColor = vec4(1,0.5,0.7,1); +} + + diff --git a/resources/Shaders/DrawColorCorrection.vert.glsl b/resources/Shaders/DrawColorCorrection.vert.glsl new file mode 100644 index 00000000..346bc141 --- /dev/null +++ b/resources/Shaders/DrawColorCorrection.vert.glsl @@ -0,0 +1,13 @@ +#version 430 + +layout (location = 0) in vec3 Position; + +out VertexData{ + vec2 TextureCoordinate; +}Output; + +void main() +{ + gl_Position = vec4(Position, 1.0); + Output.TextureCoordinate = (vec2(Position) + 1) / 2; +} \ No newline at end of file diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl index 78a2125e..403c96fc 100644 --- a/resources/Shaders/ForwardPlus.frag.glsl +++ b/resources/Shaders/ForwardPlus.frag.glsl @@ -5,7 +5,8 @@ uniform mat4 V; uniform mat4 P; uniform vec4 Color; uniform vec2 ScreenDimensions; -uniform sampler2D texture0; +layout (binding = 0) uniform sampler2D DiffuseTexture; +layout (binding = 1) uniform sampler2D GlowMap; #define TILE_SIZE 16 @@ -48,7 +49,8 @@ in VertexData{ vec4 DiffuseColor; }Input; -out vec4 fragmentColor; +out vec4 sceneColor; +out vec4 bloomColor; vec4 scene_ambient = vec4(0.3,0.3,0.3,1); @@ -99,9 +101,10 @@ LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensi void main() { - vec4 texel = texture2D(texture0, Input.TextureCoordinate); + vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate); + vec4 glowTexel = texture2D(GlowMap, Input.TextureCoordinate); vec4 position = V * M * vec4(Input.Position, 1.0); - vec4 normal = V * vec4(Input.Normal, 0.0); + vec4 normal = normalize(V * vec4(Input.Normal, 0.0)); vec4 viewVec = normalize(-position); vec2 tilePos; @@ -120,30 +123,42 @@ void main() int l = int(LightIndex[i]); LightSource light = LightSources.List[l]; - LightResult result; + LightResult light_result; + //These if statements should be removed. if(light.Type == 1) { // point - result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff); + light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff); } else if (light.Type == 2) { //Directional - result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal); + light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal); } - totalLighting.Diffuse += result.Diffuse; - totalLighting.Specular += result.Specular; + totalLighting.Diffuse += light_result.Diffuse; + totalLighting.Specular += light_result.Specular; } - - //fragmentColor += Input.DiffuseColor; - fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color; - //fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color; - //fragmentColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1); - //fragmentColor = texel * Input.DiffuseColor * Color; - //fragmentColor += vec4(currentTile/3600.f, 0, 0, 1); + //sceneColor += Input.DiffuseColor; + vec4 color_result = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color; + //bloomColor = vec4(0.3, 0.8, 0.6, 1.0); + sceneColor = vec4(color_result.xyz, 1.0); + //These if statements should be removed if they are slow. + color_result += glowTexel; + bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0); + /* + if(color_result.x > 1 || color_result.y > 1 || color_result.z > 1) { + bloomColor = vec4(color_result.xyz, 1.0); + } else { + bloomColor = vec4(0.0, 0.0, 0.0, 1.0); + } */ + + //sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * diffuseTexel * Color; + //sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1); + //sceneColor = diffuseTexel * Input.DiffuseColor * Color; + //sceneColor += vec4(currentTile/3600.f, 0, 0, 1); //Tiled Debug Code /* if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) { - fragmentColor += vec4(0.5, 0, 0, 0); + sceneColor += vec4(0.5, 0, 0, 0); } else { - fragmentColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1); + sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1); } */ } diff --git a/resources/Shaders/Gaussian_horiz.frag.glsl b/resources/Shaders/Gaussian_horiz.frag.glsl new file mode 100644 index 00000000..bd48d2d5 --- /dev/null +++ b/resources/Shaders/Gaussian_horiz.frag.glsl @@ -0,0 +1,23 @@ +#version 430 + +layout (binding = 0) uniform sampler2D Texture; + +in VertexData{ + vec2 TextureCoordinate; +}Input; + +out vec4 fragmentColor; + +uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216); + +void main() +{ + vec2 tex_offset = 1.0 / textureSize(Texture, 0); + vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0]; + + for(int i = 1; i < 5; ++i) { + result += texture(Texture, Input.TextureCoordinate + vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; + result += texture(Texture, Input.TextureCoordinate - vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; + } + fragmentColor = vec4(result, 1.0); +} \ No newline at end of file diff --git a/resources/Shaders/Gaussian_horiz.vert.glsl b/resources/Shaders/Gaussian_horiz.vert.glsl new file mode 100644 index 00000000..346bc141 --- /dev/null +++ b/resources/Shaders/Gaussian_horiz.vert.glsl @@ -0,0 +1,13 @@ +#version 430 + +layout (location = 0) in vec3 Position; + +out VertexData{ + vec2 TextureCoordinate; +}Output; + +void main() +{ + gl_Position = vec4(Position, 1.0); + Output.TextureCoordinate = (vec2(Position) + 1) / 2; +} \ No newline at end of file diff --git a/resources/Shaders/Gaussian_vert.frag.glsl b/resources/Shaders/Gaussian_vert.frag.glsl new file mode 100644 index 00000000..25b08f9f --- /dev/null +++ b/resources/Shaders/Gaussian_vert.frag.glsl @@ -0,0 +1,23 @@ +#version 430 + +layout (binding = 0) uniform sampler2D Texture; + +in VertexData{ + vec2 TextureCoordinate; +}Input; + +out vec4 fragmentColor; + +uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216); + +void main() +{ + vec2 tex_offset = 1.0 / textureSize(Texture, 0); + vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0]; + + for(int i = 1; i < 5; ++i) { + result += texture(Texture, Input.TextureCoordinate + vec2(0.0, tex_offset.y * i)).rgb * weight[i]; + result += texture(Texture, Input.TextureCoordinate - vec2(0.0, tex_offset.y * i)).rgb * weight[i]; + } + fragmentColor = vec4(result, 1.0); +} \ No newline at end of file diff --git a/resources/Shaders/Gaussian_vert.vert.glsl b/resources/Shaders/Gaussian_vert.vert.glsl new file mode 100644 index 00000000..346bc141 --- /dev/null +++ b/resources/Shaders/Gaussian_vert.vert.glsl @@ -0,0 +1,13 @@ +#version 430 + +layout (location = 0) in vec3 Position; + +out VertexData{ + vec2 TextureCoordinate; +}Output; + +void main() +{ + gl_Position = vec4(Position, 1.0); + Output.TextureCoordinate = (vec2(Position) + 1) / 2; +} \ No newline at end of file diff --git a/src/Engine/Rendering/DrawBloomPass.cpp b/src/Engine/Rendering/DrawBloomPass.cpp new file mode 100644 index 00000000..1ad97eb5 --- /dev/null +++ b/src/Engine/Rendering/DrawBloomPass.cpp @@ -0,0 +1,134 @@ +#include "Rendering/DrawBloomPass.h" + +DrawBloomPass::DrawBloomPass(IRenderer* renderer) +{ + m_Renderer = renderer; + + m_ScreenQuad = ResourceManager::Load("Models/Core/ScreenQuad.obj"); + + InitializeTextures(); + InitializeBuffers(); + InitializeShaderPrograms(); +} + +void DrawBloomPass::InitializeTextures() +{ + m_WhiteTexture = ResourceManager::Load("Textures/Core/Blank.png"); +} + +void DrawBloomPass::InitializeShaderPrograms() +{ + m_GaussianProgram_horiz = ResourceManager::Load("##GaussianProgramHoriz"); + m_GaussianProgram_horiz->AddShader(std::shared_ptr(new VertexShader("Shaders/Gaussian_horiz.vert.glsl"))); + m_GaussianProgram_horiz->AddShader(std::shared_ptr(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl"))); + m_GaussianProgram_horiz->Compile(); + m_GaussianProgram_horiz->Link(); + + m_GaussianProgram_vert = ResourceManager::Load("##GaussianProgramVert"); + m_GaussianProgram_vert->AddShader(std::shared_ptr(new VertexShader("Shaders/Gaussian_vert.vert.glsl"))); + m_GaussianProgram_vert->AddShader(std::shared_ptr(new FragmentShader("Shaders/Gaussian_vert.frag.glsl"))); + m_GaussianProgram_vert->Compile(); + m_GaussianProgram_vert->Link(); +} + + +void DrawBloomPass::InitializeBuffers() +{ + GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT); + + m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0))); + m_GaussianFrameBuffer_horiz.Generate(); + + GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT); + + m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0))); + m_GaussianFrameBuffer_vert.Generate(); +} + + +void DrawBloomPass::ClearBuffer() +{ + m_GaussianFrameBuffer_horiz.Bind(); + glClearColor(0.f, 0.f, 0.f, 0.f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + m_GaussianFrameBuffer_horiz.Unbind(); + m_GaussianFrameBuffer_vert.Bind(); + glClearColor(0.f, 0.f, 0.f, 0.f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + m_GaussianFrameBuffer_vert.Unbind(); +} + +void DrawBloomPass::Draw(GLuint texture) +{ + GLERROR("DrawBloomPass::Draw: Pre"); + + DrawBloomPassState state; + + GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle(); + GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle(); + + + //Horizontal pass, first use the given texture then save it to the horizontal framebuffer. + m_GaussianFrameBuffer_horiz.Bind(); + m_GaussianProgram_horiz->Bind(); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); + + //Iterate some times to make it more gaussian. + for (int i = 1; i < m_iterations; i++) { + //Vertical pass + m_GaussianFrameBuffer_vert.Bind(); + m_GaussianProgram_vert->Bind(); + + glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); + + //horizontal pass + + m_GaussianFrameBuffer_horiz.Bind(); + m_GaussianProgram_horiz->Bind(); + + glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_vert); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); + } + + //final vertical gaussian after the iterations are done + + m_GaussianFrameBuffer_vert.Bind(); + m_GaussianProgram_vert->Bind(); + + glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); + + GLERROR("DrawBloomPass::Draw: END"); +} + +void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const +{ + glGenTextures(1, texture); + glBindTexture(GL_TEXTURE_2D, *texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering); + glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution + GLERROR("Texture initialization failed"); +} diff --git a/src/Engine/Rendering/DrawBloomPassState.cpp b/src/Engine/Rendering/DrawBloomPassState.cpp new file mode 100644 index 00000000..f9c57475 --- /dev/null +++ b/src/Engine/Rendering/DrawBloomPassState.cpp @@ -0,0 +1,15 @@ +#include "Rendering/DrawBloomPassState.h" + + +DrawBloomPassState::DrawBloomPassState() +{ + //BindFramebuffer(0); + Disable(GL_BLEND); + Disable(GL_DEPTH_TEST); + Disable(GL_CULL_FACE); +} + +DrawBloomPassState::~DrawBloomPassState() +{ + +} diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp new file mode 100644 index 00000000..c9789602 --- /dev/null +++ b/src/Engine/Rendering/DrawColorCorrectionPass.cpp @@ -0,0 +1,41 @@ +#include "Rendering/DrawColorCorrectionPass.h" + +DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer) +{ + m_Renderer = renderer; + + m_ScreenQuad = ResourceManager::Load("Models/Core/ScreenQuad.obj"); + m_Exposure = 1; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting. + + InitializeShaderPrograms(); +} + +void DrawColorCorrectionPass::InitializeShaderPrograms() +{ + m_ColorCorrectionProgram = ResourceManager::Load("#ColorCorrectionProgram"); + m_ColorCorrectionProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/DrawColorCorrection.vert.glsl"))); + m_ColorCorrectionProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/DrawColorCorrection.frag.glsl"))); + m_ColorCorrectionProgram->Compile(); + m_ColorCorrectionProgram->Link(); +} + +void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture) +{ + //glBindFramebuffer(GL_FRAMEBUFFER, 0); + GLERROR("DrawScreenQuadPass::Draw: Pre"); + + DrawScreenQuadPassState state = DrawScreenQuadPassState(); + m_ColorCorrectionProgram->Bind(); + glClear(GL_COLOR_BUFFER_BIT); + glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, sceneTexture); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, bloomTexture); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); +} diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp index eeaa7bb3..36a14610 100644 --- a/src/Engine/Rendering/DrawFinalPass.cpp +++ b/src/Engine/Rendering/DrawFinalPass.cpp @@ -6,11 +6,31 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling m_LightCullingPass = lightCullingPass; InitializeTextures(); InitializeShaderPrograms(); + InitializeFrameBuffers(); } void DrawFinalPass::InitializeTextures() { m_WhiteTexture = ResourceManager::Load("Textures/Core/Blank.png"); + m_BlackTexture = ResourceManager::Load("Textures/Core/Black.png"); +} + +void DrawFinalPass::InitializeFrameBuffers() +{ + glGenRenderbuffers(1, &m_DepthBuffer); + glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height); + + GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT); + //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT); + //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT); + GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4); + + m_FinalPassFrameBuffer.AddResource(std::shared_ptr(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT))); + m_FinalPassFrameBuffer.AddResource(std::shared_ptr(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0))); + m_FinalPassFrameBuffer.AddResource(std::shared_ptr(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1))); + m_FinalPassFrameBuffer.Generate(); + } void DrawFinalPass::InitializeShaderPrograms() @@ -26,7 +46,7 @@ void DrawFinalPass::Draw(RenderScene& scene) { GLERROR("DrawFinalPass::Draw: Pre"); - DrawFinalPassState state; + DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle()); m_ForwardPlusProgram->Bind(); GLuint shaderHandle = m_ForwardPlusProgram->GetHandle(); @@ -51,13 +71,20 @@ void DrawFinalPass::Draw(RenderScene& scene) glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix)); glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color)); + glActiveTexture(GL_TEXTURE0); if(modelJob->DiffuseTexture != nullptr) { - glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture); } else { - glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture); } + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture); + + /*if(modelJob->GlowMap != nullptr) { + glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture); + } else { + glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture); + }*/ glBindVertexArray(modelJob->Model->VAO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer); @@ -66,6 +93,41 @@ void DrawFinalPass::Draw(RenderScene& scene) continue; } } + m_FinalPassFrameBuffer.Unbind(); GLERROR("DrawFinalPass::Draw: END"); - +} + + +void DrawFinalPass::ClearBuffer() +{ + m_FinalPassFrameBuffer.Bind(); + glClearColor(0.f, 0.f, 0.f, 0.f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + m_FinalPassFrameBuffer.Unbind(); +} + +void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const +{ + glGenTextures(1, texture); + glBindTexture(GL_TEXTURE_2D, *texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering); + glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution + GLERROR("Texture initialization failed"); +} + +void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const +{ + glGenTextures(1, texture); + glBindTexture(GL_TEXTURE_2D, *texture); + glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, dimensions.x, dimensions.y); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, dimensions.x, dimensions.y, format, type, texture); + glGenerateMipmap(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + GLERROR("MipMap Texture initialization failed"); } diff --git a/src/Engine/Rendering/DrawFinalPassState.cpp b/src/Engine/Rendering/DrawFinalPassState.cpp index 2cda4069..3ebe320d 100644 --- a/src/Engine/Rendering/DrawFinalPassState.cpp +++ b/src/Engine/Rendering/DrawFinalPassState.cpp @@ -1,14 +1,14 @@ #include "Rendering/DrawFinalPassState.h" -DrawFinalPassState::DrawFinalPassState() +DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer) { - BindFramebuffer(0); + BindFramebuffer(frameBuffer); Enable(GL_BLEND); BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); Enable(GL_DEPTH_TEST); Enable(GL_CULL_FACE); - ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f)); + ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f)); } DrawFinalPassState::~DrawFinalPassState() diff --git a/src/Engine/Rendering/DrawScreenQuadPass.cpp b/src/Engine/Rendering/DrawScreenQuadPass.cpp new file mode 100644 index 00000000..4b155fc9 --- /dev/null +++ b/src/Engine/Rendering/DrawScreenQuadPass.cpp @@ -0,0 +1,37 @@ +#include "Rendering/DrawScreenQuadPass.h" + +DrawScreenQuadPass::DrawScreenQuadPass(IRenderer* renderer) +{ + m_Renderer = renderer; + + m_ScreenQuad = ResourceManager::Load("Models/Core/ScreenQuad.obj"); + + InitializeShaderPrograms(); +} + +void DrawScreenQuadPass::InitializeShaderPrograms() +{ + m_DrawQuadProgram = ResourceManager::Load("#DrawScreenQuadProgram"); + m_DrawQuadProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/DrawScreenQuad.vert.glsl"))); + m_DrawQuadProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl"))); + m_DrawQuadProgram->Compile(); + m_DrawQuadProgram->Link(); +} + +void DrawScreenQuadPass::Draw(GLuint texture) +{ + //glBindFramebuffer(GL_FRAMEBUFFER, 0); + GLERROR("DrawScreenQuadPass::Draw: Pre"); + + DrawScreenQuadPassState state = DrawScreenQuadPassState(); + m_DrawQuadProgram->Bind(); + glClear(GL_COLOR_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture); + + glBindVertexArray(m_ScreenQuad->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 + , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); +} diff --git a/src/Engine/Rendering/DrawScreenQuadPassState.cpp b/src/Engine/Rendering/DrawScreenQuadPassState.cpp new file mode 100644 index 00000000..33a4895d --- /dev/null +++ b/src/Engine/Rendering/DrawScreenQuadPassState.cpp @@ -0,0 +1,18 @@ +#include "Rendering/DrawScreenQuadPassState.h" + + +DrawScreenQuadPassState::DrawScreenQuadPassState() +{ + GLERROR("---"); + BindFramebuffer(0); + GLERROR("---"); + Disable(GL_DEPTH_TEST); + Disable(GL_CULL_FACE); + Disable(GL_BLEND); + ClearColor(glm::vec4(0.f)); +} + +DrawScreenQuadPassState::~DrawScreenQuadPassState() +{ + +} diff --git a/src/Engine/Rendering/FrameBuffer.cpp b/src/Engine/Rendering/FrameBuffer.cpp index b2b29626..b7e908cc 100644 --- a/src/Engine/Rendering/FrameBuffer.cpp +++ b/src/Engine/Rendering/FrameBuffer.cpp @@ -55,8 +55,9 @@ void FrameBuffer::Generate() glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle); GLERROR("FrameBuffer generate: glFramebufferRenderbuffer"); if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 || + (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 || (*it)->m_Attachment != GL_DEPTH_ATTACHMENT || - (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) + (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta { LOG_ERROR("RenderBuffer Attachment not valid."); } @@ -69,10 +70,8 @@ void FrameBuffer::Generate() } } - - GLenum* bufferTextures = &attachments[0]; - glDrawBuffers(1, bufferTextures); + glDrawBuffers(attachments.size(), bufferTextures); if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus); diff --git a/src/Engine/Rendering/PickingPass.cpp b/src/Engine/Rendering/PickingPass.cpp index 6f448896..f063b344 100644 --- a/src/Engine/Rendering/PickingPass.cpp +++ b/src/Engine/Rendering/PickingPass.cpp @@ -54,52 +54,49 @@ void PickingPass::Draw(RenderScene& scene) if (scene.ClearDepth) { glClear(GL_DEPTH_BUFFER_BIT); } + m_Camera = scene.Camera; - m_Camera = scene.Camera; + for (auto &job : scene.ForwardJobs) { + auto modelJob = std::dynamic_pointer_cast(job); - for (auto &job : scene.ForwardJobs) { - auto modelJob = std::dynamic_pointer_cast(job); + if (modelJob) { + int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] }; - if (modelJob) { - int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] }; + PickingInfo pickInfo; + pickInfo.Entity = modelJob->Entity; + pickInfo.World = modelJob->World; + pickInfo.Camera = scene.Camera; - PickingInfo pickInfo; - pickInfo.Entity = modelJob->Entity; - pickInfo.World = modelJob->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; + 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]++; - } else { + } else { m_ColorCounter[0]++; - } } - - m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo; - - glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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(modelJob->Model->VAO); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer); - glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex); } + + m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo; + + glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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(modelJob->Model->VAO); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer); + glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex); } - + } m_PickingBuffer.Unbind(); GLERROR("PickingPass Error"); - delete state; } diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp index e84768e4..57849d99 100644 --- a/src/Engine/Rendering/Renderer.cpp +++ b/src/Engine/Rendering/Renderer.cpp @@ -63,12 +63,6 @@ void Renderer::InitializeWindow() void Renderer::InitializeShaders() { m_BasicForwardProgram = ResourceManager::Load("#m_BasicForwardProgram"); - - m_DrawScreenQuadProgram = ResourceManager::Load("#DrawScreenQuadProgram"); - m_DrawScreenQuadProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/DrawScreenQuad.vert.glsl"))); - m_DrawScreenQuadProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl"))); - m_DrawScreenQuadProgram->Compile(); - m_DrawScreenQuadProgram->Link(); } void Renderer::InputUpdate(double dt) @@ -86,10 +80,16 @@ void Renderer::Update(double dt) void Renderer::Draw(RenderFrame& frame) { - glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f); + ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking"); + //clear buffer 0 + glClearColor(0.f, 0.f, 0.f, 0.f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + //Clear other buffers m_PickingPass->ClearPicking(); + m_DrawFinalPass->ClearBuffer(); + m_DrawBloomPass->ClearBuffer(); + for (auto scene : frame.RenderScenes){ SortRenderJobsByDepth(*scene); @@ -98,14 +98,28 @@ void Renderer::Draw(RenderFrame& frame) m_LightCullingPass->FillLightList(*scene); m_LightCullingPass->CullLights(*scene); m_DrawFinalPass->Draw(*scene); - //m_DrawScenePass->Draw(rq); GLERROR("Renderer::Draw m_DrawScenePass->Draw"); m_TextPass->Draw(*scene); } - + m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture()); + if(m_DebugTextureToDraw == 0) { + m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture()); + } + if (m_DebugTextureToDraw == 1) { + m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture()); + } + if (m_DebugTextureToDraw == 2) { + m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture()); + } + if (m_DebugTextureToDraw == 3) { + m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture()); + } + if (m_DebugTextureToDraw == 4) { + m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture()); + } m_ImGuiRenderPass->Draw(); glfwSwapBuffers(m_Window); @@ -116,27 +130,6 @@ PickData Renderer::Pick(glm::vec2 screenCoord) return m_PickingPass->Pick(screenCoord); } -void Renderer::DrawScreenQuad(GLuint textureToDraw) -{ - glBindFramebuffer(GL_FRAMEBUFFER, 0); - - glDisable(GL_DEPTH_TEST); - glDisable(GL_CULL_FACE); - - glClearColor(0.f, 0.f, 0.f, 1.f); - glClear(GL_COLOR_BUFFER_BIT); - - - m_DrawScreenQuadProgram->Bind(); - glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_2D, textureToDraw); - - glBindVertexArray(m_ScreenQuad->VAO); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer); - glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1 - , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex); -} - void Renderer::InitializeTextures() { m_ErrorTexture = ResourceManager::Load("Textures/Core/ErrorTexture.png"); @@ -167,4 +160,7 @@ void Renderer::InitializeRenderPasses() m_PickingPass = new PickingPass(this, m_EventBroker); m_LightCullingPass = new LightCullingPass(this); m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass); + m_DrawScreenQuadPass = new DrawScreenQuadPass(this); + m_DrawBloomPass = new DrawBloomPass(this); + m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this); } diff --git a/src/Engine/Rendering/Util/CommonFunctions.cpp b/src/Engine/Rendering/Util/CommonFunctions.cpp new file mode 100644 index 00000000..3c81de66 --- /dev/null +++ b/src/Engine/Rendering/Util/CommonFunctions.cpp @@ -0,0 +1,2 @@ +#include "Rendering/Util/CommonFunctions.h" +