Merge pull request #144 from teamfisk/RenderSetingsV2

Render settings

include/Engine/Rendering/DrawBloomPass.h

@@ -12,7 +12,7 @@
 class DrawBloomPass
 {
 public:
-    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
+    DrawBloomPass(IRenderer* renderer, ConfigFile* config);
     ~DrawBloomPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -23,26 +23,33 @@ public:
     void FillGaussianBuffer(FrameBuffer* fb);
 
     void Draw(GLuint texture);
+	void ChangeQuality(int quality);
 
     void OnWindowResize();
 
     //Getters
     //Return the blurred result of the texture that was sent into draw
-    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
+	GLuint GaussianTexture() const { 
+		if (m_Quality == 0) { 
+			return m_BlackTexture->m_Texture;
+		} else { 
+			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_BlackTexture;
-
-    Texture* m_WhiteTexture;
     Model* m_ScreenQuad;
 
     const IRenderer* m_Renderer;
+	ConfigFile* m_Config;
     //const LightCullingPass* m_LightCullingPass 
-    GLuint m_iterations = 9;
+    int m_Iterations;
+	int m_Quality = 0;
 
-    GLuint m_GaussianTexture_horiz;
+    GLuint m_GaussianTexture_horiz = 0;
-    GLuint m_GaussianTexture_vert;
+    GLuint m_GaussianTexture_vert = 0;
 
     FrameBuffer m_GaussianFrameBuffer_horiz;
     FrameBuffer m_GaussianFrameBuffer_vert;

include/Engine/Rendering/DrawFinalPass.h

@@ -5,6 +5,7 @@
 #include "DrawFinalPassState.h"
 #include "LightCullingPass.h"
 #include "CubeMapPass.h"
+#include "SSAOPass.h"
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
 #include "Util/UnorderedMapVec2.h"
@@ -14,12 +15,12 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, GLuint* depthBuffer);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-    void Draw(RenderScene& scene, GLuint SSAOTexture);
+    void Draw(RenderScene& scene);
     void ClearBuffer();
     void OnWindowResize();
 
@@ -34,11 +35,8 @@ public:
     FrameBuffer* FinalPassFrameBufferLowRes() { return &m_FinalPassFrameBufferLowRes; }
 
 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;
-
     void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
-    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene, GLuint SSAOTexture);
+    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
@@ -61,7 +59,7 @@ private:
     GLuint m_SceneTexture;
     GLuint m_BloomTextureLowRes;
     GLuint m_SceneTextureLowRes;
-    GLuint m_DepthBuffer;
+    GLuint* m_DepthBuffer;
     GLuint m_DepthBufferLowRes;
     GLuint m_CubeMapTexture;
 
@@ -71,6 +69,7 @@ private:
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
     const CubeMapPass* m_CubeMapPass;
+	const SSAOPass* m_SSAOPass;
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;

include/Engine/Rendering/IRenderer.h

@@ -5,11 +5,13 @@
 #include "../OpenGL.h"
 #include "../GLM.h"
 #include "../Core/Util/Rectangle.h"
+#include "../Core/ConfigFile.h"
 #include "Util/ScreenCoords.h"
 #include "Camera.h"
 #include "RenderQueue.h"
 #include "Model.h"
 #include "../Core/World.h" //So temp
+#include "Util/CommonFunctions.h"
 
 
 struct PickData

include/Engine/Rendering/PickingPass.h

@@ -28,15 +28,13 @@ public:
     const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
     //const std::unordered_map<glm::ivec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }
     GLuint PickingTexture() const { return m_PickingTexture; }
-    GLuint DepthBuffer() const { return m_DepthBuffer; }
+    GLuint* DepthBuffer() { return &m_DepthBuffer; }
     const FrameBuffer& PickingBuffer() const { return m_PickingBuffer; }
 
     
     PickData Pick(glm::vec2 screenCoord);
 
 private:
-    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
     EventBroker* m_EventBroker;
 
     const IRenderer* m_Renderer;

include/Engine/Rendering/RenderState.h

@@ -24,6 +24,8 @@ public:
     bool StencilFunc(GLenum func, GLint ref, GLuint mask);
     bool StencilMask(GLuint mask);
     bool DepthMask(GLboolean flag);
+	bool DepthFunc(GLenum func);
+	bool AlphaFunc(GLenum func, GLclampf thresholder);
 
 private:
     std::vector<std::function<void(void)>> m_ResetFunctions;

include/Engine/Rendering/Renderer.h

@@ -32,8 +32,9 @@ class Renderer : public IRenderer
     static void glfwFrameBufferCallback(GLFWwindow* window, int width, int height);
 
 public:
-    Renderer(EventBroker* eventBroker) 
+	Renderer(EventBroker* eventBroker, ConfigFile* config)
-        : m_EventBroker(eventBroker)
+		: m_EventBroker(eventBroker)
+		, m_Config(config)
     { }
 
     virtual void Initialize() override;
@@ -47,6 +48,7 @@ private:
     //----------------------Variables----------------------//
 
     static std::unordered_map <GLFWwindow*, Renderer*> m_WindowToRenderer;
+	ConfigFile* m_Config;
 
     EventBroker* m_EventBroker;
     TextPass* m_TextPass;
@@ -61,12 +63,8 @@ private:
     int m_DebugTextureToDraw = 0;
     int m_CubeMapTexture = 0;
     bool m_ResizeWindow = false;
-	float m_SSAO_Radius = 1.0f;
+	int m_SSAO_Quality = 0;
-	float m_SSAO_Bias = 0.05f;
+	int m_GLOW_Quality = 2;
-	float m_SSAO_Contrast = 1.5f;
-	float m_SSAO_IntensityScale = 1.0f;
-	int m_SSAO_NumOfSamples = 24;
-	int m_SSAO_NumOfTurns = 7;
 
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;

include/Engine/Rendering/SSAOPass.h

@@ -13,18 +13,32 @@
 class SSAOPass
 {
 public:
-	SSAOPass(IRenderer* rendere);
+	SSAOPass(IRenderer* renderer, ConfigFile* config);
-	~SSAOPass() { 
+	~SSAOPass() { };
-		delete m_DrawBloomPass;
+
-	};
+	void ChangeQuality(int quality);
 
 	void Draw(GLuint depthBuffer, Camera* camera);
-	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns);
+	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int numOfTurns, int iterations, int quality);
 	void ClearBuffer();
 	void OnWindowResize();
 
 	//Return the SSAO of the texture sent to Draw
-	GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
+	GLuint SSAOTexture() const { 
+		if (m_Quality == 0) {
+			return m_WhiteTexture->m_Texture;
+		} else {
+			return m_Gaussian_vert;
+		}
+	}
+
+	int TextureQuality() const {
+		if (m_Quality == 0) {
+			return 13;
+		} else {
+			return m_TextureQuality;
+		}
+	}
 
 private:
 	void InitializeTexture();
@@ -32,14 +46,13 @@ private:
 	void InitializeShaderProgram();
 	void InitializeBuffer();
 
-	void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
 	//void blurHorizontal(GLuint depthBuffer);
 	//void blurVertical(GLuint depthBuffer);
 
 	Model* m_ScreenQuad;
 
 	const IRenderer* m_Renderer;
+	ConfigFile* m_Config;
 
 	float m_Radius;
 	float m_Bias;
@@ -47,17 +60,28 @@ private:
 	float m_IntensityScale;
 	int m_NumOfSamples;
 	int m_NumOfTurns;
+	int m_Iterations;
+	int m_TextureQuality;
+	int m_Quality = 0;
 
-	GLuint m_SSAOTexture;
+	Texture* m_WhiteTexture;
+
+	GLuint m_SSAOTexture = 0;
 	FrameBuffer m_SSAOFramBuffer;
 
-	GLuint m_SSAOViewSpaceZTexture;
+	GLuint m_SSAOViewSpaceZTexture = 0;
 	FrameBuffer m_SSAOViewSpaceZFramBuffer;
 
+	GLuint m_Gaussian_horiz = 0;
+	GLuint m_Gaussian_vert = 0;
+
+	FrameBuffer m_GaussianFrameBuffer_horiz;
+	FrameBuffer m_GaussianFrameBuffer_vert;
+
 	ShaderProgram* m_SSAOProgram;
 	ShaderProgram* m_SSAOViewSpaceZProgram;
-
+	ShaderProgram* m_GaussianProgram_horiz;
-	DrawBloomPass* m_DrawBloomPass;
+	ShaderProgram* m_GaussianProgram_vert;
 };
 
 #endif

include/Engine/Rendering/Util/CommonFunctions.h

@@ -9,6 +9,10 @@
 namespace CommonFunctions
 { 
 Texture* LoadTexture(std::string path, bool threaded);
+void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
+void GenerateMultiSampleTexture(GLuint* texture, int numSamples, glm::vec2 dimensions, GLint internalFormat);
+void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps);
+void DeleteTexture(GLuint* texture);
 };
 
 #endif

resources/DefaultConfig.ini

@@ -36,4 +36,37 @@ ResourceLoading=true
 [Sound]
 BGMVolume=1.0
 SFXVolume=1.0
-Announcer=female
+Announcer=female
+
+[SSAO]
+Quality=0
+
+[SSAO1]
+Radius=1.0
+Bias=0.02
+Contrast=1.5
+Intensity=1.0
+NumSamples=8
+NumTurns=3
+NumIterations=5
+TextureQuality=2
+
+[SSAO2]
+Radius=1.0
+Bias=0.02
+Contrast=1.5
+Intensity=1.0
+NumSamples=16
+NumTurns=13
+NumIterations=9
+TextureQuality=1
+
+[SSAO3]
+Radius=1.0
+Bias=0.02
+Contrast=1.5
+Intensity=1.0
+NumSamples=24
+NumTurns=17
+NumIterations=13
+TextureQuality=0

resources/Shaders/ForwardPlus.frag.glsl

@@ -13,6 +13,7 @@ uniform vec4 AmbientColor;
 uniform float FillPercentage;
 uniform float GlowIntensity = 10;
 uniform vec3 CameraPosition;
+uniform int SSAOQuality;
 
 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
@@ -125,7 +126,7 @@ vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textu
 
 void main()
 {
-	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy), 0).r;
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
 	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
 	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
 	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);

resources/Shaders/ForwardPlusSplatMapRGB.frag.glsl

@@ -11,6 +11,7 @@ uniform vec4 DiffuseColor;
 uniform vec4 FillColor;
 uniform vec4 Color;
 uniform vec4 AmbientColor;
+uniform int SSAOQuality;
 
 //Get bineded at the same time as the textures
 uniform vec2 DiffuseUVRepeat1;
@@ -177,7 +178,7 @@ vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
 
 void main()
 {
-	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy), 0).r;
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
 	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
 
 	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);

resources/Shaders/SSAO.frag.glsl

@@ -2,11 +2,11 @@
 
 //Number of samples per pixel
 uniform int           uNumOfSamples;
-//#define NUM_SAMPLES (11)
+//#define uNumOfSamples (11)
 
 //Number of turns around the cirle
 uniform int           uNumOfTurns;
-//#define NUM_TURNS (7)
+//#define uNumOfTurns (7)
 
 layout (binding = 0) uniform sampler2D ViewSpaceZ;
 
@@ -16,15 +16,16 @@ uniform float           uProjScale;
 //#define ProjScale 500
 
 uniform float           uRadius;
-//#define Radius 1.0f
+//#define uRadius 1.0f
 
 uniform float           uBias;
-//#define Bias 0.012f
+//#define uBias 0.05f
 
 uniform float           uContrast;
-//#define IntensityDivR6 1
+//#define uContrast 1.5f
 
 uniform float           uIntensityScale;
+//#define uIntensityScale 1.0f
 
 out float				AO;
 
@@ -88,13 +89,7 @@ void main() {
 
 	vec3 origin = getVSPosition(originScreenCoord);
 
-	float radius;
+	float radius = min(origin.z, uRadius);
-	if(origin.z < uRadius){
-		radius = origin.z;
-	} else {
-		radius = uRadius;
-	}
-
 
 	vec3 originNormal = getVSFaceNormal(origin);
 

resources/Shaders/SSAO.vert.glsl

@@ -2,7 +2,12 @@
 
 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;
 }

resources/Shaders/SSAOViewSpaceZ.frag.glsl

@@ -3,11 +3,15 @@
 layout (binding = 0) uniform sampler2D DepthBuffer;
 uniform vec3 ClipInfo;
 
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
 out float depthLinear;
 //Just for Debug, should be depthLinear
 //out vec4 fragmentColor;
 void main() {
-	float depthSample = texelFetch(DepthBuffer, ivec2(gl_FragCoord.xy), 0).r;
+	float depthSample = texture2D(DepthBuffer, Input.TextureCoordinate).r;
 	depthLinear = ClipInfo[0] / (ClipInfo[1] * depthSample + ClipInfo[2]);
 	//float depthLinear = (NearClip) / ( -depthSample + 1.0f);
 	//fragmentColor = vec4(depthLinear, depthLinear, depthLinear, 1.0f);

src/Engine/Rendering/DrawBloomPass.cpp

@@ -1,19 +1,41 @@
 #include "Rendering/DrawBloomPass.h"
 
-DrawBloomPass::DrawBloomPass(IRenderer* renderer)
+DrawBloomPass::DrawBloomPass(IRenderer* renderer, ConfigFile* config)
+	: m_Renderer(renderer)
+	, m_Config(config)
 {
-    m_Renderer = renderer;
+	InitializeTextures();
 
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+	ChangeQuality(m_Config->Get<int>("GLOW.Quality", 2));
-
-    InitializeTextures();
-    InitializeBuffers();
-    InitializeShaderPrograms();
 }
 
 void DrawBloomPass::InitializeTextures()
 {
-    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
+}
+
+void DrawBloomPass::ChangeQuality(int quality)
+{
+	if (m_Quality == quality) {
+		return;
+	}
+	m_Quality = quality;
+
+	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+
+	if (m_Quality == 0) {
+		CommonFunctions::DeleteTexture(&m_GaussianTexture_horiz);
+		CommonFunctions::DeleteTexture(&m_GaussianTexture_vert);
+		m_GaussianTexture_horiz = 0;
+		m_GaussianTexture_vert = 0;
+		return;
+	}
+	InitializeTextures();
+
+	InitializeBuffers();
+	InitializeShaderPrograms();
+	std::string qStr = std::to_string(m_Quality);
+	m_Iterations = m_Config->Get<float>("GLOW" + qStr + ".NumIterations", 0);
 }
 
 void DrawBloomPass::InitializeShaderPrograms()
@@ -35,37 +57,45 @@ void DrawBloomPass::InitializeShaderPrograms()
 	}
 }
 
-
 void DrawBloomPass::InitializeBuffers()
 {
-    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);
+    CommonFunctions::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.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
+	if (m_GaussianFrameBuffer_horiz.GetHandle() == 0) {
-    m_GaussianFrameBuffer_horiz.Generate();
+		m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(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->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    CommonFunctions::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);
-
+	if (m_GaussianFrameBuffer_vert.GetHandle() == 0) {
-    m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
+		m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
-    m_GaussianFrameBuffer_vert.Generate();
+	}
+	m_GaussianFrameBuffer_vert.Generate();
 }
 
 
 void DrawBloomPass::ClearBuffer()
 {
+	if (m_Quality == 0) {
+		return;
+	}
     GLERROR("PRE");
     m_GaussianFrameBuffer_horiz.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glClear(GL_COLOR_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);
+    glClear(GL_COLOR_BUFFER_BIT);
     m_GaussianFrameBuffer_vert.Unbind();
     GLERROR("END");
 }
 
 void DrawBloomPass::Draw(GLuint texture)
 {
+	if (m_Quality == 0) {
+		return;
+	}
     GLERROR("DrawBloomPass::Draw: Pre");
 
     DrawBloomPassState state;
@@ -84,11 +114,12 @@ void DrawBloomPass::Draw(GLuint texture)
     glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
         , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
     //Iterate some times to make it more gaussian.
-    for (int i = 1; i < m_iterations; i++) {
+    for (int i = 1; i < m_Iterations; i++) {
         //Vertical pass
         m_GaussianFrameBuffer_vert.Bind();
         m_GaussianProgram_vert->Bind();
 
+		glActiveTexture(GL_TEXTURE0);
         glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
 
         glBindVertexArray(m_ScreenQuad->VAO);
@@ -96,16 +127,19 @@ void DrawBloomPass::Draw(GLuint texture)
         glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
             , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
         //horizontal pass
+		m_GaussianFrameBuffer_vert.Unbind();
 
         m_GaussianFrameBuffer_horiz.Bind();
         m_GaussianProgram_horiz->Bind();
 
+		glActiveTexture(GL_TEXTURE0);
         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].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
             , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
+		m_GaussianFrameBuffer_horiz.Unbind();
     }
 
     //final vertical gaussian after the iterations are done
@@ -113,6 +147,7 @@ void DrawBloomPass::Draw(GLuint texture)
     m_GaussianFrameBuffer_vert.Bind();
     m_GaussianProgram_vert->Bind();
 
+	glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
@@ -125,20 +160,11 @@ void DrawBloomPass::Draw(GLuint texture)
 
 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);
+	if (m_Quality == 0) {
+		return;
+	}
+    CommonFunctions::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);
+    CommonFunctions::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);
-    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");
-}

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1,9 +1,10 @@
 #include "Rendering/DrawFinalPass.h"
-
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, GLuint* depthBuffer)
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass)
+	: m_Renderer(renderer)
-    : m_Renderer(renderer)
+	, m_LightCullingPass(lightCullingPass)
-    , m_LightCullingPass(lightCullingPass)
+	, m_CubeMapPass(cubeMapPass)
-    , m_CubeMapPass(cubeMapPass)
+	, m_SSAOPass(ssaoPass)
+	, m_DepthBuffer(depthBuffer)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
     m_ShieldPixelRate = 8;
@@ -23,19 +24,13 @@ void DrawFinalPass::InitializeTextures()
 
 void DrawFinalPass::InitializeFrameBuffers()
 {
-    glGenRenderbuffers(1, &m_DepthBuffer);
+	CommonFunctions::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);
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-    GLERROR("RenderBuffer generation");
-
-
-    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);
-    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);
+	CommonFunctions::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);
     //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
     //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
 
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
     //m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_StencilTexture, GL_STENCIL_ATTACHMENT)));
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
@@ -47,9 +42,9 @@ void DrawFinalPass::InitializeFrameBuffers()
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
     GLERROR("RenderBufferLowRes generation");
 
-    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);
+	CommonFunctions::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_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), 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);
+	CommonFunctions::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);
     //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
     //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
 
@@ -162,27 +157,26 @@ void DrawFinalPass::InitializeShaderPrograms()
 
     m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
-    m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    //m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferProgram->Compile();
     m_FillDepthBufferProgram->Link();
     GLERROR("Creating DepthFill program");
 
     m_FillDepthBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
     m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
-    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    //m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferSkinnedProgram->Compile();
     m_FillDepthBufferSkinnedProgram->Link();
     GLERROR("Creating DepthFill program");
 }
 
-void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
+void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("Pre");
     DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
     if (scene.ClearDepth) {
         //glClear(GL_DEPTH_BUFFER_BIT);
 		state->Disable(GL_DEPTH_TEST);
-		state->DepthMask(GL_FALSE);
     }
     //TODO: Do we need check for this or will it be per scene always?
     glClearStencil(0x00);
@@ -191,12 +185,13 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
     //Fill depth buffer
 	
     state->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
     GLERROR("OpaqueObjects");
     //state->BlendFunc(GL_ONE, GL_ONE);
     state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
+    //state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
     GLERROR("TransparentObjects");
     //state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     DrawSprites(scene.Jobs.SpriteJob, scene);
@@ -212,11 +207,11 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
     //Draw Opaque shielded objects
     state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
     state->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene, SSAOTexture); //might need changing
+    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
     GLERROR("Shielded Opaque object");
 
     //Draw Transparen Shielded objects
-    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene, SSAOTexture); //might need changing
+    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
     GLERROR("Shielded Transparent objects");
 
     GLERROR("END");
@@ -252,9 +247,9 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
     stateLowRes->Enable(GL_DEPTH_TEST);
     stateLowRes->StencilFunc(GL_LEQUAL, 1, 0xFF);
     stateLowRes->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
     GLERROR("OpaqueObjects");
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
+    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
     GLERROR("TransparentObjects");
     glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
@@ -275,7 +270,7 @@ void DrawFinalPass::ClearBuffer()
     glClearColor(0.f, 0.f, 0.f, 0.f);
     GLERROR("1");
 
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     GLERROR("2");
 
     glDisable(GL_SCISSOR_TEST);
@@ -290,7 +285,7 @@ void DrawFinalPass::ClearBuffer()
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     GLERROR("ViewPort,Scissor LowRes");
     glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glClear(GL_COLOR_BUFFER_BIT);
     m_FinalPassFrameBuffer.Unbind();
     GLERROR("END");
 }
@@ -299,50 +294,22 @@ void DrawFinalPass::ClearBuffer()
 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);
+    CommonFunctions::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);
+	CommonFunctions::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);
+	CommonFunctions::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);
+	CommonFunctions::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
+void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
-{
-    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");
-}
-
-void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene, GLuint SSAOTexture)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
     GLERROR("forwardHandle");
@@ -366,7 +333,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
 	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, SSAOTexture);
+	glBindTexture(GL_TEXTURE_2D, m_SSAOPass->SSAOTexture());
 
     for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
@@ -385,7 +352,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
                     glActiveTexture(GL_TEXTURE5);
                     glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                    glUniform3fv(glGetUniformLocation(explosionSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                     std::vector<glm::mat4> frameBones;
                     if (explosionEffectJob->AnimationOffset.animation != nullptr) {
@@ -403,7 +370,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionTextures(explosionHandle, explosionEffectJob);
                     glActiveTexture(GL_TEXTURE5);
                     glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                    glUniform3fv(glGetUniformLocation(explosionHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                 }
                 break;
@@ -465,7 +432,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelTextures(forwardSkinnedHandle, modelJob);
                             glActiveTexture(GL_TEXTURE5);
                             glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                            glUniform3fv(glGetUniformLocation(forwardSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                             std::vector<glm::mat4> frameBones;
                             if (modelJob->AnimationOffset.animation != nullptr) {
@@ -755,6 +722,7 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
 
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
+	glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 	GLERROR("Bind 1 uniform");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
 	GLERROR("Bind 2 uniform");
@@ -803,6 +771,7 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 
 void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene)
 {
+	glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 	GLERROR("Bind 1 uniform");
 	GLint Location_M = glGetUniformLocation(shaderHandle, "M");
 	glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -8,6 +8,8 @@ DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
+	DepthMask(GL_FALSE);
+	DepthFunc(GL_LEQUAL);
     Enable(GL_CULL_FACE);
     Enable(GL_STENCIL_TEST);
     StencilFunc(GL_NOTEQUAL, 1, 0xFF);

src/Engine/Rendering/FrameBuffer.cpp

@@ -42,33 +42,33 @@ void FrameBuffer::Generate()
     GLERROR("PRE");
 
     std::vector<GLenum> attachments;
-
+	if (m_BufferHandle == 0) {
-    glGenFramebuffers(1, &m_BufferHandle);
+		glGenFramebuffers(1, &m_BufferHandle);
+	}
     glBindFramebuffer(GL_FRAMEBUFFER, m_BufferHandle);
     GLERROR("1");
 
-    for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
+	for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
-        switch ((*it)->m_ResourceType) {
+		switch ((*it)->m_ResourceType) {
-        case GL_TEXTURE_2D:
+		case GL_TEXTURE_2D:
-            glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
-            GLERROR("FrameBuffer generate: glFramebufferTexture2D");
+			GLERROR("FrameBuffer generate: glFramebufferTexture2D");
 
-            break;
+			break;
-        case GL_RENDERBUFFER:
+		case GL_RENDERBUFFER:
-            glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
+			glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
-            GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
+			GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
-            break;
+			break;
-        }
+		}
-        GLERROR("2");
+		GLERROR("2");
 
-        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
+		if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
-            attachments.push_back((*it)->m_Attachment);
+			attachments.push_back((*it)->m_Attachment);
-        }
+		}
-        GLERROR("Attachment");
+		GLERROR("Attachment");
-
-    }
-    GLERROR("3");
 
+	}
+	GLERROR("3");
 
     GLenum* bufferTextures = &attachments[0];
     glDrawBuffers(attachments.size(), bufferTextures);

src/Engine/Rendering/PickingPass.cpp

@@ -19,10 +19,10 @@ PickingPass::~PickingPass()
 
 void PickingPass::InitializeTextures()
 {
-    GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
+    CommonFunctions::GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
         glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
 
-	GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
+	CommonFunctions::GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
 		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
 }
 
@@ -366,7 +366,7 @@ void PickingPass::ClearPicking()
 
     m_PickingBuffer.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     m_PickingBuffer.Unbind();
     GLERROR("END");
 }
@@ -407,16 +407,3 @@ PickData PickingPass::Pick(glm::vec2 screenCoord)
     pickData.World = pickInfo.World;
     return pickData;
 }
-
-void PickingPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
-{
-    //TODO: Renderer: Make this in a sparate class
-    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");
-}

src/Engine/Rendering/PickingPassState.cpp

@@ -9,11 +9,11 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
     Disable(GL_BLEND);
-
     glm::vec4 clearColor = glm::vec4(0.f);
     //ClearColor(clearColor);
     //Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     GLERROR("END");
+	
 }
 
 PickingPassState::~PickingPassState()

src/Engine/Rendering/RenderState.cpp

@@ -135,6 +135,26 @@ bool RenderState::DepthMask(GLboolean flag)
     return !GLERROR("DepthMask");
 }
 
+bool RenderState::DepthFunc(GLenum func)
+{
+	GLint original;
+	glGetIntegerv(GL_DEPTH_FUNC, &original);
+	m_ResetFunctions.push_back(std::bind(glDepthFunc, original));
+	glDepthFunc(func);
+	return !GLERROR("DepthFunc");
+}
+
+bool RenderState::AlphaFunc(GLenum func, GLclampf thresholder)
+{
+	GLint originalFunc;
+	glGetIntegerv(GL_ALPHA_TEST_FUNC, &originalFunc);
+	GLint originalRef;
+	glGetIntegerv(GL_ALPHA_TEST_REF, &originalRef);
+	m_ResetFunctions.push_back(std::bind(glAlphaFunc, originalFunc, originalRef));
+	glAlphaFunc(func, thresholder);
+	return !GLERROR("AlphaFunc");
+}
+
 RenderState::~RenderState()
 {
     for (auto& f : boost::adaptors::reverse(m_ResetFunctions)) {

src/Engine/Rendering/Renderer.cpp

@@ -4,6 +4,8 @@ std::unordered_map<GLFWwindow*, Renderer*> Renderer::m_WindowToRenderer;
 
 void Renderer::Initialize()
 {
+	m_SSAO_Quality = m_Config->Get<int>("SSAO.Quality", 0);
+	m_GLOW_Quality = m_Config->Get<int>("GLOW.Quality", 0);
 	InitializeWindow();
     
     InitializeRenderPasses();
@@ -26,9 +28,9 @@ 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_PickingPass->OnWindowResize();
     currentRenderer->m_DrawFinalPass->OnWindowResize();
     currentRenderer->m_LightCullingPass->OnWindowResize();
-    currentRenderer->m_PickingPass->OnWindowResize();
     currentRenderer->m_DrawBloomPass->OnWindowResize();
 	currentRenderer->m_SSAOPass->OnWindowResize();
 }
@@ -107,6 +109,7 @@ void Renderer::Update(double dt)
 void Renderer::Draw(RenderFrame& frame)
 {
     GLERROR("PRE");
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
     ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
     ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
     if(m_CubeMapTexture == 0) {
@@ -115,19 +118,16 @@ void Renderer::Draw(RenderFrame& frame)
         m_CubeMapPass->LoadTextures("Sky");
     }
 
-	ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.01f, 5.0f);
+	ImGui::SliderInt("SSAO Quality", &m_SSAO_Quality, 0, 3);
-	ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 0.1f);
+	ImGui::SliderInt("Glow Quality", &m_GLOW_Quality, 0, 3);
-	ImGui::SliderFloat("SSAO contrast", &m_SSAO_Contrast, 0.0f, 10.0f);
+	m_SSAOPass->ChangeQuality(m_SSAO_Quality);
-	ImGui::SliderFloat("SSAO IntensityScale", &m_SSAO_IntensityScale, 0.0f, 10.0f);
+	m_DrawBloomPass->ChangeQuality(m_GLOW_Quality);
-	ImGui::SliderInt("SSAO Number of Samples", &m_SSAO_NumOfSamples, 2, 100);
-	ImGui::SliderInt("SSAO Number of Turns", &m_SSAO_NumOfTurns, 0, 50);
-	m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Contrast, m_SSAO_IntensityScale, m_SSAO_NumOfSamples, m_SSAO_NumOfTurns);
     GLERROR("SSAO Settings");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    //Clear other buffers
+    //Clear other buffers 
     PerformanceTimer::StartTimer("Renderer-ClearBuffers");
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
@@ -136,18 +136,16 @@ void Renderer::Draw(RenderFrame& frame)
     PerformanceTimer::StopTimer("Renderer-ClearBuffers");
     GLERROR("ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
-		PerformanceTimer::StartTimer("Renderer-Depth");
+		PerformanceTimer::StartTimer("Renderer-PickingPass");
 		m_PickingPass->Draw(*scene);
 		GLERROR("Drawing pickingpass");
-		PerformanceTimer::StopTimer("Renderer-Depth");
+		PerformanceTimer::StopTimer("Renderer-PickingPass");
 	}
-	PerformanceTimer::StartTimer("AO generation");
+	PerformanceTimer::StartTimer("Renderer-AO generation");
-	m_SSAOPass->Draw(m_PickingPass->DepthBuffer(), frame.RenderScenes.front()->Camera);
+	m_SSAOPass->Draw(*m_PickingPass->DepthBuffer(), frame.RenderScenes.front()->Camera);
-	GLuint ao = m_SSAOPass->SSAOTexture();
+	PerformanceTimer::StopTimer("Renderer-AO generation");
-	PerformanceTimer::StopTimer("AO generation");
     for (auto scene : frame.RenderScenes){
-        
+        PerformanceTimer::StartTimer("Renderer-Depth");
-        PerformanceTimer::StartTimer("Renderer-Drawing PickingPass");
         SortRenderJobsByDepth(*scene);
         GLERROR("SortByDepth");
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Generate Frustrums");
@@ -159,8 +157,8 @@ void Renderer::Draw(RenderFrame& frame)
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Light Culling");
         m_LightCullingPass->CullLights(*scene);
         GLERROR("LightCulling");
-		m_DrawFinalPass->Draw(*scene, ao);
+		PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
-        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
+		m_DrawFinalPass->Draw(*scene);
         GLERROR("Draw Geometry+Light");
         //m_DrawScenePass->Draw(*scene);
 
@@ -207,8 +205,11 @@ void Renderer::Draw(RenderFrame& frame)
     PerformanceTimer::StartTimer("Renderer-ImGuiRenderPass");
     m_ImGuiRenderPass->Draw();
     GLERROR("Imgui draw");
+	PerformanceTimer::StopTimer("Renderer-ImGuiRenderPass");
+
+	PerformanceTimer::StartTimer("Renderer-SwapBuffer");
     glfwSwapBuffers(m_Window);
-    PerformanceTimer::StopTimer("Renderer-ImGuiRenderPass");
+	PerformanceTimer::StopTimer("Renderer-SwapBuffer");
 }
 
 PickData Renderer::Pick(glm::vec2 screenCoord)
@@ -248,9 +249,10 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_CubeMapPass = new CubeMapPass(this);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass);
+	m_SSAOPass = new SSAOPass(this, m_Config);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass, m_PickingPass->DepthBuffer());
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
-    m_DrawBloomPass = new DrawBloomPass(this);
+    m_DrawBloomPass = new DrawBloomPass(this, m_Config);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
-    m_SSAOPass = new SSAOPass(this);
+  
-}
+}

src/Engine/Rendering/SSAOPass.cpp

@@ -1,84 +1,168 @@
 #include "Rendering/SSAOPass.h"
 
-SSAOPass::SSAOPass(IRenderer* renderer)
+SSAOPass::SSAOPass(IRenderer* renderer, ConfigFile* config)
+	: m_Renderer(renderer)
+	, m_Config(config)
 {
-	m_Renderer = renderer;
+	m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+
+	ChangeQuality(m_Config->Get<int>("SSAO.Quality", 0));
+
+}
+
+void SSAOPass::ChangeQuality(int quality)
+{
+	if (m_Quality == quality) {
+		return;
+	}
+
+	m_Quality = quality;
+
+	if (m_Quality == 0) {	
+		CommonFunctions::DeleteTexture(&m_SSAOTexture);
+		CommonFunctions::DeleteTexture(&m_SSAOViewSpaceZTexture);
+		CommonFunctions::DeleteTexture(&m_Gaussian_horiz);
+		CommonFunctions::DeleteTexture(&m_Gaussian_vert);
+		return;
+	}
+
+	std::string qStr = std::to_string(m_Quality);
+	Setting(
+		m_Config->Get<float>("SSAO" + qStr + ".Radius", 0.01),
+		m_Config->Get<float>("SSAO" + qStr + ".Bias", 0.012),
+		m_Config->Get<float>("SSAO" + qStr + ".Contrast", 1.0),
+		m_Config->Get<float>("SSAO" + qStr + ".Intensity", 1.0),
+		m_Config->Get<int>("SSAO" + qStr + ".NumSamples", 0),
+		m_Config->Get<int>("SSAO" + qStr + ".NumTurns", 0),
+		m_Config->Get<int>("SSAO" + qStr + ".NumIterations", 0),
+		m_Config->Get<int>("SSAO" + qStr + ".TextureQuality", 4)
+		);
+
+
 
 	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
 	InitializeTexture();
 	InitializeBuffer();
 	InitializeShaderProgram();
-	Setting(0.1f, 0.012f, 1.0f, 1.0f, 13, 7);
 
-	m_DrawBloomPass = new DrawBloomPass(renderer);
+
 }
 
 void SSAOPass::InitializeShaderProgram()
 {
 	m_SSAOProgram = ResourceManager::Load<ShaderProgram>("##SSAOProgram");
-	m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
+	if (m_SSAOProgram->GetHandle() == 0) {
-	m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAO.frag.glsl")));
+		m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
-	m_SSAOProgram->Compile();
+		m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAO.frag.glsl")));
-	m_SSAOProgram->Link();
+		m_SSAOProgram->Compile();
+		m_SSAOProgram->Link();
+	}
 
 	m_SSAOViewSpaceZProgram = ResourceManager::Load<ShaderProgram>("##SSAOViewSpaceZProgram");
-	m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
+	if (m_SSAOViewSpaceZProgram->GetHandle() == 0) {
-	m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAOViewSpaceZ.frag.glsl")));
+		m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
-	m_SSAOViewSpaceZProgram->Compile();
+		m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAOViewSpaceZ.frag.glsl")));
-	m_SSAOViewSpaceZProgram->Link();
+		m_SSAOViewSpaceZProgram->Compile();
+		m_SSAOViewSpaceZProgram->Link();
+	}
+
+	m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
+	if (m_GaussianProgram_horiz->GetHandle() == 0) {
+		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
+		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
+		m_GaussianProgram_horiz->Compile();
+		m_GaussianProgram_horiz->Link();
+	}
+
+	m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
+	if (m_GaussianProgram_vert->GetHandle() == 0) {
+		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
+		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
+		m_GaussianProgram_vert->Compile();
+		m_GaussianProgram_vert->Link();
+	}
 }
 
 void SSAOPass::InitializeTexture() {
-	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
+	CommonFunctions::GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RED, GL_FLOAT);
-	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
+	CommonFunctions::GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R32F, GL_RED, GL_FLOAT);
+
+	CommonFunctions::GenerateTexture(&m_Gaussian_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RED, GL_FLOAT);
+	CommonFunctions::GenerateTexture(&m_Gaussian_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RED, GL_FLOAT);
 }
 
 void SSAOPass::InitializeBuffer()
 {
-	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
+	if (m_SSAOFramBuffer.GetHandle() == 0) {
+		m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
+	}
 	m_SSAOFramBuffer.Generate();
 
-	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
+
+	if (m_SSAOViewSpaceZFramBuffer.GetHandle() == 0) {
+		m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
+	}
 	m_SSAOViewSpaceZFramBuffer.Generate();
+
+
+
+	if (m_GaussianFrameBuffer_horiz.GetHandle() == 0) {
+		m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_Gaussian_horiz, GL_COLOR_ATTACHMENT0)));
+	}
+	m_GaussianFrameBuffer_horiz.Generate();
+
+
+	if (m_GaussianFrameBuffer_vert.GetHandle() == 0) {
+		m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_Gaussian_vert, GL_COLOR_ATTACHMENT0)));
+	}
+	m_GaussianFrameBuffer_vert.Generate();
+
 }
 
 void SSAOPass::ClearBuffer()
 {
+	if (m_Quality == 0) {
+		return;
+	}
 	m_SSAOFramBuffer.Bind();
 	glClearColor(1.f, 1.f, 1.f, 1.f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClear(GL_COLOR_BUFFER_BIT);
 	m_SSAOFramBuffer.Unbind();
 
 	m_SSAOViewSpaceZFramBuffer.Bind();
 	glClearColor(1.f, 1.f, 1.f, 1.f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClear(GL_COLOR_BUFFER_BIT);
 	m_SSAOViewSpaceZFramBuffer.Unbind();
+
+	m_GaussianFrameBuffer_horiz.Bind();
+	glClearColor(1.f, 1.f, 1.f, 1.f);
+	glClear(GL_COLOR_BUFFER_BIT);
+	m_GaussianFrameBuffer_horiz.Unbind();
+
+	m_GaussianFrameBuffer_vert.Bind();
+	glClearColor(1.f, 1.f, 1.f, 1.f);
+	glClear(GL_COLOR_BUFFER_BIT);
+	m_GaussianFrameBuffer_vert.Unbind();
 }
 
-void SSAOPass::Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns) {
+void SSAOPass::Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int numOfTurns, int iterations, int quality) {
 	m_Radius = radius;
 	m_Bias = bias;
 	m_Contrast = contrast;
 	m_IntensityScale = intensityScale;
 	m_NumOfSamples = numOfSamples;
-	m_NumOfTurns = NumOfTurns;
+	m_NumOfTurns = numOfTurns;
-}
+	m_Iterations = iterations;
-
+	m_TextureQuality = quality;
-void SSAOPass::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);
-	GLERROR("Texture initialization failed");
 }
 
 void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 {
+	if (m_Quality == 0) {
+		return;
+	}
+
 	SSAOPassState state;
 	GLuint viewSpaceZPShaderHandle = m_SSAOViewSpaceZProgram->GetHandle();
 	GLuint SSAOShaderHandle = m_SSAOProgram->GetHandle();
@@ -98,6 +182,7 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 		(-1.0f),
 		(+1.0f)
 		);*/
+	glViewport(0, 0, (m_Renderer->GetViewportSize().Width >> m_TextureQuality), (m_Renderer->GetViewportSize().Height >> m_TextureQuality)); //JOHAN TODO: Get this into state
 	glUniform3fv(glGetUniformLocation(viewSpaceZPShaderHandle, "ClipInfo"), 1, glm::value_ptr(clipInfo));
 
 	glBindVertexArray(m_ScreenQuad->VAO);
@@ -107,9 +192,9 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	
 	glm::vec4 projInfo = glm::vec4(
 		((1.0 - camera->ProjectionMatrix()[0][2]) / camera->ProjectionMatrix()[0][0]),
-		(-2.0 / (m_Renderer->GetViewportSize().Width * camera->ProjectionMatrix()[0][0])),
+		(-2.0 / ((m_Renderer->GetViewportSize().Width >> m_TextureQuality) * camera->ProjectionMatrix()[0][0])),
 		((1.0 + camera->ProjectionMatrix()[1][2]) / camera->ProjectionMatrix()[1][1]),
-		(-2.0 / (m_Renderer->GetViewportSize().Height * camera->ProjectionMatrix()[1][1]))
+		(-2.0 / ((m_Renderer->GetViewportSize().Height >> m_TextureQuality) * camera->ProjectionMatrix()[1][1]))
 		);
 
 
@@ -120,26 +205,84 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	glBindTexture(GL_TEXTURE_2D, m_SSAOViewSpaceZTexture);
 
 	// How many pixel there are in a 1m long object 1m away from the camera
-	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uProjScale"), m_Renderer->GetViewportSize().Height / (-2.0f * glm::tan(camera->FOV() * 0.5f)));
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uProjScale"), (m_Renderer->GetViewportSize().Height >> m_TextureQuality) / (-2.0f * glm::tan(camera->FOV() * 0.5f)));
 
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uRadius"), m_Radius);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uBias"), m_Bias);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uContrast"), m_Contrast);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uIntensityScale"), m_IntensityScale);
 	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfSamples"), m_NumOfSamples);
-	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfTurns"), m_NumOfTurns);;
+	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfTurns"), m_NumOfTurns);
 
 	glUniform4fv(glGetUniformLocation(SSAOShaderHandle, "uProjInfo"), 1, glm::value_ptr(projInfo));
 	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
 		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 
-	m_DrawBloomPass->ClearBuffer();
+	DrawBloomPassState BloomState;
-	m_DrawBloomPass->Draw(m_SSAOTexture);
+	GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
+	GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
+
+	m_GaussianFrameBuffer_horiz.Bind();
+	m_GaussianProgram_horiz->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, m_SSAOTexture);
+
+	glBindVertexArray(m_ScreenQuad->VAO);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
+		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->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();
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, m_Gaussian_horiz);
+
+		glBindVertexArray(m_ScreenQuad->VAO);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+		glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
+			, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
+		//horizontal pass
+		m_GaussianFrameBuffer_vert.Unbind();
+
+		m_GaussianFrameBuffer_horiz.Bind();
+		m_GaussianProgram_horiz->Bind();
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, m_Gaussian_vert);
+
+		glBindVertexArray(m_ScreenQuad->VAO);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+		glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
+			, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
+		m_GaussianFrameBuffer_horiz.Unbind();
+	}
+
+	//final vertical gaussian after the iterations are done
+
+	m_GaussianFrameBuffer_vert.Bind();
+	m_GaussianProgram_vert->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, m_Gaussian_horiz);
+	glBindVertexArray(m_ScreenQuad->VAO);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
+		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
+
+	m_GaussianFrameBuffer_vert.Unbind();
+
+	glViewport(0, 0, (m_Renderer->GetViewportSize().Width), (m_Renderer->GetViewportSize().Height));
 }
 
 void SSAOPass::OnWindowResize() {
-	m_DrawBloomPass->OnWindowResize();
+	if (m_Quality == 0) {
+		return;
+	}
+
 	InitializeTexture();
-	m_SSAOFramBuffer.Generate();
+	InitializeBuffer();
-	m_SSAOViewSpaceZFramBuffer.Generate();
 }

src/Engine/Rendering/Util/CommonFunctions.cpp

@@ -17,3 +17,46 @@ Texture* CommonFunctions::LoadTexture(std::string path, bool threaded)
 
     return img;
 }
+
+void CommonFunctions::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)
+{
+	glDeleteTextures(1, texture);
+	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);
+	GLERROR("Texture initialization failed");
+}
+
+void CommonFunctions::GenerateMultiSampleTexture(GLuint* texture, int numSamples, glm::vec2 dimensions, GLint internalFormat)
+{
+	glDeleteTextures(1, texture);
+	glGenTextures(1, texture);
+	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, *texture);
+	glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, numSamples, internalFormat, dimensions.x, dimensions.y, false);
+	GLERROR("Texture initialization failed");
+}
+
+
+void CommonFunctions::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps)
+{
+	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");
+}
+
+void CommonFunctions::DeleteTexture(GLuint* texture) 
+{
+	glDeleteTextures(1, texture);
+	*texture = 0;
+}

src/Engine/Rendering/Util/ScreenCoords.cpp

@@ -31,22 +31,27 @@ glm::vec3 ScreenCoords::ToWorldPos(glm::vec2 screenCoord, float depth, float scr
 
 ScreenCoords::PixelData ScreenCoords::ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
 {
+	GLERROR("Pre");
     PickDataBuffer->Bind();
     unsigned char pdata[3];
     glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pdata);
+	GLERROR("glReadPixels(pdata) Error");
     PickDataBuffer->Unbind();
 
-    glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer);
+    glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer); 
+	GLERROR("glBindFramebuffer(DepthBuffer) Error");
     float depthData;
     glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depthData);
+	GLERROR("glReadPixels(depthData) Error");
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	GLERROR("glBindFramebuffer(0) Error");
 
     PixelData p;
     p.Color[0] = (int)pdata[0];
     p.Color[1] = (int)pdata[1];
     p.Depth = depthData;
 
-    GLERROR("ScreenCoords::ToPixelData Error");
+    GLERROR("End");
 
     return p;
 }

src/Game/Game.cpp

@@ -53,7 +53,7 @@ Game::Game(int argc, char* argv[])
     m_EventBroker = new EventBroker();
 
     // Create the renderer
-    m_Renderer = new Renderer(m_EventBroker);
+    m_Renderer = new Renderer(m_EventBroker, m_Config);
     m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
     m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
     m_Renderer->SetResolution(Rectangle::Rectangle(

src/Game/main.cpp

@@ -9,7 +9,9 @@ int main(int argc, char* argv[])
 
     Game game(argc, argv);
     while (game.Running()) {
+		PerformanceTimer::StartTimer("Game-Tick");
         game.Tick();
+		PerformanceTimer::StopTimer("Game-Tick");
     }
 
 	return 0;