Coloring players depending on team and created a blue spawn in MovementTest

Forward+

include/Engine/Rendering/DrawBloomPass.h

@@ -0,0 +1,53 @@
+#ifndef DrawBloomPass_h__
+#define DrawBloomPass_h__
+
+#include "IRenderer.h"
+#include "DrawBloomPassState.h"
+//#include "LightCullingPass.h" Finalpass om den skall skickas in
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawBloomPass
+{
+public:
+    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
+    ~DrawBloomPass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+    void InitializeBuffers();
+    void ClearBuffer();
+
+    void FillGaussianBuffer(FrameBuffer* fb);
+
+    void Draw(GLuint texture);
+
+    //Getters
+    //Return the blurred result of the texture that was sent into draw
+    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    Texture* m_WhiteTexture;
+    Model* m_ScreenQuad;
+
+    const IRenderer* m_Renderer;
+    //const LightCullingPass* m_LightCullingPass 
+    GLuint m_iterations = 9;
+
+    GLuint m_GaussianTexture_horiz;
+    GLuint m_GaussianTexture_vert;
+
+    FrameBuffer m_GaussianFrameBuffer_horiz;
+    FrameBuffer m_GaussianFrameBuffer_vert;
+
+    ShaderProgram* m_GaussianProgram_horiz;
+    ShaderProgram* m_GaussianProgram_vert;
+
+};
+
+#endif 

include/Engine/Rendering/DrawBloomPassState.h

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

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -0,0 +1,29 @@
+#ifndef DrawColorCorrectionPass_h__
+#define DrawColorCorrectionPass_h__
+
+#include "IRenderer.h"
+#include "DrawScreenQuadPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawColorCorrectionPass
+{
+public:
+    DrawColorCorrectionPass(IRenderer* renderer);
+    ~DrawColorCorrectionPass() { }
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(GLuint sceneTexture, GLuint bloomTexture);
+private:
+    const IRenderer* m_Renderer;
+
+    ShaderProgram* m_ColorCorrectionProgram;
+
+    Model* m_ScreenQuad;
+    GLfloat m_Exposure;
+};
+
+#endif 

include/Engine/Rendering/DrawFinalPass.h

@@ -17,16 +17,27 @@ public:
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-
     void Draw(RenderScene& scene);
+    void ClearBuffer();
 
-    //Getters
+    //Return the texture that is used in later stages to apply the bloom effect
+    GLuint BloomTexture() const { return m_BloomTexture; }
+    //Return the texture with diffuse and lighting of the scene.
+    GLuint SceneTexture() const { return m_SceneTexture; }
+    FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
 
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+    void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
 
     Texture* m_WhiteTexture;
+    Texture* m_BlackTexture;
+
+    FrameBuffer m_FinalPassFrameBuffer;
+    GLuint m_BloomTexture;
+    GLuint m_SceneTexture;
+    GLuint m_DepthBuffer;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;

include/Engine/Rendering/DrawFinalPassState.h

@@ -6,7 +6,7 @@
 class DrawFinalPassState : public RenderState
 {
 public:
-    DrawFinalPassState();
+    DrawFinalPassState(GLuint frameBuffer);
     ~DrawFinalPassState();
 private:
 

include/Engine/Rendering/DrawScreenQuadPass.h

@@ -0,0 +1,28 @@
+#ifndef DrawScreenQuadPass_h__
+#define DrawScreenQuadPass_h__
+
+#include "IRenderer.h"
+#include "DrawScreenQuadPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawScreenQuadPass
+{
+public:
+    DrawScreenQuadPass(IRenderer* renderer);
+    ~DrawScreenQuadPass() { }
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(GLuint texture);
+private:
+    const IRenderer* m_Renderer;
+
+    ShaderProgram* m_DrawQuadProgram;
+
+    Model* m_ScreenQuad;
+};
+
+#endif 

include/Engine/Rendering/DrawScreenQuadPassState.h

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

include/Engine/Rendering/Renderer.h

@@ -13,12 +13,15 @@
 #include "PickingPass.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
+#include "DrawScreenQuadPass.h"
+#include "DrawBloomPass.h"
+#include "DrawColorCorrectionPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
 #include "../Core/Transform.h"
-
-#include "TextRenderer.h"
+#include "imgui/imgui.h"
+#include "TextPass.h"
 
 class Renderer : public IRenderer
 {
@@ -36,7 +39,7 @@ public:
 private:
     //----------------------Variables----------------------//
     EventBroker* m_EventBroker;
-    TextRenderer* m_TextRenderer;
+    TextPass* m_TextPass;
 
     Texture* m_ErrorTexture;
     Texture* m_WhiteTexture;
@@ -45,10 +48,15 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
+    int m_DebugTextureToDraw = 0;
+
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
     DrawFinalPass* m_DrawFinalPass;
+    DrawScreenQuadPass* m_DrawScreenQuadPass;
+    DrawBloomPass* m_DrawBloomPass;
+    DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
@@ -58,14 +66,13 @@ private:
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
-    void DrawScreenQuad(GLuint textureToDraw);
+    //void DrawScreenQuad(GLuint textureToDraw);
 
     static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
     void SortRenderJobsByDepth(RenderScene &scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
-	ShaderProgram* m_BasicForwardProgram;
-    ShaderProgram* m_DrawScreenQuadProgram;
+    ShaderProgram* m_BasicForwardProgram;
 };
 
 #endif

include/Engine/Rendering/TextPass.h

@@ -10,14 +10,16 @@
 #include "Font.h"
 #include "../Core/ResourceManager.h"
 #include "RenderQueue.h"
+#include "TextPassState.h"
+#include "FrameBuffer.h"
 
-class TextRenderer
+class TextPass
 {
 public:
-    TextRenderer();
+    TextPass();
     void Initialize();
     void Update();
-    void Draw(RenderScene& scene);
+    void Draw(RenderScene& scene, FrameBuffer& frameBuffer);
 
 private:
     void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);

include/Engine/Rendering/TextPassState.h

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

include/Engine/Rendering/Util/CommonFunctions.h

@@ -0,0 +1,17 @@
+#ifndef CommonFuntions_h__
+#define CommonFuntions_h__
+
+#include "../../Common.h"
+#include "../../OpenGL.h"
+#include "../../GLM.h"
+
+class CommonFuntions
+{
+public:
+    CommonFuntions() = delete;
+
+private:
+
+};
+
+#endif

include/Game/Systems/PlayerMovementSystem.h

@@ -3,6 +3,7 @@
 #include "Core/System.h"
 #include "Core/EPlayerSpawned.h"
 #include "Input/FirstPersonInputController.h"
+#include <imgui/imgui.h>
 
 class PlayerMovementSystem : public ImpureSystem, PureSystem
 {

include/Game/Systems/PlayerSpawnSystem.h

@@ -22,6 +22,7 @@ private:
 
     bool m_NetworkEnabled = false;
     std::vector<SpawnRequest> m_SpawnRequests;
+    std::map<int, EntityWrapper> m_PlayerEntities;
 
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);

resources/Schema/Components/Player.xml

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Player.xsd">
-	<MovementSpeed>0.2</MovementSpeed>
+	<MovementSpeed>3</MovementSpeed>
+	<CrouchSpeed>1.5</CrouchSpeed>
 </Player>

resources/Schema/Components/Player.xsd

@@ -10,6 +10,7 @@
 		<xs:complexType>
 			<xs:all>
 				<xs:element name="MovementSpeed" type="t:float" minOccurs="0"/>
+				<xs:element name="CrouchSpeed" type="t:float" minOccurs="0"/>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Entities/MovementTest.xml

@@ -13,6 +13,7 @@
         <c:Model>
           <Resource>Models/Core/UnitCube.obj</Resource>
           <Color A="1" B="0.513725519" G="0" R="1"/>
+          <Visible>false</Visible>
         </c:Model>
         <c:Transform>
           <Position X="7" Y="-0.727000058" Z="-1.22800004"/>
@@ -21,7 +22,7 @@
       </Components>
       <Children/>
     </Entity>
-    <Entity name="Spawner">
+    <Entity name="RedSpawn">
       <Components>
         <c:PlayerSpawn/>
         <c:Spawner>
@@ -93,6 +94,7 @@
         <c:Collidable/>
         <c:Model>
           <Resource>Models/Core/UnitCube.obj</Resource>
+          <Visible>false</Visible>
         </c:Model>
         <c:Transform>
           <Position X="6.32800007" Y="0.807000041" Z="-2.2750001"/>
@@ -107,6 +109,7 @@
         <c:Collidable/>
         <c:Model>
           <Resource>Models/Core/UnitCube.obj</Resource>
+          <Visible>false</Visible>
         </c:Model>
         <c:Transform>
           <Position X="9.11900043" Y="0.5" Z="-2.10900021"/>
@@ -121,6 +124,7 @@
         <c:Collidable/>
         <c:Model>
           <Resource>Models/Core/UnitCube.obj</Resource>
+          <Visible>false</Visible>
         </c:Model>
         <c:Transform>
           <Position X="13.2370005" Y="1.28600001" Z="-1.71700013"/>
@@ -129,6 +133,51 @@
       </Components>
       <Children/>
     </Entity>
+    <Entity name="BlueSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="0.300000012" Y="0.0270000007" Z="6.67400026"/>
+          <Orientation X="0" Y="3.20700026" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Model>
+              <Resource>Models/Assault.obj</Resource>
+              <Color A="1" B="1" G="0.254901975" R="0"/>
+            </c:Model>
+            <c:Transform>
+              <Position X="0.800000012" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Model>
+              <Resource>Models/Assault.obj</Resource>
+              <Color A="1" B="1" G="0.254901975" R="0"/>
+            </c:Model>
+            <c:Transform>
+              <Position X="-0.600000024" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/Player.xml

@@ -7,9 +7,12 @@
       <Size X="1" Y="1.60000002" Z="1"/>
     </c:AABB>
     <c:Collidable/>
-    <c:Physics/>
+    <c:Model/>
+    <c:Physics>
+      <Velocity X="8.33307467e-09" Y="0" Z="9.82836834e-09"/>
+    </c:Physics>
     <c:Player>
-      <MovementSpeed>3</MovementSpeed>
+      <MovementSpeed>5</MovementSpeed>
     </c:Player>
     <c:Team>
       <Team>
@@ -17,7 +20,8 @@
       </Team>
     </c:Team>
     <c:Transform>
-      <Position X="0" Y="0" Z="7.38143063"/>
+      <Position X="2.84928203" Y="0.0264999866" Z="7.31610918"/>
+      <Orientation X="0" Y="2.14675093" Z="0"/>
     </c:Transform>
   </Components>
 
@@ -27,19 +31,19 @@
         <c:Camera/>
         <c:Transform>
           <Position X="0" Y="1.37700009" Z="0"/>
-          <Orientation X="6.28300047" Y="0" Z="0"/>
+          <Orientation X="0.921535373" Y="0" Z="0"/>
         </c:Transform>
       </Components>
       <Children>
         <Entity name="PlayerName">
           <Components>
             <c:Text>
-              <Content></Content>
               <Resource>Fonts/DroidSans.ttf,100</Resource>
               <Color A="1" B="0" G="1" R="0"/>
+              <Visible>false</Visible>
             </c:Text>
             <c:Transform>
-              <Position X="0" Y="0.0263664704" Z="-0.447885782"/>
+              <Position X="0" Y="0.247910097" Z="-0.447844714"/>
               <Scale X="0.100000001" Y="0.113000005" Z="0.5"/>
               <Orientation X="0" Y="3.14199996" Z="0"/>
             </c:Transform>
@@ -85,6 +89,33 @@
       </Components>
       <Children/>
     </Entity>
+    <Entity name="AABBStanding">
+      <Components>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Color A="0.427450985" B="1" G="1" R="1"/>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0.772000015" Z="0"/>
+          <Scale X="1" Y="1.60000002" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="AABBCrouching">
+      <Components>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Color A="0.745098054" B="1" G="0" R="1"/>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0.772000015" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
   </Children>
 
 </Entity>

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -0,0 +1,32 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D SceneTexture;
+layout (binding = 1) uniform sampler2D BloomTexture;
+uniform float Exposure;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+void main()
+{
+	const float gamma = 2.2;
+	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
+	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
+	hdrColor += bloomColor;
+
+	//Toon mapping thingy
+	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
+
+	//gamme correction
+	result = pow(result, vec3(1.0 / gamma));
+
+	fragmentColor = vec4(result, 1.0);
+	//fragmentColor = hdrColor;
+	//fragmentColor = bloomColor;
+	//fragmentColor = vec4(1,0.5,0.7,1);
+}
+
+

resources/Shaders/DrawColorCorrection.vert.glsl

@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}

resources/Shaders/ForwardPlus.frag.glsl

@@ -5,7 +5,8 @@ uniform mat4 V;
 uniform mat4 P;
 uniform vec4 Color;
 uniform vec2 ScreenDimensions;
-uniform sampler2D texture0;
+layout (binding = 0) uniform sampler2D DiffuseTexture;
+layout (binding = 1) uniform sampler2D GlowMap;
 
 #define TILE_SIZE 16
 
@@ -48,7 +49,8 @@ in VertexData{
 	vec4 DiffuseColor;
 }Input;
 
-out vec4 fragmentColor;
+out vec4 sceneColor;
+out vec4 bloomColor;
 
 vec4 scene_ambient = vec4(0.3,0.3,0.3,1);
 
@@ -99,9 +101,10 @@ LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensi
 
 void main()
 {
-	vec4 texel = texture2D(texture0, Input.TextureCoordinate);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
+	vec4 glowTexel = texture2D(GlowMap, Input.TextureCoordinate);
 	vec4 position = V * M * vec4(Input.Position, 1.0); 
-	vec4 normal = V  * vec4(Input.Normal, 0.0);
+	vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
 	vec4 viewVec = normalize(-position); 
 
 	vec2 tilePos;
@@ -120,30 +123,42 @@ void main()
 		int l = int(LightIndex[i]);
 		LightSource light = LightSources.List[l];
 
-		LightResult result;
+		LightResult light_result;
+		//These if statements should be removed.
 		if(light.Type == 1) { // point
-			result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
 		} else if (light.Type == 2) { //Directional
-			result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
 		}
-		totalLighting.Diffuse += result.Diffuse;
-		totalLighting.Specular += result.Specular;
+		totalLighting.Diffuse += light_result.Diffuse;
+		totalLighting.Specular += light_result.Specular;
 	}
 
-
-	//fragmentColor += Input.DiffuseColor;
-	fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
-	//fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
-	//fragmentColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
-	//fragmentColor = texel * Input.DiffuseColor * Color;
-	//fragmentColor += vec4(currentTile/3600.f, 0, 0, 1);
+	//sceneColor += Input.DiffuseColor;
+	vec4 color_result = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color;
+	//bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//These if statements should be removed if they are slow.
+	color_result += glowTexel;
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	/*
+	if(color_result.x > 1 || color_result.y > 1 || color_result.z > 1) {
+		bloomColor = vec4(color_result.xyz, 1.0);
+	} else {
+		bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
+	} */
+	
+	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * diffuseTexel * Color;
+	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
+	//sceneColor = diffuseTexel * Input.DiffuseColor * Color;
+	//sceneColor += vec4(currentTile/3600.f, 0, 0, 1);
 
 	//Tiled Debug Code
 	/*
 	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
-		fragmentColor += vec4(0.5, 0, 0, 0);
+		sceneColor += vec4(0.5, 0, 0, 0);
 	} else {
-		fragmentColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
 	}
 	*/
 }

resources/Shaders/Gaussian_horiz.frag.glsl

@@ -0,0 +1,23 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D Texture;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+
+void main()
+{
+	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
+	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
+
+	for(int i = 1; i < 5; ++i) {
+	    result += texture(Texture, Input.TextureCoordinate + vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+	    result += texture(Texture, Input.TextureCoordinate - vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+	}
+	fragmentColor = vec4(result, 1.0);
+}

resources/Shaders/Gaussian_horiz.vert.glsl

@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}

resources/Shaders/Gaussian_vert.frag.glsl

@@ -0,0 +1,23 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D Texture;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+
+void main()
+{
+	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
+	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
+
+    for(int i = 1; i < 5; ++i) {
+        result += texture(Texture, Input.TextureCoordinate + vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+        result += texture(Texture, Input.TextureCoordinate - vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+    }
+    fragmentColor = vec4(result, 1.0);
+}

resources/Shaders/Gaussian_vert.vert.glsl

@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}

resources/Shaders/Text.frag.glsl

@@ -3,10 +3,15 @@ in vec2 TexCoords;
 out vec4 color;
 
 uniform sampler2D text;
-uniform vec3 textColor;
+uniform vec4 textColor;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
 
 void main()
 {    
     vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r);
-    color = vec4(textColor, 1.0) * sampled;
+    vec4 color_result = textColor * sampled;
+    sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0) * sampled;
 } 

src/Engine/Collision/CollisionSystem.cpp

@@ -31,7 +31,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         }
         if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             (glm::vec3&)cTransform["Position"] += resolutionVector;
-            cPhysics["Velocity"] = glm::vec3(0, 0, 0);
+            ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
         }
     }
 

src/Engine/Input/FirstPersonInputController.cpp

@@ -1,2 +0,0 @@
-#include "Input/FirstPersonInputController.h"
-

src/Engine/Rendering/DrawBloomPass.cpp

@@ -0,0 +1,134 @@
+#include "Rendering/DrawBloomPass.h"
+
+DrawBloomPass::DrawBloomPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+
+    InitializeTextures();
+    InitializeBuffers();
+    InitializeShaderPrograms();
+}
+
+void DrawBloomPass::InitializeTextures()
+{
+    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+}
+
+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")));
+    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
+    m_GaussianProgram_horiz->Compile();
+    m_GaussianProgram_horiz->Link();
+
+    m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
+    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
+    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
+    m_GaussianProgram_vert->Compile();
+    m_GaussianProgram_vert->Link();
+}
+
+
+void DrawBloomPass::InitializeBuffers()
+{
+    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+
+    m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_horiz.Generate();
+
+    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+
+    m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_vert.Generate();
+}
+
+
+void DrawBloomPass::ClearBuffer()
+{
+    m_GaussianFrameBuffer_horiz.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_GaussianFrameBuffer_horiz.Unbind();
+    m_GaussianFrameBuffer_vert.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_GaussianFrameBuffer_vert.Unbind();
+}
+
+void DrawBloomPass::Draw(GLuint texture)
+{
+    GLERROR("DrawBloomPass::Draw: Pre");
+
+    DrawBloomPassState state;
+
+    GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
+    GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
+
+
+    //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
+    m_GaussianFrameBuffer_horiz.Bind();
+    m_GaussianProgram_horiz->Bind();
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+    //Iterate some times to make it more gaussian.
+    for (int i = 1; i < m_iterations; i++) {
+        //Vertical pass
+        m_GaussianFrameBuffer_vert.Bind();
+        m_GaussianProgram_vert->Bind();
+
+        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
+
+        glBindVertexArray(m_ScreenQuad->VAO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+        //horizontal pass
+
+        m_GaussianFrameBuffer_horiz.Bind();
+        m_GaussianProgram_horiz->Bind();
+
+        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_vert);
+
+        glBindVertexArray(m_ScreenQuad->VAO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    }
+
+    //final vertical gaussian after the iterations are done
+
+    m_GaussianFrameBuffer_vert.Bind();
+    m_GaussianProgram_vert->Bind();
+
+    glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+    GLERROR("DrawBloomPass::Draw: END");
+}
+
+void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("Texture initialization failed");
+}

src/Engine/Rendering/DrawBloomPassState.cpp

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

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -0,0 +1,41 @@
+#include "Rendering/DrawColorCorrectionPass.h"
+
+DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_Exposure = 1; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+
+    InitializeShaderPrograms();
+}
+
+void DrawColorCorrectionPass::InitializeShaderPrograms()
+{
+    m_ColorCorrectionProgram = ResourceManager::Load<ShaderProgram>("#ColorCorrectionProgram");
+    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawColorCorrection.vert.glsl")));
+    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawColorCorrection.frag.glsl")));
+    m_ColorCorrectionProgram->Compile();
+    m_ColorCorrectionProgram->Link();
+}
+
+void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
+{
+    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    GLERROR("DrawScreenQuadPass::Draw: Pre");
+
+    DrawScreenQuadPassState state = DrawScreenQuadPassState();
+    m_ColorCorrectionProgram->Bind();
+    glClear(GL_COLOR_BUFFER_BIT);
+    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, sceneTexture);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, bloomTexture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+}

src/Engine/Rendering/DrawFinalPass.cpp

@@ -6,11 +6,31 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
     m_LightCullingPass = lightCullingPass;
     InitializeTextures();
     InitializeShaderPrograms();
+    InitializeFrameBuffers();
 }
 
 void DrawFinalPass::InitializeTextures()
 {
     m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+    m_BlackTexture = ResourceManager::Load<Texture>("Textures/Core/Black.png");
+}
+
+void DrawFinalPass::InitializeFrameBuffers()
+{
+    glGenRenderbuffers(1, &m_DepthBuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4);
+    
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_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)));
+    m_FinalPassFrameBuffer.Generate();
+
 }
 
 void DrawFinalPass::InitializeShaderPrograms()
@@ -19,6 +39,8 @@ void DrawFinalPass::InitializeShaderPrograms()
     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->BindFragDataLocation(0, "sceneColor");
+    m_ForwardPlusProgram->BindFragDataLocation(1, "bloomColor");
     m_ForwardPlusProgram->Link();
 }
 
@@ -26,7 +48,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("DrawFinalPass::Draw: Pre");
 
-    DrawFinalPassState state;
+    DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
 
     m_ForwardPlusProgram->Bind();
     GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
@@ -51,13 +73,20 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
 
+            glActiveTexture(GL_TEXTURE0);
             if(modelJob->DiffuseTexture != nullptr) {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
             } else {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+
+            /*if(modelJob->GlowMap != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+            }*/
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -66,6 +95,42 @@ void DrawFinalPass::Draw(RenderScene& scene)
             continue;
         }
     }
+    m_FinalPassFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
-
+    delete state;
+}
+
+
+void DrawFinalPass::ClearBuffer()
+{
+    m_FinalPassFrameBuffer.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_FinalPassFrameBuffer.Unbind();
+}
+
+void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("Texture initialization failed");
+}
+
+void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, dimensions.x, dimensions.y);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, dimensions.x, dimensions.y, format, type, texture);
+    glGenerateMipmap(GL_TEXTURE_2D);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    GLERROR("MipMap Texture initialization failed");
 }

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -1,14 +1,14 @@
 #include "Rendering/DrawFinalPassState.h"
 
 
-DrawFinalPassState::DrawFinalPassState()
+DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
 {
-    BindFramebuffer(0);
+    BindFramebuffer(frameBuffer);
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
+    ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
 }
 
 DrawFinalPassState::~DrawFinalPassState()

src/Engine/Rendering/DrawScreenQuadPass.cpp

@@ -0,0 +1,37 @@
+#include "Rendering/DrawScreenQuadPass.h"
+
+DrawScreenQuadPass::DrawScreenQuadPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+
+    InitializeShaderPrograms();
+}
+
+void DrawScreenQuadPass::InitializeShaderPrograms()
+{
+    m_DrawQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
+    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
+    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
+    m_DrawQuadProgram->Compile();
+    m_DrawQuadProgram->Link();
+}
+
+void DrawScreenQuadPass::Draw(GLuint texture)
+{
+    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    GLERROR("DrawScreenQuadPass::Draw: Pre");
+
+    DrawScreenQuadPassState state = DrawScreenQuadPassState();
+    m_DrawQuadProgram->Bind();
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+}

src/Engine/Rendering/DrawScreenQuadPassState.cpp

@@ -0,0 +1,18 @@
+#include "Rendering/DrawScreenQuadPassState.h"
+
+
+DrawScreenQuadPassState::DrawScreenQuadPassState()
+{
+    GLERROR("---");
+    BindFramebuffer(0);
+    GLERROR("---");
+    Disable(GL_DEPTH_TEST);
+    Disable(GL_CULL_FACE);
+    Disable(GL_BLEND);
+    ClearColor(glm::vec4(0.f));
+}
+
+DrawScreenQuadPassState::~DrawScreenQuadPassState()
+{
+
+}

src/Engine/Rendering/FrameBuffer.cpp

@@ -55,8 +55,9 @@ void FrameBuffer::Generate()
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
             if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 ||
+                (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 ||
                 (*it)->m_Attachment != GL_DEPTH_ATTACHMENT ||
-                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT)
+                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta
             {
                 LOG_ERROR("RenderBuffer Attachment not valid.");
             }
@@ -69,10 +70,8 @@ void FrameBuffer::Generate()
         }
     }
         
-   
-    
     GLenum* bufferTextures = &attachments[0];
-    glDrawBuffers(1, bufferTextures);
+    glDrawBuffers(attachments.size(), bufferTextures);
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
         LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);

src/Engine/Rendering/PickingPass.cpp

@@ -54,52 +54,49 @@ void PickingPass::Draw(RenderScene& scene)
     if (scene.ClearDepth) {
         glClear(GL_DEPTH_BUFFER_BIT);
     }
+    m_Camera = scene.Camera;
 
-        m_Camera = scene.Camera;
+    for (auto &job : scene.ForwardJobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
-        for (auto &job : scene.ForwardJobs) {
-            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if (modelJob) {
+            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
-            if (modelJob) {
-                int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+            PickingInfo pickInfo;
+            pickInfo.Entity = modelJob->Entity;
+            pickInfo.World = modelJob->World;
+            pickInfo.Camera = scene.Camera;
 
-                PickingInfo pickInfo;
-                pickInfo.Entity = modelJob->Entity;
-                pickInfo.World = modelJob->World;
-                pickInfo.Camera = scene.Camera;
-
-                auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
-                if (color != m_EntityColors.end()) {
-                    pickColor[0] = color->second[0];
-                    pickColor[1] = color->second[1];
-                } else {
-                    m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
-                    if (m_ColorCounter[0] > 255) {
-                        m_ColorCounter[0] = 0;
+            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+            if (color != m_EntityColors.end()) {
+                pickColor[0] = color->second[0];
+                pickColor[1] = color->second[1];
+            } else {
+                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+                if (m_ColorCounter[0] > 255) {
+                    m_ColorCounter[0] = 0;
                         m_ColorCounter[1]++;
-                    } else {
+                } else {
                         m_ColorCounter[0]++;
-                    }
                 }
-
-                m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
-
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-                glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
-
-                glBindVertexArray(modelJob->Model->VAO);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-                glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
             }
+
+            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
         }
-    
+    }
     
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");
 
-
     delete state;
 }
 

src/Engine/Rendering/Renderer.cpp

@@ -9,8 +9,8 @@ void Renderer::Initialize()
 	glfwSwapInterval(m_VSYNC);
 	InitializeShaders();
     InitializeTextures();
-    m_TextRenderer = new TextRenderer();
-    m_TextRenderer->Initialize();
+    m_TextPass = new TextPass();
+    m_TextPass->Initialize();
 
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
@@ -63,12 +63,6 @@ void Renderer::InitializeWindow()
 void Renderer::InitializeShaders()
 {
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#m_BasicForwardProgram");
-
-    m_DrawScreenQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
-    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
-    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
-    m_DrawScreenQuadProgram->Compile();
-    m_DrawScreenQuadProgram->Link();
 }
 
 void Renderer::InputUpdate(double dt)
@@ -80,16 +74,22 @@ void Renderer::Update(double dt)
 {
     m_EventBroker->Process<Renderer>();
     InputUpdate(dt);
-    m_TextRenderer->Update();
+    m_TextPass->Update();
     m_ImGuiRenderPass->Update(dt);
 }
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f);
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking");
+    //clear buffer 0
+    glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+    //Clear other buffers
     m_PickingPass->ClearPicking();
+    m_DrawFinalPass->ClearBuffer();
+    m_DrawBloomPass->ClearBuffer();
+
     for (auto scene : frame.RenderScenes){
         
         SortRenderJobsByDepth(*scene);
@@ -98,14 +98,28 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
-        //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
 
-        m_TextRenderer->Draw(*scene);
+        m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
 
     }
-    
+    m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
+    if(m_DebugTextureToDraw == 0) {
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture());
+    }
+    if (m_DebugTextureToDraw == 1) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
+    }
+    if (m_DebugTextureToDraw == 2) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture());
+    }
+    if (m_DebugTextureToDraw == 3) {
+        m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
+    }
+    if (m_DebugTextureToDraw == 4) {
+        m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
+    }
 
     m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
@@ -116,27 +130,6 @@ PickData Renderer::Pick(glm::vec2 screenCoord)
     return m_PickingPass->Pick(screenCoord);
 }
 
-void Renderer::DrawScreenQuad(GLuint textureToDraw)
-{
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_CULL_FACE);
-
-    glClearColor(0.f, 0.f, 0.f, 1.f);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-
-    m_DrawScreenQuadProgram->Bind();
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, textureToDraw);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-}
-
 void Renderer::InitializeTextures()
 {
     m_ErrorTexture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
@@ -167,4 +160,7 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
+    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
+    m_DrawBloomPass = new DrawBloomPass(this);
+    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
 }

src/Engine/Rendering/TextPass.cpp

@@ -1,11 +1,11 @@
-#include "Rendering/TextRenderer.h"
+#include "Rendering/TextPass.h"
 
-TextRenderer::TextRenderer()
+TextPass::TextPass()
 {
 
 }
 
-void TextRenderer::Initialize()
+void TextPass::Initialize()
 {
     glGenVertexArrays(1, &VAO);
     glGenBuffers(1, &VBO);
@@ -21,16 +21,20 @@ void TextRenderer::Initialize()
     m_TextProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Text.vert.glsl")));
     m_TextProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Text.frag.glsl")));
     m_TextProgram->Compile();
+    m_TextProgram->BindFragDataLocation(0, "sceneColor");
+    m_TextProgram->BindFragDataLocation(1, "bloomColor");
     m_TextProgram->Link();
 }
 
-void TextRenderer::Update()
+void TextPass::Update()
 {
 
 }
 
-void TextRenderer::Draw(RenderScene& scene)
+void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer)
 {
+    GLERROR("Derp1");
+    TextPassState* state = new TextPassState(frameBuffer.GetHandle());
     for (auto &job : scene.TextJobs) {
         auto textJob = std::dynamic_pointer_cast<TextJob>(job);
         if (textJob) {
@@ -38,13 +42,15 @@ void TextRenderer::Draw(RenderScene& scene)
             renderText(textJob->Content, textJob->Resource, textJob->Alignment, textJob->Color, textJob->Matrix, scene.Camera->ProjectionMatrix(), scene.Camera->ViewMatrix());
         }
     }
+    GLERROR("Derp2");
+    delete state;
 }
 
-void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix)
+void TextPass::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix)
 {
     GLfloat penX = 0;
     GLfloat penY = 0;
-    float scale = 1.0/font->FontSize;
+    GLfloat scale = 1.0/font->FontSize;
 
     GLfloat stringWidth = 0.f;
 
@@ -61,13 +67,10 @@ void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEn
         penX = 0;
     }	
     
-    glEnable(GL_BLEND);
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_DEPTH_TEST);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    
 
     m_TextProgram->Bind();
-    glUniform3f(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), color.x, color.y, color.z);
+    glUniform4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), 1, glm::value_ptr(color));
     glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
     glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
     glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix));

src/Engine/Rendering/TextPassState.cpp

@@ -0,0 +1,16 @@
+#include "Rendering/TextPassState.h"
+
+
+TextPassState::TextPassState(GLuint frameBuffer)
+{
+    BindFramebuffer(frameBuffer);
+    glEnable(GL_BLEND);
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+TextPassState::~TextPassState()
+{
+
+}

src/Engine/Rendering/Util/CommonFunctions.cpp

@@ -0,0 +1,2 @@
+#include "Rendering/Util/CommonFunctions.h"
+

src/Game/Systems/CapturePointSystem.cpp

@@ -66,6 +66,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
     nextPossibleCapturePoint["Blue"] = -1;
     for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
     {
+        if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) {
+            continue;
+        }
         ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
         if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint == 0) {
             nextPossibleCapturePoint["Red"] = i + 1;
@@ -76,6 +79,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
     }
     for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--)
     {
+        if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) {
+            continue;
+        }
         ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
         if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint != 0) {
             nextPossibleCapturePoint["Red"] = i - 1;

src/Game/Systems/PlayerMovementSystem.cpp

@@ -36,14 +36,55 @@ void PlayerMovementSystem::Update(double dt)
         glm::vec3& ori = cTransform["Orientation"];
         ori.y += controller->Rotation().y;
 
-        glm::vec3& pos = cTransform["Position"];
-        pos += controller->Movement() * glm::inverse(glm::quat(ori)) * (float)player["Player"]["MovementSpeed"] * (float)dt;
-
         if (player.HasComponent("Physics")) {
-            if (controller->Jumping()) {
-                glm::vec3& velocity = player["Physics"]["Velocity"];
-                velocity.y += 10.f;
+            ComponentWrapper cPhysics = player["Physics"];
+
+            glm::vec3 wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
+            float wishSpeed;
+            if (controller->Crouching()) {
+                wishSpeed = player["Player"]["CrouchSpeed"];
+            } else {
+                wishSpeed = player["Player"]["MovementSpeed"];
             }
+            glm::vec3& velocity = cPhysics["Velocity"];
+            ImGui::Text("velocity: (%f, %f, %f)", velocity.x, velocity.y, velocity.z);
+            glm::vec3 groundVelocity(0.f, 0.f, 0.f);
+            groundVelocity.x = glm::dot(velocity, glm::vec3(1.f, 0.f, 0.f));
+            groundVelocity.z = glm::dot(velocity, glm::vec3(0.f, 0.f, 1.f));
+            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(wishDirection));
+            ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
+            float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
+            float addSpeed = wishSpeed - currentSpeedProj;
+            ImGui::Text("currentSpeedProj: %f", currentSpeedProj);
+            ImGui::Text("wishSpeed: %f", wishSpeed);
+            ImGui::Text("addSpeed: %f", addSpeed);
+
+            if (addSpeed > 0) {
+                static float accel = 15.f;
+                ImGui::InputFloat("accel", &accel);
+                static float airAccel = 0.5f;
+                ImGui::InputFloat("airAccel", &airAccel);
+                float actualAccel = (velocity.y != 0) ? airAccel : accel;
+                static float surfaceFriction = 5.f;
+                ImGui::InputFloat("surfaceFriction", &surfaceFriction);
+                float accelerationSpeed = actualAccel * (float)dt * wishSpeed * surfaceFriction;
+                accelerationSpeed = glm::min(accelerationSpeed, addSpeed);
+                velocity += accelerationSpeed * wishDirection;
+                ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
+            }
+
+            if (controller->Jumping() && !controller->Crouching() && velocity.y == 0.f) {
+                velocity.y += 4.f;
+            }
+
+            //if (player.HasComponent("AABB")) {
+            //    glm::vec3& size = player["AABB"]["Size"];
+            //    if (controller->Crouching()) {
+            //        size = glm::vec3(1.f, 1.f, 1.f);
+            //    } else {
+            //        size = glm::vec3(1.f, 1.6f, 1.f);
+            //    }
+            //}
         }
         
         controller->Reset();
@@ -56,9 +97,24 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
     if (!entity.HasComponent("Physics")) {
         return;
     }
-    ComponentWrapper& cPhysics = entity["Physics"];
 
+    ComponentWrapper& cPhysics = entity["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
+
+    // Ground friction
+    float speed = glm::length(velocity);
+    static float groundFriction = 7.f;
+    ImGui::InputFloat("groundFriction", &groundFriction);
+    static float airFriction = 0.f;
+    ImGui::InputFloat("airFriction", &airFriction);
+    float friction = (velocity.y != 0) ? airFriction : groundFriction;
+    if (speed > 0) {
+        float drop = speed * friction * (float)dt;
+        float multiplier = glm::max(speed - drop, 0.f) / speed;
+        velocity.x *= multiplier;
+        velocity.z *= multiplier;
+    }
+
     if (cPhysics["Gravity"]) {
         velocity.y -= 9.82f * (float)dt;
     }

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -72,6 +72,15 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
     // When a player is actually spawned (since the actual spawning is handled on the server)
 
+    // Check if a player already exists
+    if (m_PlayerEntities.count(e.PlayerID) != 0) {
+        // TODO: Disallow infinite respawning here
+        m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+    }
+
+    // Store the player for future reference
+    m_PlayerEntities[e.PlayerID] = e.Player;
+
     // Set the camera to the correct entity
     EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera");
     if (cameraEntity.Valid()) {
@@ -80,5 +89,23 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
         m_EventBroker->Publish(e);
     }
 
+    // HACK: Set the player model color to team color
+    EntityWrapper playerModel = e.Player.FirstChildByName("PlayerModel");
+    if (playerModel.Valid() && e.Player.HasComponent("Team")) {
+        ComponentWrapper cTeam = e.Player["Team"];
+        ComponentWrapper cModel = playerModel["Model"];
+        if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Red")) {
+            cModel["Color"] = glm::vec3(1.f, 0.f, 0.f);
+        } else if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Blue")) {
+            cModel["Color"] = glm::vec3(0.f, 0.25f, 1.f);
+        }
+    }
+
+    // TODO: Set the player name to whatever
+    //EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
+    //if (playerName.Valid()) {
+    //    playerName["Text"]["Content"] = ???;
+    //}
+
     return true;
 }