Merge pull request #25 from teamfisk/Forward+

Forward+

include/Engine/Rendering/DrawFinalPass.h

@@ -0,0 +1,38 @@
+#ifndef DrawFinalPass_h__
+#define DrawFinalPass_h__
+
+#include "IRenderer.h"
+#include "DrawFinalPassState.h"
+#include "LightCullingPass.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawFinalPass
+{
+public:
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
+    ~DrawFinalPass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(RenderQueueCollection& rq);
+
+    //Getters
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    Texture* m_WhiteTexture;
+
+    const IRenderer* m_Renderer;
+    const LightCullingPass* m_LightCullingPass;
+
+    ShaderProgram* m_ForwardPlusProgram;
+
+};
+
+#endif 

include/Engine/Rendering/DrawFinalPassState.h

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

include/Engine/Rendering/LightCullingPass.h

@@ -0,0 +1,78 @@
+#ifndef LightCullingPass_h__
+#define LightCullingPass_h__
+
+#define TILE_SIZE 16 
+#define NUM_LIGHTS 1000
+
+#include "IRenderer.h"
+#include "LightCullingPassState.h"
+#include "ShaderProgram.h"
+
+
+class LightCullingPass
+{
+public:
+    LightCullingPass(IRenderer* renderer);
+    ~LightCullingPass();
+
+    void GenerateNewFrustum();
+    void CullLights();
+    void FillLightList(RenderQueueCollection& rq);
+
+    GLuint FrustumSSBO() const { return m_FrustumSSBO; }
+    GLuint LightSSBO() const { return m_LightSSBO; }
+    GLuint LightGridSSBO() const { return m_LightGridSSBO; }
+    GLuint LightOffsetSSBO() const { return m_LightOffsetSSBO; }
+    GLuint LightIndexSSBO() const { return m_LightIndexSSBO; }
+private:
+
+    void InitializeSSBOs();
+    void InitializeShaderPrograms();
+
+    const IRenderer* m_Renderer;
+
+    GLuint m_FrustumSSBO = 0;
+    GLuint m_LightSSBO = 0;
+    GLuint m_LightGridSSBO = 0;
+    GLuint m_LightOffsetSSBO = 0;
+    GLuint m_LightIndexSSBO = 0;
+
+    ShaderProgram* m_CalculateFrustumProgram;
+    ShaderProgram* m_LightCullProgram;
+
+    struct Plane {
+        glm::vec3 Normal;
+        float d;
+    };
+
+    struct Frustum {
+        Plane Planes[4];
+    };
+    Frustum m_Frustums[80*45]; //TODO: Renderer: Make this change with resolution
+
+    //This should be a component
+    struct PointLight {
+        glm::vec4 Position = glm::vec4(0.f);
+        glm::vec4 Color = glm::vec4(1.f);
+        float Radius = 5.f;
+        float Intensity = 0.8f;
+        float Falloff = 0.3f;
+        float Padding = 1337;
+    };
+    std::vector<PointLight> m_PointLights;
+
+    struct LightGrid {
+        float Start;
+        float Amount;
+        glm::vec2 Padding;
+    };
+
+    LightGrid m_LightGrid[80*45]; //TODO: Renderer: Make this change with resolution
+
+    int m_LightOffset = 0;
+
+    float m_LightIndex[80*45*200]; //TODO: Renderer: Make this change with resolution
+};
+
+
+#endif

include/Engine/Rendering/PickingPass.h

@@ -1,6 +1,8 @@
 #ifndef PickingPass_h__
 #define PickingPass_h__
 
+
+
 #include "IRenderer.h"
 #include "PickingPassState.h"
 #include "FrameBuffer.h"
@@ -9,6 +11,8 @@
 #include "../Core/EventBroker.h"
 #include "EPicking.h"
 
+
+
 class PickingPass
 {
 public:
@@ -20,7 +24,6 @@ public:
 
     void Draw(RenderQueueCollection& rq);
 
-
     //Getters
     const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
     const std::unordered_map<glm::vec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }
@@ -28,7 +31,6 @@ public:
     GLuint DepthBuffer() const { return m_DepthBuffer; }
     const FrameBuffer& PickingBuffer() const { return m_PickingBuffer; }
 
-
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
 

include/Engine/Rendering/RenderQueue.h

@@ -82,11 +82,12 @@ struct SpriteJob : RenderJob
 
 struct PointLightJob : RenderJob
 {
-	glm::vec3 Position;
-	glm::vec3 SpecularColor = glm::vec3(1, 1, 1);
-	glm::vec3 DiffuseColor = glm::vec3(1, 1, 1);
-	float Radius = 1.f;
-    float Intensity = 0.8f;
+    glm::vec4 Position;
+	glm::vec4 Color;
+	float Radius;
+    float Intensity;
+    float Falloff;
+    float padding = 123;
 
 	void CalculateHash() override
 	{

include/Engine/Rendering/Renderer.h

@@ -13,19 +13,8 @@
 #include "PickingPass.h"
 #include "DrawScenePass.h"
 #include "DebugCameraInputController.h"
-
-
-#define TILE_SIZE 16 
-#define NUM_LIGHTS 3
-
-
-enum lightType 
-{
-    Point,
-    Spot,
-    Directional,
-    Area
-};
+#include "LightCullingPass.h"
+#include "DrawFinalPass.h"
 
 #include "../Core/EventBroker.h"
 #include "EPicking.h"
@@ -58,70 +47,24 @@ private:
 
     DrawScenePass* m_DrawScenePass;
     PickingPass* m_PickingPass;
+    LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
+    DrawFinalPass* m_DrawFinalPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
     void InitializeShaders();
     void InitializeTextures();
-    void InitializeSSBOs();
     void InitializeRenderPasses();
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
     void DrawScreenQuad(GLuint textureToDraw);
 
-    //----------------------Forward+-----------------------//
-    void CalculateFrustum();
-    void CullLights();
-    //Frustum
-    struct Plane {
-        glm::vec3 Normal;
-        float d;
-    };
-    struct Frustum {
-        Plane Planes[4];
-    };
-    Frustum m_Frustums[80*45]; //TODO: Renderer: Make this change with resolution
-
-    //Lights
-    void TEMPCreateLights();
-    //TODO: Renderer: Add Directionllights, spotlights and area lights to this as type.
-    struct PointLight {
-        glm::vec4 Position = glm::vec4(0.f);
-        glm::vec4 Color = glm::vec4(1.f);
-        float Radius = 5.f;
-        float Intensity = 0.8f;
-        float Falloff = 0.3f;
-        float Padding = 1337;
-    };
-    PointLight m_PointLights[NUM_LIGHTS];
-
-    struct LightGrid {
-        int Amount;
-        int Start;
-        glm::vec2 Padding;
-    };
-    LightGrid m_LightGrid[80*45];
-
-    int m_LightOffset = 0;
-
-    int m_LightIndex[80*45*200];
-
-    //-------------------------SSBO------------------------//
-    GLuint m_FrustumSSBO = 0;
-    GLuint m_LightSSBO = 1;
-    GLuint m_LightGridSSBO = 2;
-    GLuint m_LightOffsetSSBO = 3;
-    GLuint m_LightIndexSSBO = 4;
-
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
 	ShaderProgram* m_BasicForwardProgram;
     ShaderProgram* m_DrawScreenQuadProgram;
-    ShaderProgram* m_CalculateFrustumProgram;
-    ShaderProgram* m_LightCullProgram;
-
 };
 
 #endif

resources/Schema/Components.xsd

@@ -7,6 +7,7 @@
 	<xs:include schemaLocation="Components/RaptorCopter.xsd"/>
 	<xs:include schemaLocation="Components/Player.xsd"/>
 	<xs:include schemaLocation="Components/AABB.xsd"/>
+	<xs:include schemaLocation="Components/PointLight.xsd"/>
 	<xs:include schemaLocation="Components/Trigger.xsd"/>
 	<xs:include schemaLocation="Components/Health.xsd"/>
 </xs:schema>

resources/Schema/Components/PointLight.xml

@@ -0,0 +1,7 @@
+<c:PointLight>
+	<Color R="1" G="1" B="1" A="1"/>
+	<Radius>1.0</Radius>
+	<Intensity>0.8</Intensity>
+	<Falloff>0.3</Falloff>
+	<Visible>true</Visible>
+</c:PointLight>

resources/Schema/Components/PointLight.xsd

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="PointLight">
+		<xs:annotation>
+			<xs:documentation>A pointlight that lights up geometry in a radius.</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="Color" type="t:Color" minOccurs="0"/>
+				<xs:element name="Radius" type="t:double" minOccurs="0"/>
+				<xs:element name="Intensity" type="t:double" minOccurs="0"/>
+				<xs:element name="Falloff" type="t:double" minOccurs="0"/>
+				<xs:element name="Visible" type="t:bool" minOccurs="0"/>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/Test.xml

@@ -10,7 +10,7 @@
 		</c:Model>
 	</Components>
 	<Children>
-		<Entity>
+		<!--<Entity>
 			<Components>
 				<c:Transform>
 					<Position X="-1.5"/>
@@ -20,8 +20,8 @@
 					<Resource>Models/ScaleWidget.obj</Resource>
 				</c:Model>
 			</Components>
-		</Entity>
-		<Entity>
+		</Entity>-->
+		<!--<Entity>
 			<Components>
 				<c:Transform>
 					<Position X="1.5"/>
@@ -33,7 +33,7 @@
 				<c:Trigger>
 				</c:Trigger>
 			</Components>
-		</Entity>
+		</Entity>-->
 		<!--<Entity>
 			<Components>
 				<c:Player>

resources/Schema/Types/Entity.xsd

@@ -16,6 +16,7 @@
 							<xs:element ref="c:RaptorCopter" minOccurs="0"/>
 							<xs:element ref="c:Player" minOccurs="0"/>
 							<xs:element ref="c:Health" minOccurs="0"/>
+							<xs:element ref="c:PointLight" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

resources/Shaders/CullLights.comp.glsl

@@ -0,0 +1,154 @@
+#version 430
+
+//in uvec3 gl_NumWorkGroups;			//contains the number of workgroups that have been dispatched to a compute shader
+//in uvec3 gl_WorkGroupID;				//contains the index of the workgroup currently being operated on by a compute shader
+//in uvec3 gl_LocalInvocationID;		//contains the index of work item currently being operated on by a compute shader
+//in uvec3 gl_GlobalInvocationID;		//contains the global index of work item currently being operated on by a compute shader
+//in uint  gl_LocalInvocationIndex;		//contains the local linear index of work item currently being operated on by a compute shader
+
+
+
+#define MAX_LIGHTS_PER_TILE 200
+#define NUM_TILES 3600
+#define TILE_SIZE 16
+
+uniform mat4 V;
+
+struct Plane {
+	vec3 Normal;
+	float d;
+};
+struct Frustum {
+	Plane Planes[4];
+};
+
+layout (std430, binding = 0) buffer FrustumBuffer
+{
+	Frustum Data[];
+} Frustums;
+
+struct PointLight {
+	vec4 Position;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	float Padding;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	PointLight List[];
+} PointLights;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 3) buffer LightOffsetBuffer
+{
+	int LightOffset[];
+};
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+shared int GroupLightCount;
+shared int GroupLightIndexStartOffset;
+shared int GroupLightIndex[MAX_LIGHTS_PER_TILE];
+shared Frustum GroupFrustum;
+int GroupIndex;
+
+bool SphereInsidePlane(vec3 center, float radius, Plane plane)
+{
+	return dot(plane.Normal, center) - plane.d > -radius;
+}
+
+bool SphereInsideFrustrum(vec3 center, float radius, Frustum frustum/*, float zNear, float zFar*/)
+{
+
+	//Check depth here
+	//if ( sphere.c.z - sphere.r > zNear || sphere.c.z + sphere.r < zFar )
+    //{
+    //    result = false;
+    //}
+ 
+ 	for (int i =0; i < 4; i++)
+ 	{
+ 		if(! SphereInsidePlane(center, radius, frustum.Planes[i]))
+ 		{
+ 			return false;
+ 		}
+ 	}
+ 	return true;
+}
+
+void AppendLight(int li)
+{
+	int index;
+	index = atomicAdd(GroupLightCount, 1);
+	if( index < MAX_LIGHTS_PER_TILE )
+	{ 
+		GroupLightIndex[index] = int(li);
+	}
+}
+
+layout (local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
+void main ()
+{
+	GroupIndex = int(gl_WorkGroupID.x + (gl_WorkGroupID.y * 80));
+	if(gl_LocalInvocationIndex == 0)
+	{
+		GroupLightCount = 0;
+		GroupFrustum = Frustums.Data[GroupIndex];
+	}
+
+	barrier();
+	memoryBarrierShared();
+
+	for(int i = int(gl_LocalInvocationIndex); i < PointLights.List.length(); i += TILE_SIZE*TILE_SIZE)
+	{
+		PointLight light = PointLights.List[i];
+
+		//if pointlight
+		//Pos i view antagligen
+		if(SphereInsideFrustrum( vec3(V * light.Position), light.Radius, GroupFrustum))
+		{
+			//TODO: Fix transparent and opaque list, and depth test.
+			AppendLight( i );
+		}
+
+
+		//if conelight
+
+		//if directional
+
+	}
+
+	barrier();
+	memoryBarrierShared();
+
+	if(gl_LocalInvocationIndex == 0)
+	{
+		GroupLightIndexStartOffset = atomicAdd(LightOffset[0], GroupLightCount);
+		LightGrids.Data[GroupIndex].Start = GroupLightIndexStartOffset;
+		LightGrids.Data[GroupIndex].Amount = GroupLightCount;
+	}
+
+	barrier();
+	
+
+	for (uint i = gl_LocalInvocationIndex; i < GroupLightCount; i += TILE_SIZE * TILE_SIZE )
+	{
+	    LightIndex[GroupLightIndexStartOffset + i] = GroupLightIndex[i];
+	}
+}

resources/Shaders/ForwardPlus.frag.glsl

@@ -0,0 +1,132 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec4 Color;
+
+uniform sampler2D texture0;
+
+#define TILE_SIZE 16
+
+struct PointLight {
+	vec4 Position;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	float Padding;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	PointLight List[];
+} PointLights;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+	vec4 DiffuseColor;
+}Input;
+
+out vec4 fragmentColor;
+
+vec4 scene_ambient = vec4(0.3,0.3,0.3,1);
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist) {
+	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+}
+
+vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
+	vec4 R = normalize( reflect(-lightVec, normal));
+	float RdotV = max( dot(R, viewVec), 0.0);
+	return lightColor * pow(RdotV, 90.0);
+}
+
+vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
+	float power = max( dot(normal, lightVec), 0.0);
+	return lightColor * power;
+}
+
+LightResult CalcPointLight(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist);
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
+	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
+	return result;
+}
+
+
+void main()
+{
+	vec4 texel = texture2D(texture0, Input.TextureCoordinate);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	vec4 normal = V  * vec4(Input.Normal, 0.0);
+	vec4 viewVec = normalize(-position); 
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/16);
+	tilePos.y = int(gl_FragCoord.y/16);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = scene_ambient;
+	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * 80));
+
+	int start = int(LightGrids.Data[currentTile].Start);
+	int amount = int(LightGrids.Data[currentTile].Amount);
+	//for(int i = 0; i < 3; i++)
+	for(int i = start; i < start + amount; i++)
+	{
+		int l = int(LightIndex[i]);
+
+		LightResult result = CalcPointLight(V * PointLights.List[l].Position, PointLights.List[l].Radius, PointLights.List[l].Color, PointLights.List[l].Intensity, viewVec, position, normal);
+
+		totalLighting.Diffuse += result.Diffuse;
+		totalLighting.Specular += result.Specular;
+	}
+
+	fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
+	//fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
+	//fragmentColor += vec4(0.0, LightGrids.Data[currentTile].Amount/3.0, 0, 1);
+	//fragmentColor = texel * Input.DiffuseColor * Color;
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 )
+	{
+		//fragmentColor += vec4(0.5, 0, 0, 0);
+	} else {
+		//fragmentColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/3.0, 0, 0, 1);
+
+
+	}
+
+}
+
+

resources/Shaders/ForwardPlus.vert.glsl

@@ -0,0 +1,34 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 DiffuseVertexColor;
+layout(location = 6) in vec4 SpecularVertexColor;
+layout(location = 7) in vec4 BoneIndices1;
+layout(location = 8) in vec4 BoneIndices2;
+layout(location = 9) in vec4 BoneWeights1;
+layout(location = 10) in vec4 BoneWeights2;
+
+out VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+	vec4 DiffuseColor;
+}Output;
+
+void main()
+{
+	gl_Position = P*V*M * vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.TextureCoordinate = TextureCoords;
+	Output.Normal = Normal;
+	Output.DiffuseColor = DiffuseVertexColor;
+}

resources/Shaders/GridFrustum.comp.glsl

@@ -16,7 +16,7 @@ struct Frustum {
 
 layout (std430, binding = 0) buffer FrustumBuffer
 {
-	Frustum Data[3600];
+	Frustum Data[];
 } Frustums;
 
 vec4 ConvertToView(vec4 ScreenCoords)
@@ -43,31 +43,34 @@ Plane ComputePlane( vec3 p0, vec3 p1, vec3 p2 )
 layout (local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
 void main ()
 {
-	if(gl_GlobalInvocationID.x * TILE_SIZE < ScreenDimensions.x && gl_GlobalInvocationID.y * TILE_SIZE < ScreenDimensions.y) {
 	//Top-Left = 0 		| Top-Right = 1 
 	//Bottom-Left = 2 	| Bottom-Right = 3
 	vec4 ScreenCoords[4];
-		ScreenCoords[0] = vec4(gl_GlobalInvocationID.x 		 * TILE_SIZE, 	(gl_GlobalInvocationID.y + 1       ) * TILE_SIZE, -1.0, 1.0); // Z-axis might need to be 1
+	ScreenCoords[0] = vec4(gl_GlobalInvocationID.x 		 * TILE_SIZE, 	(gl_GlobalInvocationID.y + 1) * TILE_SIZE, -1.0, 1.0);
 	ScreenCoords[1] = vec4((gl_GlobalInvocationID.x + 1) * TILE_SIZE, 	(gl_GlobalInvocationID.y + 1) * TILE_SIZE, -1.0, 1.0);
 	ScreenCoords[2] = vec4(gl_GlobalInvocationID.x 		 * TILE_SIZE, 	(gl_GlobalInvocationID.y)	  * TILE_SIZE, 	-1.0, 1.0);
 	ScreenCoords[3] = vec4((gl_GlobalInvocationID.x + 1) * TILE_SIZE, 	(gl_GlobalInvocationID.y) 	  * TILE_SIZE, 	-1.0, 1.0);
 
+
+
 	vec3 ViewVectors[4];
 	for(int i = 0; i < 4; i++) {
 		ViewVectors[i] = vec3(ConvertToView(ScreenCoords[i]));
 	}
 
-		vec3 EyePos = vec3(0,0,0);
+	vec3 EyePos = vec3(0.0, 0.0 ,0.0);
 
 	Frustum f;
-		f.Planes[0] = ComputePlane(EyePos, ViewVectors[2], ViewVectors[0]);
-		f.Planes[1] = ComputePlane(EyePos, ViewVectors[1], ViewVectors[3]);
-		f.Planes[2] = ComputePlane(EyePos, ViewVectors[0], ViewVectors[1]);
-		f.Planes[3] = ComputePlane(EyePos, ViewVectors[3], ViewVectors[2]);
+	f.Planes[0] = ComputePlane(EyePos, ViewVectors[2], ViewVectors[0]); // left plane
+	f.Planes[1] = ComputePlane(EyePos, ViewVectors[1], ViewVectors[3]); // right plane
+	f.Planes[2] = ComputePlane(EyePos, ViewVectors[0], ViewVectors[1]);	// top plane
+	f.Planes[3] = ComputePlane(EyePos, ViewVectors[3], ViewVectors[2]); // bottom plane
 
 
 
 	
+	if ( gl_GlobalInvocationID.x < ScreenDimensions.x / TILE_SIZE && gl_GlobalInvocationID.y < ScreenDimensions.y / TILE_SIZE ) { // inside the screen
         Frustums.Data[gl_GlobalInvocationID.x + gl_GlobalInvocationID.y*80] = f;	
+
     }
 }

resources/Shaders/cullLights.comp.glsl

@@ -1,35 +0,0 @@
-#version 430
-
-//in uvec3 gl_NumWorkGroups;
-//in uvec3 gl_WorkGroupID;
-//in uvec3 gl_LocalInvocationID;
-//in uvec3 gl_GlobalInvocationID;
-//in uint  gl_LocalInvocationIndex;
-
-
-
-#define NUM_LIGHTS 3
-#define MAX_LIGHTS_PER_TILE 200
-#define NUM_TILES 3600
-
-struct Plane {
-	vec3 Normal;
-	float d;
-};
-struct Frustum {
-	Plane Planes[4];
-};
-
-layout (std430, binding = 0) buffer FrustumBuffer
-{
-	Frustum Data[3600];
-} Frustums;
-
-
-
-layout (local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
-void main ()
-{
-		if(1 == 1) {
-	}
-}

src/Engine/Rendering/DrawFinalPass.cpp

@@ -0,0 +1,65 @@
+#include "Rendering/DrawFinalPass.h"
+
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
+{
+    m_Renderer = renderer;
+    m_LightCullingPass = lightCullingPass;
+    InitializeTextures();
+    InitializeShaderPrograms();
+}
+
+void DrawFinalPass::InitializeTextures()
+{
+    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+}
+
+void DrawFinalPass::InitializeShaderPrograms()
+{
+    m_ForwardPlusProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram");
+    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlus.frag.glsl")));
+    m_ForwardPlusProgram->Compile();
+    m_ForwardPlusProgram->Link();
+}
+
+void DrawFinalPass::Draw(RenderQueueCollection& rq)
+{
+    GLERROR("DrawFinalPass::Draw: Pre");
+
+    DrawFinalPassState state;
+    m_ForwardPlusProgram->Bind();
+    GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
+
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
+
+    //TODO: Render: Add code for more jobs than modeljobs.
+    for (auto &job : rq.Forward) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if(modelJob) {
+            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
+            glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
+
+            if(modelJob->DiffuseTexture != nullptr) {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
+            } else {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+            }
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
+
+            continue;
+        }
+    }
+    GLERROR("DrawFinalPass::Draw: END");
+
+}

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -0,0 +1,17 @@
+#include "Rendering/DrawFinalPassState.h"
+
+
+DrawFinalPassState::DrawFinalPassState()
+{
+    BindFramebuffer(0);
+
+    Enable(GL_DEPTH_TEST);
+    Enable(GL_CULL_FACE);
+    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
+    Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+DrawFinalPassState::~DrawFinalPassState()
+{
+
+}

src/Engine/Rendering/DrawScenePass.cpp

@@ -14,23 +14,21 @@ void DrawScenePass::InitializeTextures()
 
 void DrawScenePass::InitializeShaderPrograms()
 {
-    //Gör så att shaders är en resource, tex som texture classen. Konstruktorn måste vara privat.
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#BasicForwardProgram");
 
     m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/BasicForward.vert.glsl")));
     m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/BasicForward.frag.glsl")));
     m_BasicForwardProgram->Compile();
     m_BasicForwardProgram->Link();
-
-
 }
 
 void DrawScenePass::Draw(RenderQueueCollection& rq)
 {
     //glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    GLERROR("Renderer::Draw PickingPass");
+    GLERROR("DrawScenePass::Draw: Pre");
 
     DrawScenePassState state;
+    m_BasicForwardProgram->Bind();
 
 
     //TODO: Render: Add code for more jobs than modeljobs.
@@ -39,7 +37,6 @@ void DrawScenePass::Draw(RenderQueueCollection& rq)
         if (modelJob) {
             GLuint ShaderHandle = m_BasicForwardProgram->GetHandle();
 
-            m_BasicForwardProgram->Bind();
             //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
@@ -61,6 +58,12 @@ void DrawScenePass::Draw(RenderQueueCollection& rq)
 
             continue;
         }
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if(spriteJob)
+        {
+            //Hello im a sprite, please draw me.
         }
-    GLERROR("DrawScene Error");
+
+    }
+    GLERROR("DrawScenePass::Draw: End");
 }

src/Engine/Rendering/LightCullingPass.cpp

@@ -0,0 +1,126 @@
+#include "Rendering/LightCullingPass.h"
+
+LightCullingPass::LightCullingPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+    InitializeSSBOs();
+    InitializeShaderPrograms();
+    GenerateNewFrustum();
+}
+
+LightCullingPass::~LightCullingPass()
+{
+
+}
+
+void LightCullingPass::GenerateNewFrustum()
+{
+    GLERROR("CalculateFrustum Error: Pre");
+
+    m_CalculateFrustumProgram->Bind();
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
+    glUniformMatrix4fv(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "P"), 1, false, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
+    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glDispatchCompute(5, 3, 1); //TODO: Renderer: This needs change so resolution will be right.
+
+    GLERROR("CalculateFrustum Error: End");
+}
+
+void LightCullingPass::CullLights()
+{
+    GLERROR("CullLights Error: Pre");
+    m_LightOffset = 0;
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightOffsetSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightOffset), &m_LightOffset, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightSSBO);
+    if (m_PointLights.size() > 0) {
+        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(PointLight) * m_PointLights.size(), &(m_PointLights[0]), GL_DYNAMIC_COPY);
+    } else {
+        GLfloat zero = 0.f;
+        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLfloat), &zero , GL_DYNAMIC_COPY);
+
+    }
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+
+    m_LightCullProgram->Bind();
+    glUniformMatrix4fv(glGetUniformLocation(m_LightCullProgram->GetHandle(), "V"), 1, false, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
+    glDispatchCompute(m_Renderer->Resolution().Width / TILE_SIZE, m_Renderer->Resolution().Height / TILE_SIZE, 1);
+
+    GLERROR("CullLights Error: End");
+}
+
+void LightCullingPass::FillLightList(RenderQueueCollection& rq)
+{
+    m_PointLights.clear();
+    for(auto &job : rq.Lights) {
+        auto pointLightjob = std::dynamic_pointer_cast<PointLightJob>(job);
+        if (pointLightjob) {
+            PointLight p;
+            p.Color = pointLightjob->Color;
+            p.Falloff = pointLightjob->Falloff;
+            p.Intensity = pointLightjob->Intensity;
+            p.Position = glm::vec4(glm::vec3(pointLightjob->Position), 1.f);
+            p.Radius = pointLightjob->Radius;
+            p.Padding = 123.f;
+            m_PointLights.push_back(p);
+            continue;
+        }
+    }
+}
+
+void LightCullingPass::InitializeSSBOs()
+{
+    glGenBuffers(1, &m_FrustumSSBO);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_FrustumSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_Frustums), &m_Frustums, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    GLERROR("m_FrustumSSBO");
+
+    glGenBuffers(1, &m_LightSSBO);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightSSBO);
+    if(m_PointLights.size() > 0) {
+        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(PointLight) * m_PointLights.size(), &(m_PointLights[0]), GL_DYNAMIC_COPY);
+    }
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    GLERROR("m_LightSSBO");
+
+    glGenBuffers(1, &m_LightGridSSBO);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightGridSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightGrid), &m_LightGrid, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    GLERROR("m_LightGridSSBO");
+
+
+    glGenBuffers(1, &m_LightOffsetSSBO);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightOffsetSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightOffset), &m_LightOffset, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    GLERROR("m_LightOffsetSSBO");
+
+    glGenBuffers(1, &m_LightIndexSSBO);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightIndexSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightIndex), &m_LightIndex, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    GLERROR("m_LightIndexSSBO");
+}
+
+void LightCullingPass::InitializeShaderPrograms()
+{
+    m_CalculateFrustumProgram = ResourceManager::Load<ShaderProgram>("#CalculateFrustumProgram");
+    m_CalculateFrustumProgram->AddShader(std::shared_ptr<Shader>(new ComputeShader("Shaders/GridFrustum.comp.glsl")));
+    m_CalculateFrustumProgram->Compile();
+    m_CalculateFrustumProgram->Link();
+
+    m_LightCullProgram = ResourceManager::Load<ShaderProgram>("#LightCullProgram");
+    m_LightCullProgram->AddShader(std::shared_ptr<Shader>(new ComputeShader("Shaders/CullLights.comp.glsl")));
+    m_LightCullProgram->Compile();
+    m_LightCullProgram->Link();
+}
+

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -111,6 +111,34 @@ void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
 
 void RenderQueueFactory::FillLights(World* world, RenderQueue* renderQueue)
 {
+    auto pointLights = world->GetComponents("PointLight");
+    if(pointLights == nullptr) {
+        return;
+    }
 
+    for(auto& pointlightC : *pointLights) {
+        bool visible = pointlightC["Visible"];
+        if(!visible) {
+            continue;
+        }
+        auto transformC = world->GetComponent(pointlightC.EntityID, "Transform");
+        if(&transformC == nullptr) {
+            return;
+        }
+
+        glm::vec4 color = pointlightC["Color"];
+        float radius = (double)pointlightC["Radius"];
+        float intensity = (double)pointlightC["Intensity"];
+        float falloff = (double)pointlightC["Falloff"];
+
+        PointLightJob job;
+        job.Position = glm::vec4(AbsolutePosition(world, transformC.EntityID), 1.f);
+        job.Color = color;
+        job.Radius = radius;
+        job.Intensity = intensity;
+        job.Falloff = falloff;
+
+        renderQueue->Add(job);
+    }
 }
 

src/Engine/Rendering/RenderState.cpp

@@ -3,6 +3,7 @@
 bool RenderState::Enable(GLenum cap)
 {
     if (glIsEnabled(cap)) {
+        //LOG_WARNING("Trying to enable somthing that is already enabled.");
         return false;
     }
     m_ResetFunctions.push_back(std::bind(glDisable, cap));

src/Engine/Rendering/Renderer.cpp

@@ -4,20 +4,17 @@ void Renderer::Initialize()
 {
 	InitializeWindow();
 	// Create default camera
-	m_DefaultCamera = new ::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
-	m_DefaultCamera->SetPosition(glm::vec3(0, 0, 10));
+	m_DefaultCamera = new ::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(90.0f), 0.01f, 5000.f);
+	m_DefaultCamera->SetPosition(glm::vec3(0, 1, 10));
 	if (m_Camera == nullptr) {
 		m_Camera = m_DefaultCamera;
 	}
     m_DebugCameraInputController = std::make_shared<DebugCameraInputController<Renderer>>(m_EventBroker, -1);
-    TEMPCreateLights();
     InitializeRenderPasses();
 
 	glfwSwapInterval(m_VSYNC);
 	InitializeShaders();
     InitializeTextures();
-    InitializeSSBOs();
-    //CalculateFrustum();
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
@@ -75,49 +72,10 @@ void Renderer::InitializeShaders()
     m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
     m_DrawScreenQuadProgram->Compile();
     m_DrawScreenQuadProgram->Link();
-
-    //m_CalculateFrustumProgram = ResourceManager::Load<ShaderProgram>("#CalculateFrustumProgram");
-    //m_CalculateFrustumProgram.AddShader(std::shared_ptr<Shader>(new ComputeShader("Shaders/GridFrustum.comp.glsl")));
-    //m_CalculateFrustumProgram.Compile();
-    //m_CalculateFrustumProgram.Link();
-
-    //m_LightCullProgram = ResourceManager::Load<ShaderProgram>("#LightCullProgram");
-    //m_LightCullProgram.AddShader(std::shared_ptr<Shader>(new ComputeShader("Shaders/cullLights.comp.glsl")));
-    //m_LightCullProgram.Compile();
-    //m_LightCullProgram.Link();
 }
 
 void Renderer::InputUpdate(double dt)
 {
-	glm::vec3 m_Position = m_Camera->Position();
-	if (glfwGetKey(m_Window, GLFW_KEY_O) == GLFW_PRESS)
-	{
-		m_Position = glm::vec3(0.f, 0.f, 5.f);
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_W) == GLFW_PRESS)
-	{
-		m_Position += m_Camera->Forward() * m_CameraMoveSpeed * (float)dt;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_S) == GLFW_PRESS)
-	{
-		m_Position -= m_Camera->Forward() * m_CameraMoveSpeed * (float)dt;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_D) == GLFW_PRESS)
-	{
-		m_Position += m_Camera->Right() * m_CameraMoveSpeed * (float)dt;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_A) == GLFW_PRESS)
-	{
-		m_Position -= m_Camera->Right() * m_CameraMoveSpeed * (float)dt;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
-	{
-		m_CameraMoveSpeed = 5.f;
-	}
-	else {
-		m_CameraMoveSpeed = 0.5f;
-	}
-
     m_DebugCameraInputController->Update(dt);
     m_Camera->SetOrientation(m_DebugCameraInputController->Orientation());
 	m_Camera->SetPosition(m_DebugCameraInputController->Position());
@@ -134,11 +92,12 @@ void Renderer::Draw(RenderQueueCollection& rq)
 {
     m_PickingPass->Draw(rq);
     //DrawScreenQuad(m_PickingPass->PickingTexture());
-    //CullLights();
+    m_LightCullingPass->FillLightList(rq);
+    m_LightCullingPass->CullLights();
     
+    //m_DrawScenePass->Draw(rq);
+    m_DrawFinalPass->Draw(rq);
     glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 1.f);
-
-    m_DrawScenePass->Draw(rq);
     GLERROR("Renderer::Draw m_DrawScenePass->Draw");
     m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
@@ -183,95 +142,10 @@ void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filterin
     GLERROR("Texture initialization failed");
 }
 
-void Renderer::InitializeSSBOs()
-{
-    printf("Size: %i\n", sizeof(m_Frustums));
-    glGenBuffers(1, &m_FrustumSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_FrustumSSBO);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_Frustums), &m_Frustums, GL_DYNAMIC_COPY);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-
-    GLERROR("m_FrustumSSBO");
-
-    glGenBuffers(1, &m_LightSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightSSBO);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_PointLights), &m_PointLights, GL_DYNAMIC_COPY);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-
-    GLERROR("m_LightSSBO");
-
-
-    glGenBuffers(1, &m_LightGridSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightGridSSBO);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightGrid), &m_LightGrid, GL_DYNAMIC_COPY);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-
-    GLERROR("m_LightGridSSBO");
-
-
-    glGenBuffers(1, &m_LightOffsetSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightOffsetSSBO);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightOffset), &m_LightOffset, GL_DYNAMIC_COPY);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-
-    GLERROR("m_LightOffsetSSBO");
-
-
-    glGenBuffers(1, &m_LightIndexSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightIndexSSBO);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightIndex), &m_LightIndex, GL_DYNAMIC_COPY);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-
-    GLERROR("m_LightIndexSSBO");
-
-}
-
 void Renderer::InitializeRenderPasses()
 {
     m_DrawScenePass = new DrawScenePass(this);
     m_PickingPass = new PickingPass(this, m_EventBroker);
+    m_LightCullingPass = new LightCullingPass(this);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
 }
-
-void Renderer::CalculateFrustum()
-{
-    GLERROR("CalculateFrustum Error-1");
-    m_CalculateFrustumProgram->Bind();
-    
-    GLERROR("CalculateFrustum Error1");
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
-    GLERROR("CalculateFrustum Error2");
-    glUniformMatrix4fv(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "P"), 1, false, glm::value_ptr(m_Camera->ProjectionMatrix()));
-    GLERROR("CalculateFrustum Error3");
-    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Resolution.Width, m_Resolution.Height);
-    GLERROR("CalculateFrustum Error4");
-    glDispatchCompute(5, 3, 1);
-    GLERROR("CalculateFrustum Error5");
-
-}
-
-void Renderer::TEMPCreateLights()
-{
-    for (int i = 0; i < NUM_LIGHTS; i++) {
-        m_PointLights[i].Position = glm::vec4(i, 0.f, 0.f, 0.f);
-        m_PointLights[i].Color = glm::vec4(1.f, 0.5f, 0.f + i*0.1f, 1.f);
-    }
-}
-
-void Renderer::CullLights()
-{
-    m_LightCullProgram->Bind();
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
-    glDispatchCompute(m_Resolution.Width / TILE_SIZE, m_Resolution.Height / TILE_SIZE, 1);
-    GLERROR("CullLights Error");
-
-}
-