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..4cf88842 100644 --- a/include/Engine/Rendering/DrawFinalPass.h +++ b/include/Engine/Rendering/DrawFinalPass.h @@ -17,16 +17,27 @@ 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; } + FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; } 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 34f442e9..d84f41d5 100644 --- a/include/Engine/Rendering/Renderer.h +++ b/include/Engine/Rendering/Renderer.h @@ -13,12 +13,15 @@ #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 "TextRenderer.h" +#include "imgui/imgui.h" +#include "TextPass.h" class Renderer : public IRenderer { @@ -36,7 +39,7 @@ public: private: //----------------------Variables----------------------// EventBroker* m_EventBroker; - TextRenderer* m_TextRenderer; + TextPass* m_TextPass; Texture* m_ErrorTexture; Texture* m_WhiteTexture; @@ -45,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(); @@ -58,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/TextRenderer.h b/include/Engine/Rendering/TextPass.h similarity index 79% rename from include/Engine/Rendering/TextRenderer.h rename to include/Engine/Rendering/TextPass.h index cdc1d8c7..8fbb3df0 100644 --- a/include/Engine/Rendering/TextRenderer.h +++ b/include/Engine/Rendering/TextPass.h @@ -10,14 +10,16 @@ #include "Font.h" #include "../Core/ResourceManager.h" #include "RenderQueue.h" +#include "TextPassState.h" +#include "FrameBuffer.h" -class TextRenderer +class TextPass { public: - TextRenderer(); + TextPass(); void Initialize(); void Update(); - void Draw(RenderScene& scene); + void Draw(RenderScene& scene, FrameBuffer& frameBuffer); private: void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix); diff --git a/include/Engine/Rendering/TextPassState.h b/include/Engine/Rendering/TextPassState.h new file mode 100644 index 00000000..fbed6356 --- /dev/null +++ b/include/Engine/Rendering/TextPassState.h @@ -0,0 +1,15 @@ +#ifndef TextPassState_h__ +#define TextPassState_h__ + +#include "Rendering/RenderState.h" + +class TextPassState : public RenderState +{ +public: + TextPassState(GLuint frameBuffer); + ~TextPassState(); +private: + +}; + +#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..e158640e 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, clamp(color_result.a, 0, 1)); + //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/resources/Shaders/Text.frag.glsl b/resources/Shaders/Text.frag.glsl index 2726b5d1..3b0f9e28 100644 --- a/resources/Shaders/Text.frag.glsl +++ b/resources/Shaders/Text.frag.glsl @@ -3,10 +3,15 @@ in vec2 TexCoords; out vec4 color; uniform sampler2D text; -uniform vec3 textColor; +uniform vec4 textColor; + +out vec4 sceneColor; +out vec4 bloomColor; void main() { vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r); - color = vec4(textColor, 1.0) * sampled; + vec4 color_result = textColor * sampled; + sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1)); + bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0) * sampled; } \ 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..0a91a9db 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() @@ -19,6 +39,8 @@ void DrawFinalPass::InitializeShaderPrograms() m_ForwardPlusProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/ForwardPlus.vert.glsl"))); m_ForwardPlusProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/ForwardPlus.frag.glsl"))); m_ForwardPlusProgram->Compile(); + m_ForwardPlusProgram->BindFragDataLocation(0, "sceneColor"); + m_ForwardPlusProgram->BindFragDataLocation(1, "bloomColor"); m_ForwardPlusProgram->Link(); } @@ -26,7 +48,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 +73,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 +95,42 @@ void DrawFinalPass::Draw(RenderScene& scene) continue; } } + m_FinalPassFrameBuffer.Unbind(); GLERROR("DrawFinalPass::Draw: END"); - + delete state; +} + + +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 d788fd8e..770baabf 100644 --- a/src/Engine/Rendering/Renderer.cpp +++ b/src/Engine/Rendering/Renderer.cpp @@ -9,8 +9,8 @@ void Renderer::Initialize() glfwSwapInterval(m_VSYNC); InitializeShaders(); InitializeTextures(); - m_TextRenderer = new TextRenderer(); - m_TextRenderer->Initialize(); + m_TextPass = new TextPass(); + m_TextPass->Initialize(); m_ScreenQuad = ResourceManager::Load("Models/Core/ScreenQuad.obj"); @@ -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) @@ -80,16 +74,22 @@ void Renderer::Update(double dt) { m_EventBroker->Process(); InputUpdate(dt); - m_TextRenderer->Update(); + m_TextPass->Update(); m_ImGuiRenderPass->Update(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_TextRenderer->Draw(*scene); + m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer()); } - + 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/TextRenderer.cpp b/src/Engine/Rendering/TextPass.cpp similarity index 80% rename from src/Engine/Rendering/TextRenderer.cpp rename to src/Engine/Rendering/TextPass.cpp index a8dfc083..1e3d5941 100644 --- a/src/Engine/Rendering/TextRenderer.cpp +++ b/src/Engine/Rendering/TextPass.cpp @@ -1,11 +1,11 @@ -#include "Rendering/TextRenderer.h" +#include "Rendering/TextPass.h" -TextRenderer::TextRenderer() +TextPass::TextPass() { } -void TextRenderer::Initialize() +void TextPass::Initialize() { glGenVertexArrays(1, &VAO); glGenBuffers(1, &VBO); @@ -21,16 +21,20 @@ void TextRenderer::Initialize() m_TextProgram->AddShader(std::shared_ptr(new VertexShader("Shaders/Text.vert.glsl"))); m_TextProgram->AddShader(std::shared_ptr(new FragmentShader("Shaders/Text.frag.glsl"))); m_TextProgram->Compile(); + m_TextProgram->BindFragDataLocation(0, "sceneColor"); + m_TextProgram->BindFragDataLocation(1, "bloomColor"); m_TextProgram->Link(); } -void TextRenderer::Update() +void TextPass::Update() { } -void TextRenderer::Draw(RenderScene& scene) +void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer) { + GLERROR("Derp1"); + TextPassState* state = new TextPassState(frameBuffer.GetHandle()); for (auto &job : scene.TextJobs) { auto textJob = std::dynamic_pointer_cast(job); if (textJob) { @@ -38,13 +42,15 @@ void TextRenderer::Draw(RenderScene& scene) renderText(textJob->Content, textJob->Resource, textJob->Alignment, textJob->Color, textJob->Matrix, scene.Camera->ProjectionMatrix(), scene.Camera->ViewMatrix()); } } + GLERROR("Derp2"); + delete state; } -void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix) +void TextPass::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix) { GLfloat penX = 0; GLfloat penY = 0; - float scale = 1.0/font->FontSize; + GLfloat scale = 1.0/font->FontSize; GLfloat stringWidth = 0.f; @@ -61,13 +67,10 @@ void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEn penX = 0; } - glEnable(GL_BLEND); - glDisable(GL_CULL_FACE); - glEnable(GL_DEPTH_TEST); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + m_TextProgram->Bind(); - glUniform3f(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), color.x, color.y, color.z); + glUniform4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), 1, glm::value_ptr(color)); glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix)); glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix)); glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix)); diff --git a/src/Engine/Rendering/TextPassState.cpp b/src/Engine/Rendering/TextPassState.cpp new file mode 100644 index 00000000..d285a1f0 --- /dev/null +++ b/src/Engine/Rendering/TextPassState.cpp @@ -0,0 +1,16 @@ +#include "Rendering/TextPassState.h" + + +TextPassState::TextPassState(GLuint frameBuffer) +{ + BindFramebuffer(frameBuffer); + glEnable(GL_BLEND); + glDisable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +} + +TextPassState::~TextPassState() +{ + +} 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" + diff --git a/src/Game/Systems/CapturePointSystem.cpp b/src/Game/Systems/CapturePointSystem.cpp index 67c2353c..fbd20e38 100644 --- a/src/Game/Systems/CapturePointSystem.cpp +++ b/src/Game/Systems/CapturePointSystem.cpp @@ -66,6 +66,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper nextPossibleCapturePoint["Blue"] = -1; for (size_t i = 0; i < m_NumberOfCapturePoints; i++) { + if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) { + continue; + } ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team"); if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint == 0) { nextPossibleCapturePoint["Red"] = i + 1; @@ -76,6 +79,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper } for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--) { + if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) { + continue; + } ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team"); if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint != 0) { nextPossibleCapturePoint["Red"] = i - 1;