Merge pull request #33 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(RenderScene& scene);
+
+    //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/IRenderer.h

@@ -9,6 +9,8 @@
 #include "Camera.h"
 #include "RenderQueue.h"
 #include "Model.h"
+#include "../Core/World.h" //So temp
+
 
 struct PickData
 {
@@ -43,6 +45,8 @@ public:
 	virtual void Draw(RenderFrame& rq) = 0;
     virtual PickData Pick(glm::vec2 screenCord) = 0;
 
+    World* m_World; //Temp world, untill viktor merge.
+
 protected:
 	Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
 	bool m_Fullscreen = false;

include/Engine/Rendering/LightCullingPass.h

@@ -0,0 +1,83 @@
+#ifndef LightCullingPass_h__
+#define LightCullingPass_h__
+
+#define TILE_SIZE 16 
+#define MAX_LIGHTS_PER_TILE 200
+
+#include "IRenderer.h"
+#include "LightCullingPassState.h"
+#include "ShaderProgram.h"
+#include "RenderQueue.h"
+
+
+class LightCullingPass
+{
+public:
+    LightCullingPass(IRenderer* renderer);
+    ~LightCullingPass();
+
+    void GenerateNewFrustum(RenderScene& scene);
+    void OnResolutionChange();
+    void SetSSBOSizes();
+    void CullLights(RenderScene& scene);
+    void FillLightList(RenderScene& scene);
+
+    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;
+
+    int m_NumberOfTiles = 0;
+
+    struct Plane {
+        glm::vec3 Normal;
+        float d;
+    };
+
+    struct Frustum {
+        Plane Planes[4];
+    };
+    Frustum* m_Frustums;
+
+    //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;
+
+    int m_LightOffset = 0;
+
+    float* m_LightIndex;
+};
+
+
+#endif

include/Engine/Rendering/ModelJob.h

@@ -44,7 +44,7 @@ struct ModelJob : RenderJob
     const ::Model* Model = nullptr;
     unsigned int StartIndex = 0;
     unsigned int EndIndex = 0;
-    const World* World;
+    World* World;
 
     void CalculateHash() override
     {

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 "../Core/World.h"
 
+
+
 class PickingPass
 {
 public:
@@ -21,7 +25,6 @@ public:
     void Draw(RenderScene& scene);
     void ClearPicking();
 
-
     //Getters
     const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
     //const std::unordered_map<glm::ivec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }

include/Engine/Rendering/PointLightJob.h

@@ -0,0 +1,39 @@
+#ifndef PointLightJob_h__
+#define PointLightJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "RenderJob.h"
+#include "../Core/Transform.h"
+#include "../Core/World.h"
+
+struct PointLightJob : RenderJob
+{
+    PointLightJob(ComponentWrapper transformComponent, ComponentWrapper pointLightComponent, World* m_World)
+        : RenderJob()
+    {
+        Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
+        Position = glm::vec4(Transform::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
+        Color = (glm::vec4)pointLightComponent["Color"];
+        Radius = (double)pointLightComponent["Radius"];
+        Intensity = (double)pointLightComponent["Intensity"];
+        Falloff = (double)pointLightComponent["Falloff"];
+    };
+
+    glm::vec4 Position;
+    glm::vec4 Color;
+    float Radius;
+    float Intensity;
+    float Falloff;
+    float padding = 123;
+
+    void CalculateHash() override
+    {
+        Hash = 0;
+    }
+};
+
+#endif

include/Engine/Rendering/RenderQueue.h

@@ -11,7 +11,7 @@
 #include "Camera.h"
 #include "RenderJob.h"
 #include "ModelJob.h"
-
+#include "PointLightJob.h"
 
 
 /*
@@ -34,11 +34,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
 	{
@@ -51,13 +52,13 @@ struct RenderScene
 {
     ::Camera* Camera;
     std::list<std::shared_ptr<RenderJob>> ForwardJobs;
-    std::list<std::shared_ptr<RenderJob>> LightJobs;
+    std::list<std::shared_ptr<RenderJob>> PointLightJobs;
     Rectangle Viewport;
 
 	void Clear()
 	{
         ForwardJobs.clear();
-        LightJobs.clear();
+        PointLightJobs.clear();
 	}
 };
 

include/Engine/Rendering/RenderSystem.h

@@ -13,6 +13,7 @@
 #include "Camera.h"
 #include "ModelJob.h"
 #include "Renderer.h"
+#include "PointLightJob.h"
 #include "../Core/Transform.h"
 #include "DebugCameraInputController.h"
 
@@ -45,6 +46,7 @@ private:
     void updateProjectionMatrix(ComponentWrapper& cameraComponent);
     
     void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
 
     EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);

include/Engine/Rendering/Renderer.h

@@ -12,9 +12,12 @@
 #include "../Core/World.h"
 #include "PickingPass.h"
 #include "DrawScenePass.h"
+#include "LightCullingPass.h"
+#include "DrawFinalPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
+#include "../Core/Transform.h"
 
 class Renderer : public IRenderer
 {
@@ -44,24 +47,26 @@ 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);
 
+    static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
+    void FillDepth(RenderScene& scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
 	ShaderProgram* m_BasicForwardProgram;
     ShaderProgram* m_DrawScreenQuadProgram;
-
 };
 
 #endif

resources/Schema/Components.xsd

@@ -8,6 +8,7 @@
 	<xs:include schemaLocation="Components/Player.xsd"/>
 	<xs:include schemaLocation="Components/Camera.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" minInclusive="0" maxInclusive="1"/>
+				<xs:element name="Visible" type="t:bool" minOccurs="0"/>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/EditorTestWorld.xml

@@ -1,49 +1,57 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
-<Entity xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xi="http://www.w3.org/2001/XInclude" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd" xmlns:c="components">
-	<Components>
-		<c:Transform>
-			<Position X="0" Y="0" Z="0"/>
-			<Orientation X="0" Y="0" Z="0"/>
-		</c:Transform>
-	</Components>
-	<Children>
-		<Entity>
-			<Components>
-				<c:Transform>
-					<Position X="0" Y="0" Z="0"/>
-					<Scale X="100" Y="1" Z="100"/>
-				</c:Transform>
-				<c:Model>
-					<Resource>Models/Core/UnitPlane.obj</Resource>
-				</c:Model>
-			</Components>
-		</Entity>
-		<Entity>
-			<Components>
-				<c:Transform>
-					<Position X="1" Y="1" Z="0"/>
-					<Orientation X="0" Y="0.78539" Z="0"/>
-				</c:Transform>
-				<c:Model>
-					<Resource>An error</Resource>
-				</c:Model>
-			</Components>
-			<Children>
-				<Entity>
-					<Components>
-						<c:Transform>
-							<Position X="2" Y="0" Z="0"/>
-							<Orientation X="0" Y="0.78539" Z="0"/>
-						</c:Transform>
-						<c:Model>
-							<Resource>An error</Resource>
-						</c:Model>
-					</Components>
-					<Children>
-					</Children>
-				</Entity>
-			</Children>
-		</Entity>
-	</Children>
-</Entity>
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.obj</Resource>
+        </c:Model>
+        <c:Transform>
+          <Scale X="100" Y="1" Z="100"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>An error</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1" Y="1" Z="0"/>
+          <Orientation X="0" Y="0.785390019" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Model>
+              <Resource>An error</Resource>
+            </c:Model>
+            <c:Transform>
+              <Position X="2" Y="0" Z="0"/>
+              <Orientation X="0" Y="0.785390019" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Camera/>
+        <c:Transform>
+          <Position X="5.85247707" Y="3.8454349" Z="-1.14486957"/>
+          <Orientation X="2.51327395" Y="1.23916209" Z="-3.1415925"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

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 TILE_SIZE 16
+
+uniform mat4 V;
+uniform vec2 ScreenDimensions;
+
+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 * int(ScreenDimensions.x/TILE_SIZE)));
+	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 vec2 ScreenDimensions;
+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, float falloff) {
+	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, float falloff)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
+
+	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) * int(ScreenDimensions.x/TILE_SIZE)));
+
+	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, PointLights.List[i].Falloff);
+
+		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

@@ -1,7 +1,6 @@
 #version 430
 
 #define TILE_SIZE 16
-#define NUM_TILES 3600
 
 uniform mat4 P;
 uniform vec2 ScreenDimensions;
@@ -16,7 +15,7 @@ struct Frustum {
 
 layout (std430, binding = 0) buffer FrustumBuffer
 {
-	Frustum Data[3600];
+	Frustum Data[];
 } Frustums;
 
 vec4 ConvertToView(vec4 ScreenCoords)
@@ -43,31 +42,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[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);
-
-		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]);
+	//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);
+	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);
 
 
 
-	
-		Frustums.Data[gl_GlobalInvocationID.x + gl_GlobalInvocationID.y*80] = f;	
+	vec3 ViewVectors[4];
+	for(int i = 0; i < 4; i++) {
+		ViewVectors[i] = vec3(ConvertToView(ScreenCoords[i]));
 	}
+
+	vec3 EyePos = vec3(0.0, 0.0 ,0.0);
+
+	Frustum f;
+	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*int(ScreenDimensions.x/TILE_SIZE)] = 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,66 @@
+#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(RenderScene& scene)
+{
+    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()));
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+
+    //TODO: Render: Add code for more jobs than modeljobs.
+    for (auto &job : scene.ForwardJobs) {
+        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->Matrix));
+            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,18 @@
+#include "Rendering/DrawFinalPassState.h"
+
+
+DrawFinalPassState::DrawFinalPassState()
+{
+    BindFramebuffer(0);
+    Enable(GL_BLEND);
+    BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    Enable(GL_DEPTH_TEST);
+    Enable(GL_CULL_FACE);
+    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
+    Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+DrawFinalPassState::~DrawFinalPassState()
+{
+
+}

src/Engine/Rendering/DrawScenePass.cpp

@@ -14,7 +14,6 @@ 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")));
@@ -26,16 +25,16 @@ void DrawScenePass::InitializeShaderPrograms()
 void DrawScenePass::Draw(RenderScene& scene)
 {
     //glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    GLERROR("Renderer::Draw PickingPass");
+    GLERROR("DrawScenePass::Draw: Pre");
 
     DrawScenePassState state = DrawScenePassState();
+    m_BasicForwardProgram->Bind();
 
     for (auto &job : scene.ForwardJobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
         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->Matrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
@@ -57,7 +56,7 @@ void DrawScenePass::Draw(RenderScene& scene)
 
             //continue;
         }
-    }
     
-    GLERROR("DrawScene Error");
+    }
+    GLERROR("DrawScenePass::Draw: End");
 }

src/Engine/Rendering/LightCullingPass.cpp

@@ -0,0 +1,151 @@
+#include "Rendering/LightCullingPass.h"
+
+LightCullingPass::LightCullingPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+    SetSSBOSizes();
+    InitializeSSBOs();
+    InitializeShaderPrograms();
+    //GenerateNewFrustum(TODO);
+}
+
+LightCullingPass::~LightCullingPass()
+{
+
+}
+
+void LightCullingPass::GenerateNewFrustum(RenderScene& scene)
+{
+    if (scene.PointLightJobs.size() == 0)
+        return;
+
+    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(scene.Camera->ProjectionMatrix()));
+    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glDispatchCompute((int)(m_Renderer->Resolution().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->Resolution().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
+
+    GLERROR("CalculateFrustum Error: End");
+}
+
+
+void LightCullingPass::OnResolutionChange()
+{
+    SetSSBOSizes();
+}
+
+
+void LightCullingPass::SetSSBOSizes()
+{
+    m_NumberOfTiles = (int)(m_Renderer->Resolution().Width*m_Renderer->Resolution().Height)/TILE_SIZE;
+
+    //m_Frustums = new Frustum[s];
+    //m_LightGrid = new LightGrid[s];
+    //m_LightIndex = new float[s*200];
+
+    m_Frustums = new Frustum[m_NumberOfTiles];
+    m_LightGrid = new LightGrid[m_NumberOfTiles];
+    m_LightIndex = new float[m_NumberOfTiles*MAX_LIGHTS_PER_TILE];
+}
+
+void LightCullingPass::CullLights(RenderScene& scene)
+{
+    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();
+    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glUniformMatrix4fv(glGetUniformLocation(m_LightCullProgram->GetHandle(), "V"), 1, false, glm::value_ptr(scene.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(RenderScene& scene)
+{
+    m_PointLights.clear();
+
+    for(auto &job : scene.PointLightJobs) {
+        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(Frustum)*m_NumberOfTiles, 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(LightGrid)*m_NumberOfTiles, 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(float)*m_NumberOfTiles*MAX_LIGHTS_PER_TILE, 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/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/RenderSystem.cpp

@@ -106,6 +106,29 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World
     }
 }
 
+
+void RenderSystem::fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
+{
+    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;
+        }
+
+        std::shared_ptr<PointLightJob> pointLightJob = std::shared_ptr<PointLightJob>(new PointLightJob(transformC, pointlightC, m_World));
+        jobs.push_back(pointLightJob);
+    }
+}
+
 bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
 {
     if (e.Command == "SwitchCamera" && e.Value > 0) {
@@ -126,11 +149,12 @@ void RenderSystem::Update(World* world, double dt)
     //Only supports opaque geometry atm
     m_RenderFrame->Clear();
 
-    RenderScene rs;
-    rs.Camera = m_Camera;
-    rs.Viewport = Rectangle(1280, 720);
-    fillModels(rs.ForwardJobs, world);
-    m_RenderFrame->Add(rs);
+    RenderScene scene;
+    scene.Camera = m_Camera;
+    scene.Viewport = Rectangle(1280, 720);
+    fillModels(scene.ForwardJobs, world);
+    fillLight(scene.PointLightJobs, world);
+    m_RenderFrame->Add(scene);
    
 }
 

src/Engine/Rendering/Renderer.cpp

@@ -92,16 +92,22 @@ void Renderer::Update(double dt)
 void Renderer::Draw(RenderFrame& frame)
 {
     glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f);
+    
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
 
     m_PickingPass->ClearPicking();
     for (auto scene : frame.RenderScenes){
+    
         m_Camera = scene->Camera; // remove renderer camera when Editor uses the render scene cameras.
+        FillDepth(*scene);
         m_PickingPass->Draw(*scene);
+        m_LightCullingPass->GenerateNewFrustum(*scene);
+        m_LightCullingPass->FillLightList(*scene);
+        m_LightCullingPass->CullLights(*scene);
+        m_DrawFinalPass->Draw(*scene);
+        //m_DrawScenePass->Draw(rq);
 
-       
-
-        m_DrawScenePass->Draw(*scene);
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
     }
 
@@ -137,8 +143,8 @@ void Renderer::DrawScreenQuad(GLuint textureToDraw)
 
 void Renderer::InitializeTextures()
 {
-    m_ErrorTexture=ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
-    m_WhiteTexture=ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+    m_ErrorTexture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
+    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
 }
 
 void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)
@@ -149,7 +155,7 @@ void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filterin
     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, NULL);//TODO: Renderer: Fix the precision and Resolution
+    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");
 }
 
@@ -157,4 +163,23 @@ 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);
 }
+
+//Temp func
+void Renderer::FillDepth(RenderScene& scene)
+{
+    for (auto job : scene.ForwardJobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if(! modelJob) {
+            return;
+        }
+
+
+        glm::vec3 abspos = Transform::AbsolutePosition(modelJob->World, modelJob->Entity);
+        glm::vec3 worldpos = glm::vec3(scene.Camera->ViewMatrix() * glm::vec4(abspos, 1));
+        modelJob->Depth = worldpos.z;
+    }
+    scene.ForwardJobs.sort(Renderer::DepthSort);
+}

src/Game/Game.cpp

@@ -57,6 +57,8 @@ Game::Game(int argc, char* argv[])
         EntityFileParser fp(file);
         fp.MergeEntities(m_World);
     }
+    //SO MUCH TEMP PLEASE REMOVE ME OMFG VIKTOR HELP
+    m_Renderer->m_World = m_World;
 
     // Create system pipeline
     m_SystemPipeline = new SystemPipeline(m_EventBroker);