SSAO is working, but is kinda crappy. You can change shade variables in the debug window.

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -17,7 +17,7 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLfloat gamma, GLfloat exposure);
+    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLuint SSAOTexture, GLfloat gamma, GLfloat exposure);
 private:
     const IRenderer* m_Renderer;
 

include/Engine/Rendering/DrawFinalPass.h

@@ -21,6 +21,9 @@ public:
     void Draw(RenderScene& scene);
     void ClearBuffer();
 
+	//Return the texture that is used in later stages to apply the bloom effect
+	GLuint DepthBuffer() const { return m_DepthBuffer; }
+	Camera* DepthBufferCamera() const { return RenderCamera; }
     //Return the texture that is used in later stages to apply the bloom effect
     GLuint BloomTexture() const { return m_BloomTexture; }
     GLuint BloomTextureLowRes() const { return m_BloomTextureLowRes; }
@@ -62,6 +65,7 @@ private:
     GLuint m_SceneTextureLowRes;
     GLuint m_DepthBuffer;
     GLuint m_DepthBufferLowRes;
+	Camera* RenderCamera;
 
     //maqke this component based i guess?
     GLuint m_ShieldPixelRate = 16;

include/Engine/Rendering/Renderer.h

@@ -16,6 +16,7 @@
 #include "DrawScreenQuadPass.h"
 #include "DrawBloomPass.h"
 #include "DrawColorCorrectionPass.h"
+#include "SSAOPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
@@ -50,6 +51,9 @@ private:
     Model* m_UnitSphere;
 
     int m_DebugTextureToDraw = 0;
+	float m_SSAO_Radius = 0.2f;
+	float m_SSAO_Bias = 0.012f;
+	float m_SSAO_Intensity = 1.0f;
 
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
@@ -58,6 +62,7 @@ private:
     DrawScreenQuadPass* m_DrawScreenQuadPass;
     DrawBloomPass* m_DrawBloomPass;
     DrawColorCorrectionPass* m_DrawColorCorrectionPass;
+	SSAOPass* m_SSAOPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();

include/Engine/Rendering/SSAOPass.h

@@ -0,0 +1,58 @@
+#ifndef SSAOPass_h__
+#define SSAOPass_h__
+
+#include "IRenderer.h"
+#include "SSAOPassState.h"
+//#include "LightCullingPass.h" Finalpass om den skall skickas in
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "DrawBloomPass.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class SSAOPass
+{
+public:
+	SSAOPass(IRenderer* rendere);
+	~SSAOPass() { };
+
+	void Draw(GLuint depthBuffer, Camera* camera);
+	void Setting(float radius, float bias, float intensity);
+	void ClearBuffer();
+
+	//Return the SSAO of the texture sent to Draw
+	GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
+
+private:
+	void InitializeTexture();
+	void InitializeFrameBuffer();
+	void InitializeShaderProgram();
+	void InitializeBuffer();
+
+	void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+	void ComputeAO(GLuint depthBuffer, Camera* camera);
+	//void blurHorizontal(GLuint depthBuffer);
+	//void blurVertical(GLuint depthBuffer);
+
+	Model* m_ScreenQuad;
+
+	const IRenderer* m_Renderer;
+
+	float m_Radius;
+	float m_Bias;
+	float m_Intensity;
+
+	GLuint m_SSAOTexture;
+	FrameBuffer m_SSAOFramBuffer;
+
+	GLuint m_SSAOViewSpaceZTexture;
+	FrameBuffer m_SSAOViewSpaceZFramBuffer;
+
+	ShaderProgram* m_SSAOProgram;
+	ShaderProgram* m_SSAOViewSpaceZProgram;
+
+	DrawBloomPass* m_DrawBloomPass;
+};
+
+#endif

include/Engine/Rendering/SSAOPassState.h

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

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -4,6 +4,7 @@ layout (binding = 0) uniform sampler2D SceneTexture;
 layout (binding = 1) uniform sampler2D BloomTexture;
 layout (binding = 2) uniform sampler2D SceneTextureLowRes;
 layout (binding = 3) uniform sampler2D BloomTextureLowRes;
+layout (binding = 4) uniform sampler2D SSAOTexture;
 uniform float Exposure;
 uniform float Gamma;
 
@@ -19,6 +20,10 @@ void main()
 	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
 	vec4 hdrColorLowRes = texture(SceneTextureLowRes, Input.TextureCoordinate);
 	vec4 bloomColorLowRes = texture(BloomTextureLowRes, Input.TextureCoordinate);
+	vec4 SSAO = texture(SSAOTexture, Input.TextureCoordinate);
+
+	//hdrColor = hdrColor * SSAO;
+	SSAO = clamp(SSAO, 0.1f, 1.0f);
 	hdrColor += bloomColor;
 	hdrColorLowRes;
 
@@ -33,7 +38,7 @@ void main()
 
 	//gamme correction
 	result = pow(result, vec3(1.0 / Gamma));
-
+	result = result * SSAO.rgb;
 	fragmentColor = vec4(result, 1.0);
 	//fragmentColor = hdrColor;
 	//fragmentColor = bloomColor;

resources/Shaders/SSAO.frag.glsl

@@ -0,0 +1,106 @@
+#version 430
+
+//Number of samples per pixel
+#define NUM_SAMPLES (24)
+
+//Number of turns around the cirle
+#define NUM_TURNS (7)
+
+uniform sampler2D ViewSpaceZ;
+
+uniform vec4 ProjInfo;
+
+uniform float           ProjScale;
+//#define ProjScale 500
+
+uniform float           Radius;
+//#define Radius 1.0f
+
+uniform float           Bias;
+//#define Bias 0.012f
+
+uniform float           IntensityDivR6;
+//#define IntensityDivR6 1
+
+out vec4				fragmentColor;
+
+vec3 reconstructVSPosition(vec2 ScreenSpaceCoord, float z){
+	return vec3((ScreenSpaceCoord * ProjInfo.xy + ProjInfo.zw) * z, z);
+}
+
+vec3 getPosition(ivec2 ScreenSpaceCoord) {
+	vec3 P;
+    P.z = texelFetch(ViewSpaceZ, ScreenSpaceCoord, 0).r;
+    //Get the xy view space coordinates and add the z value from ViewSpaceZ buffer.
+    return reconstructVSPosition(vec2(ScreenSpaceCoord) + vec2(0.5), P.z);
+}
+
+vec3 getVSFaceNormal(vec3 ViewSpacePosition) {
+	// Get tangets vector for the plane and ViewSpacePositin... don't ask how this functions works. It's pure magic. 
+	// They do this and it just works... I would guess that they approximate the function of a plane from pixels close to the pixel were on now.
+	return normalize(cross(dFdx(ViewSpacePosition), dFdy(ViewSpacePosition)));
+}
+
+
+vec3 getSampleViewSpacePos(ivec2 ScreenSpaceCoord, int SampleIndex, float RotationAngle, float ScreenSpaceSampleRadius){
+	// Pure Magic...
+	float alpha = float(SampleIndex + 0.5) * (1.0 / NUM_SAMPLES);
+
+	// Angle to where to sample
+    float angle = alpha * (NUM_TURNS * 6.28) + RotationAngle;
+
+	//Lenght to were to sample
+    ScreenSpaceSampleRadius = ScreenSpaceSampleRadius * alpha;
+
+    vec2 screenSpaceSampleOffsetVecor = vec2(cos(angle), sin(angle));
+
+    // Get texel coordinate on where to sample by going screenSpaceSampleOffsetVecor direction in ScreenSpaceSampleRadius units from ScreenSpaceCoord (the point being shaded);
+    ivec2 screenSpaceSampleTexel = ivec2(ScreenSpaceSampleRadius * screenSpaceSampleOffsetVecor) + ScreenSpaceCoord;
+
+    return getPosition(screenSpaceSampleTexel);
+}
+
+float Radius2 = Radius * Radius;
+
+float sampleAO(ivec2 ScreenSpaceCoord, vec3 ShadedViewSpacePosition, vec3 ViewSpaceNormal, float ScreenSpaceSampleRadius, int SampleIndex, float RotationAngle) {
+	vec3 sampleViewSpacePosition = getSampleViewSpacePos(ScreenSpaceCoord, SampleIndex, RotationAngle, ScreenSpaceSampleRadius);
+
+	vec3 sampleVector = ShadedViewSpacePosition - sampleViewSpacePosition;
+
+	// vv = sampleVectorLenght ^ 2
+	float vv = dot(sampleVector, sampleVector);
+	// vn = angle between sampleVector and Normal
+	float vn = dot(sampleVector, ViewSpaceNormal);
+
+	const float epsilon = 0.01f;
+
+	// vv < radius2 if the vector is shorter then the radius;
+	// vn - bias, offset the angle to reduse self occlusion. 
+	// epsilon is here to make divison by 0 impossible.
+	return float(vv < Radius2) * max((vn - Bias) / (epsilon + vv), 0.0);
+	//float f = max(Radius2 - vv, 0.0); 
+	//return f * f * f * max((vn - Bias) / (epsilon + vv), 0.0);
+}
+
+
+void main() {
+	ivec2 originScreenCoord = ivec2(gl_FragCoord.xy);
+
+	vec3 origin = getPosition(originScreenCoord);
+
+	vec3 viewSpaceNormal = getVSFaceNormal(origin);
+
+	float screenSpaceSampleRadius = ProjScale * Radius / origin.z;
+
+	//Offset on what angle to start on so that not evry pixel start sampling in the same direction, AlchemyAO
+	float rotationAngleOffset = (3 * originScreenCoord.x ^ originScreenCoord.y + originScreenCoord.x * originScreenCoord.y) * 10;
+
+	float sum = 0.0;
+    for (int i = 0; i < NUM_SAMPLES; i++) {
+        sum += sampleAO(originScreenCoord, origin, viewSpaceNormal, screenSpaceSampleRadius, i, rotationAngleOffset);
+    }
+
+    float A = max(0.0, 1.0 - sum * (2.0f / NUM_SAMPLES));
+	//fragmentColor= vec4(viewSpaceNormal, 1.0f);
+	fragmentColor = vec4(A, A, A, 1.0f);
+}

resources/Shaders/SSAO.vert.glsl

@@ -0,0 +1,8 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+}

resources/Shaders/SSAOViewSpaceZ.frag.glsl

@@ -0,0 +1,14 @@
+#version 430
+
+uniform sampler2D DepthBuffer;
+uniform vec3 ClipInfo;
+
+//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 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

@@ -19,16 +19,20 @@ void DrawBloomPass::InitializeTextures()
 void DrawBloomPass::InitializeShaderPrograms()
 {
     m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
-    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
+	if (m_GaussianProgram_horiz->GetHandle() == 0) {
-    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
+		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
-    m_GaussianProgram_horiz->Compile();
+		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
-    m_GaussianProgram_horiz->Link();
+		m_GaussianProgram_horiz->Compile();
+		m_GaussianProgram_horiz->Link();
+	}
 
-    m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
+	m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
-    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
+	if (m_GaussianProgram_vert->GetHandle() == 0) {
-    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
+		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
-    m_GaussianProgram_vert->Compile();
+		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
-    m_GaussianProgram_vert->Link();
+		m_GaussianProgram_vert->Compile();
+		m_GaussianProgram_vert->Link();
+	}
 }
 
 
@@ -70,16 +74,18 @@ void DrawBloomPass::Draw(GLuint texture)
 
     //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
     m_GaussianFrameBuffer_horiz.Bind();
+	GLERROR("m_GaussianFrameBuffer_horiz.Bind()");
     m_GaussianProgram_horiz->Bind();
-
+	GLERROR("m_GaussianProgram_horiz->Bind()");
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture);
-
+	GLERROR("glBindTexture");
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+	GLERROR("GL_ELEMENT_ARRAY_BUFFER");
     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);
-
+	GLERROR("HEJ");
     //Iterate some times to make it more gaussian.
     for (int i = 1; i < m_iterations; i++) {
         //Vertical pass
@@ -92,7 +98,7 @@ void DrawBloomPass::Draw(GLuint texture)
         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);
-
+		GLERROR("HEJ LOOP");
         //horizontal pass
 
         m_GaussianFrameBuffer_horiz.Bind();
@@ -112,7 +118,7 @@ void DrawBloomPass::Draw(GLuint texture)
     m_GaussianProgram_vert->Bind();
 
     glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
-
+	GLERROR("GL_TEXTURE_2D");
     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

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -18,7 +18,7 @@ void DrawColorCorrectionPass::InitializeShaderPrograms()
     m_ColorCorrectionProgram->Link();
 }
 
-void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLfloat gamma, GLfloat exposure)
+void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLuint SSAOTexture, GLfloat gamma, GLfloat exposure)
 {
     //glBindFramebuffer(GL_FRAMEBUFFER, 0);
     GLERROR("DrawScreenQuadPass::Draw: Pre");
@@ -37,6 +37,8 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLu
     glBindTexture(GL_TEXTURE_2D, sceneTextureLowRes);
     glActiveTexture(GL_TEXTURE3);
     glBindTexture(GL_TEXTURE_2D, bloomTextureLowRes);
+	glActiveTexture(GL_TEXTURE4);
+	glBindTexture(GL_TEXTURE_2D, SSAOTexture);
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -22,10 +22,21 @@ void DrawFinalPass::InitializeTextures()
 
 void DrawFinalPass::InitializeFrameBuffers()
 {
-    glGenRenderbuffers(1, &m_DepthBuffer);
+
+	glGenTextures(1, &m_DepthBuffer);
+
+	glBindTexture(GL_TEXTURE_2D, m_DepthBuffer);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width), (int)(m_Renderer->GetViewportSize().Height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+
+    /*glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-    GLERROR("RenderBuffer generation");
+    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);
@@ -33,7 +44,7 @@ void DrawFinalPass::InitializeFrameBuffers()
     //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)));
@@ -176,10 +187,12 @@ void DrawFinalPass::InitializeShaderPrograms()
 void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("Pre");
-
+	RenderCamera = scene.Camera;
     DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
     if (scene.ClearDepth) {
-        glClear(GL_DEPTH_BUFFER_BIT);
+        //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);
@@ -241,7 +254,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
     DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
     GLERROR("StencilPass");
 
-    glClear(GL_DEPTH_BUFFER_BIT);
+    //glClear(GL_DEPTH_BUFFER_BIT);
 
     stateLowRes->Enable(GL_DEPTH_TEST);
     stateLowRes->StencilFunc(GL_LEQUAL, 1, 0xFF);
@@ -743,17 +756,26 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 
 void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene)
 {
-	GLERROR("Bind 1 uniform");
+	if (1/*job->Model->IsSkinned()*/) {
-	GLint Location_M = glGetUniformLocation(shaderHandle, "M");
+		GLERROR("Bind 1 uniform");
-	glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));
+		GLint Location_M = glGetUniformLocation(shaderHandle, "M");
-	GLERROR("Bind 2 uniform");
+		glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));
-	GLint Location_V = glGetUniformLocation(shaderHandle, "V");
+		GLERROR("Bind 2 uniform");
-	glUniformMatrix4fv(Location_V, 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+		GLint Location_V = glGetUniformLocation(shaderHandle, "V");
-	GLERROR("Bind 3 uniform");
+		glUniformMatrix4fv(Location_V, 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-	GLint Location_P = glGetUniformLocation(shaderHandle, "P");
+		GLERROR("Bind 3 uniform");
-	glUniformMatrix4fv(Location_P, 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+		GLint Location_P = glGetUniformLocation(shaderHandle, "P");
-	GLERROR("Bind 4 uniform");
+		glUniformMatrix4fv(Location_P, 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-
+		GLERROR("Bind 4 uniform");
+	} else {
+		GLERROR("Bind 1 uniform");
+		GLint Location_M = glGetUniformLocation(shaderHandle, "M");
+		glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));
+		GLERROR("Bind 2 uniform");
+		GLint Location_V = glGetUniformLocation(shaderHandle, "PV");
+		glUniformMatrix4fv(Location_V, 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix()));
+		GLERROR("Bind 3 uniform");
+	}
 	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
 	glUniform2f(Location_ScreenDimensions, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 	GLERROR("Bind 5 uniform");

src/Engine/Rendering/Renderer.cpp

@@ -93,7 +93,12 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0SSAO");
+
+	ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.0001f, 1.0f);
+	ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 1.0f);
+	ImGui::SliderFloat("SSAO intensity", &m_SSAO_Intensity, 0.0f, 1.0f);
+	m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Intensity);
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -124,8 +129,10 @@ void Renderer::Draw(RenderFrame& frame)
 
     }
     m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
+	m_SSAOPass->Draw(m_DrawFinalPass->DepthBuffer(), m_DrawFinalPass->DepthBufferCamera());
+
     if (m_DebugTextureToDraw == 0) {
-        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), frame.Gamma, frame.Exposure);
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), m_SSAOPass->SSAOTexture(), frame.Gamma, frame.Exposure);
     }
     if (m_DebugTextureToDraw == 1) {
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
@@ -145,6 +152,9 @@ void Renderer::Draw(RenderFrame& frame)
     if (m_DebugTextureToDraw == 6) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
+	if (m_DebugTextureToDraw == 7) {
+		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
+	}
 
     m_ImGuiRenderPass->Draw();
     GLERROR("Imgui draw");
@@ -191,4 +201,5 @@ void Renderer::InitializeRenderPasses()
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
+	m_SSAOPass = new SSAOPass(this);
 }

src/Engine/Rendering/SSAOPass.cpp

@@ -0,0 +1,135 @@
+#include "Rendering/SSAOPass.h"
+
+SSAOPass::SSAOPass(IRenderer* renderer)
+{
+	m_Renderer = renderer;
+
+	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+
+	InitializeBuffer();
+	InitializeShaderProgram();
+	Setting(0.1f, 0.012f, 1.0f);
+
+	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")));
+	m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAO.frag.glsl")));
+	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")));
+	m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAOViewSpaceZ.frag.glsl")));
+	m_SSAOViewSpaceZProgram->Compile();
+	m_SSAOViewSpaceZProgram->Link();
+}
+
+
+void SSAOPass::InitializeBuffer()
+{
+	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+
+	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOFramBuffer.Generate();
+
+	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB32F, GL_RGB, GL_FLOAT);
+
+	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOViewSpaceZFramBuffer.Generate();
+}
+
+void SSAOPass::ClearBuffer()
+{
+	m_SSAOFramBuffer.Bind();
+	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	m_SSAOFramBuffer.Unbind();
+
+	m_SSAOViewSpaceZFramBuffer.Bind();
+	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	m_SSAOViewSpaceZFramBuffer.Unbind();
+}
+
+void SSAOPass::Setting(float radius, float bias, float intensity) {
+	m_Radius = radius;
+	m_Bias = bias;
+	m_Intensity = intensity;
+}
+
+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)
+{
+	SSAOPassState state;
+	GLuint viewSpaceZPShaderHandle = m_SSAOViewSpaceZProgram->GetHandle();
+	GLuint SSAOShaderHandle = m_SSAOProgram->GetHandle();
+
+	m_SSAOViewSpaceZFramBuffer.Bind();
+	m_SSAOViewSpaceZProgram->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, depthBuffer);
+	glm::vec3 clipInfo = glm::vec3(
+		(camera->NearClip() * camera->FarClip()),
+		(camera->NearClip() - camera->FarClip()),
+		(camera->FarClip())
+		);
+	/*glm::vec3 clipInfo = glm::vec3(
+		(camera->NearClip()),
+		(-1.0f),
+		(+1.0f)
+		);*/
+	glUniform3fv(glGetUniformLocation(viewSpaceZPShaderHandle, "ClipInfo"), 1, glm::value_ptr(clipInfo));
+
+	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);
+	
+	glm::vec4 projInfo = glm::vec4(
+		(-2.0f / (m_Renderer->GetViewportSize().Width * camera->ProjectionMatrix()[0][0])),
+		(-2.0f / (m_Renderer->GetViewportSize().Height * camera->ProjectionMatrix()[1][1])),
+		((1.0f - camera->ProjectionMatrix()[0][2]) / camera->ProjectionMatrix()[0][0]),
+		((1.0f - camera->ProjectionMatrix()[1][2]) / camera->ProjectionMatrix()[1][1])
+		);
+
+
+	m_SSAOFramBuffer.Bind();
+	m_SSAOProgram->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, m_SSAOViewSpaceZTexture);
+
+	// How many pixel there are in a 1m long object 1m away from the camera
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "ProjScale"), m_Renderer->GetViewportSize().Height / (-2.0f * glm::tan(camera->FOV() * 0.5f)));
+
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "Radius"), m_Radius);
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "Bias"), m_Bias);
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "IntensityDivR6"), m_Intensity / glm::pow(m_Radius, 6));
+
+	glUniform4fv(glGetUniformLocation(SSAOShaderHandle, "ProjInfo"), 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();
+	m_DrawBloomPass->Draw(m_SSAOTexture);
+}
+
+void ComputeAO(GLuint depthBuffer, Camera* camera) {
+
+}

src/Engine/Rendering/SSAOPassState.cpp

@@ -0,0 +1,16 @@
+#include "Rendering/SSAOPassState.h"
+
+
+SSAOPassState::SSAOPassState()
+{
+	//BindFramebuffer(0);
+	Disable(GL_BLEND);
+	Disable(GL_DEPTH_TEST);
+	Disable(GL_CULL_FACE);
+}
+
+SSAOPassState::~SSAOPassState()
+{
+
+}
+

src/Engine/Rendering/ShaderProgram.cpp

@@ -98,8 +98,7 @@ void ShaderProgram::AddShader(std::shared_ptr<Shader> shader)
 
 void ShaderProgram::Compile()
 {
-	if (m_ShaderProgramHandle == 0)
+	if (m_ShaderProgramHandle == 0)	{
-	{
 		m_ShaderProgramHandle = glCreateProgram();
 	}