Fixed draw final pass with shided objects having to many if-statments.

Shields is working with transparancy

Player cameras should have nearclip fater away and far clip nearer.

Defaultconfig push

include/Engine/Rendering/DrawColorCorrectionPass.h

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

include/Engine/Rendering/DrawFinalPass.h

@@ -15,7 +15,7 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, GLuint* depthBuffer);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -26,22 +26,17 @@ public:
 
     //Return the texture that is used in later stages to apply the bloom effect
     GLuint BloomTexture() const { return m_BloomTexture; }
-    GLuint BloomTextureLowRes() const { return m_BloomTextureLowRes; }
     //Return the texture with diffuse and lighting of the scene.
     GLuint SceneTexture() const { return m_SceneTexture; }
-    GLuint SceneTextureLowRes() const { return m_SceneTextureLowRes; }
     //Return the framebuffer used in the scene rendering stage.
     FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
-    FrameBuffer* FinalPassFrameBufferLowRes() { return &m_FinalPassFrameBufferLowRes; }
 
 private:
     void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
     void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
-    void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+	void DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
-    void DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawToDepthStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
-
-	void MergeLayers();
 
     void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
     void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
@@ -55,17 +50,12 @@ private:
     Texture* m_GreyTexture;
     Texture* m_ErrorTexture;
 
-	Model* m_ScreenQuad;
-
-	FrameBuffer m_MergeFrameBuffer;
     FrameBuffer m_FinalPassFrameBuffer;
-    FrameBuffer m_FinalPassFrameBufferLowRes;
+	FrameBuffer m_ShieldDepthFrameBuffer;
     GLuint m_BloomTexture;
     GLuint m_SceneTexture;
-    GLuint m_BloomTextureLowRes;
+    GLuint m_DepthBuffer;
-    GLuint m_SceneTextureLowRes;
+	GLuint m_ShieldBuffer;
-    GLuint* m_DepthBuffer;
-    GLuint m_DepthBufferLowRes;
     GLuint m_CubeMapTexture;
 
     //maqke this component based i guess?
@@ -76,23 +66,32 @@ private:
     const CubeMapPass* m_CubeMapPass;
 	const SSAOPass* m_SSAOPass;
 
-	ShaderProgram* m_MergeProgram;
-
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
     ShaderProgram* m_SpriteProgram;
 	ShaderProgram* m_ForwardPlusSplatMapProgram;
-    ShaderProgram* m_ShieldToStencilProgram;
+    ShaderProgram* m_FillDepthStencilBufferProgram;
-    ShaderProgram* m_FillDepthBufferProgram;
+
+	ShaderProgram* m_ForwardPlusShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapShieldCheckProgram;
+	ShaderProgram* m_SpriteShieldCheckProgram;
+	ShaderProgram* m_ForwardPlusSplatMapShieldCheckProgram;
+
 
 
 	ShaderProgram* m_ForwardPlusSkinnedProgram;
 	ShaderProgram* m_ExplosionEffectSkinnedProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapSkinnedProgram;
 	ShaderProgram* m_ForwardPlusSplatMapSkinnedProgram;
-    ShaderProgram* m_ShieldToStencilSkinnedProgram;
+    ShaderProgram* m_FillDepthStencilBufferSkinnedProgram;
-    ShaderProgram* m_FillDepthBufferSkinnedProgram;
+
+	ShaderProgram* m_ForwardPlusSkinnedShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSkinnedShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapSkinnedShieldCheckProgram;
+	ShaderProgram* m_ForwardPlusSplatMapSkinnedShieldCheckProgram;
+	ShaderProgram* m_FillDepthBufferSkinnedShieldCheckProgram;
 };
 
 #endif 

include/Engine/Rendering/ExplosionEffectJob.h

@@ -15,8 +15,8 @@
 
 struct ExplosionEffectJob : ModelJob
 {
-    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
+    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
-        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage)
+        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded)
     {
         ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
         TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];

include/Engine/Rendering/ModelJob.h

@@ -18,7 +18,7 @@
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
         : RenderJob()
     {
         Model = model;
@@ -117,7 +117,7 @@ struct ModelJob : RenderJob
 
         FillColor = fillColor;
         FillPercentage = fillPercentage;
-
+		IsShielded = isShielded;
 
         if (model->IsSkinned()) {
             Skeleton = Model->m_RawModel->m_Skeleton;
@@ -181,7 +181,7 @@ struct ModelJob : RenderJob
 
     glm::vec4 FillColor = glm::vec4(0);
     float FillPercentage = 0.0;
-
+	bool IsShielded;
     void CalculateHash() override
     {
         Hash = ShaderID << 20 + ModelID << 10 + TextureID;

include/Engine/Rendering/RenderQueue.h

@@ -24,7 +24,6 @@ struct RenderScene
         std::list<std::shared_ptr<RenderJob>> OpaqueObjects;
         std::list<std::shared_ptr<RenderJob>> TransparentObjects;
         std::list<std::shared_ptr<RenderJob>> OpaqueShieldedObjects;
-        std::list<std::shared_ptr<RenderJob>> TransparentShieldedObjects;
         std::list<std::shared_ptr<RenderJob>> ShieldObjects;
         std::list<std::shared_ptr<RenderJob>> SpriteJob;
         std::list<std::shared_ptr<RenderJob>> PointLight;
@@ -41,7 +40,6 @@ struct RenderScene
         Jobs.OpaqueObjects.clear();
         Jobs.TransparentObjects.clear();
         Jobs.OpaqueShieldedObjects.clear();
-        Jobs.TransparentShieldedObjects.clear();
         Jobs.ShieldObjects.clear();
         Jobs.SpriteJob.clear();
         Jobs.DirectionalLight.clear();

include/Game/Systems/PlayerSpawnSystem.h

@@ -14,8 +14,6 @@ public:
 
     virtual void Update(double dt) override;
 
-    static void SetRespawnTime(float respawnTime) { m_RespawnTime = respawnTime; };
-
 private:
     struct SpawnRequest
     {
@@ -31,8 +29,8 @@ private:
     //EntityWrapper ID -> Player ID.
     std::map<EntityID, int> m_PlayerIDs;
 
-    static float m_RespawnTime;
+    float m_ForcedRespawnTime;
-    float m_Timer;
+    bool m_DbgConfigForceRespawn;
 
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
     bool OnInputCommand(Events::InputCommand& e);

resources/DefaultConfig.ini

@@ -68,5 +68,17 @@ Contrast=1.5
 Intensity=1.0
 NumSamples=24
 NumTurns=17
-NumIterations=13
+NumIterations=9
 TextureQuality=0
+
+[GLOW]
+Quality=3;
+
+[GLOW1]
+NumIterations=5
+
+[GLOW2]
+NumIterations=9
+
+[GLOW3]
+NumIterations=13

resources/Schema/Components.xsd

@@ -46,6 +46,8 @@
 	<xs:include schemaLocation="Components/Page.xsd"/>
 	<xs:include schemaLocation="Components/SpriteIndicator.xsd"/>
 	<xs:include schemaLocation="Components/Button.xsd"/>
+	<xs:include schemaLocation="Components/DoubleJump.xsd"/>
 	<xs:include schemaLocation="Components/WeaponAttachment.xsd"/>
 	<xs:include schemaLocation="Components/DefenderWeapon.xsd"/>
+	<xs:include schemaLocation="Components/CapturePointGameMode.xsd"/>
 </xs:schema>

resources/Schema/Components/CapturePointGameMode.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<CapturePointGameMode xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="CapturePointGameMode.xsd">
+	<RespawnTime>0.0</RespawnTime>
+	<MaxRespawnTime>8.0</MaxRespawnTime>
+</CapturePointGameMode>

resources/Schema/Components/CapturePointGameMode.xsd

@@ -0,0 +1,18 @@
+<?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="CapturePointGameMode">
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="RespawnTime" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>The time since the last respawn wave. Players will be spawned when this reaches MaxRespawnTime.</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="MaxRespawnTime" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>Players will be spawned when RespawnTime reaches this.</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/DoubleJump.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<DoubleJump xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="DoubleJump.xsd">
+	<DoubleJumpSpeed>4.0</DoubleJumpSpeed>
+</DoubleJump>

resources/Schema/Components/DoubleJump.xsd

@@ -0,0 +1,16 @@
+<?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="DoubleJump">
+		<xs:annotation><xs:documentation>Enables a Player to double jump.</xs:documentation></xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="DoubleJumpSpeed" type="t:float" minOccurs="0">
+					<xs:annotation><xs:documentation>Vertical velocity set on double jump.</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/Player.xml

@@ -2,6 +2,7 @@
 <Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Player.xsd">
 	<MovementSpeed>3</MovementSpeed>
 	<CrouchSpeed>1.5</CrouchSpeed>
+	<JumpSpeed>4.0</JumpSpeed>
 	<CurrentWishDirection X="0" Y="0" Z="0"/>
 	<CurrentWeapon></CurrentWeapon>
 </Player>

resources/Schema/Components/Player.xsd

@@ -11,6 +11,9 @@
 			<xs:all>
 				<xs:element name="MovementSpeed" type="t:float" minOccurs="0"/>
 				<xs:element name="CrouchSpeed" type="t:float" minOccurs="0"/>
+				<xs:element name="JumpSpeed" type="t:float" minOccurs="0">
+					<xs:annotation><xs:documentation>Vertical velocity set when jumping.</xs:documentation></xs:annotation>
+				</xs:element>
 				<xs:element name="CurrentWishDirection" type="t:Vector" minOccurs="0"/>
 				<xs:element name="CurrentWeapon" type="t:string" minOccurs="0"/>
 			</xs:all>

resources/Schema/Entities/Player.xml

@@ -13,8 +13,9 @@
     </c:AssaultWeapon>
     <c:Collidable/>
     <c:DefenderWeapon>
-      <TimeSinceLastFire>1.6944730461160304</TimeSinceLastFire>
+      <TimeSinceLastFire>52.867678870419283</TimeSinceLastFire>
     </c:DefenderWeapon>
+    <c:DoubleJump/>
     <c:Health/>
     <c:Physics>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
@@ -36,7 +37,10 @@
   <Children>
     <Entity name="Camera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Transform>
           <Position X="0" Y="1.27700007" Z="0"/>
         </c:Transform>
@@ -371,7 +375,7 @@
           <Components>
             <c:Animation>
               <AnimationName1>Idle</AnimationName1>
-              <Time1>0.67172915251515519</Time1>
+              <Time1>1.9408570429715581</Time1>
               <Speed1>1</Speed1>
               <AnimationName2></AnimationName2>
               <AnimationName3></AnimationName3>
@@ -385,25 +389,25 @@
           <Children>
             <Entity name="PrimaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>DefenderWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/DefenderWeaponView.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>DefenderWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
             <Entity name="SecondaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>AssaultWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/AssaultWeaponView.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>AssaultWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
@@ -413,7 +417,10 @@
     </Entity>
     <Entity name="ThirdPersonCamera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Model>
           <Resource>Models/Widgets/Camera.mesh</Resource>
           <Visible>false</Visible>
@@ -429,6 +436,7 @@
       <Components>
         <c:Animation>
           <AnimationName1>Idle</AnimationName1>
+          <Time1>1.5631122524686134</Time1>
           <Speed1>1</Speed1>
           <AnimationName2></AnimationName2>
           <AnimationName3></AnimationName3>
@@ -448,31 +456,31 @@
       <Children>
         <Entity name="PrimaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/DefenderWeaponWorld.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>DefenderWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/DefenderWeaponWorld.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>
         <Entity name="SecondaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>AssaultWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>

resources/Schema/Entities/PlayerRed.xml

@@ -13,8 +13,9 @@
     </c:AssaultWeapon>
     <c:Collidable/>
     <c:DefenderWeapon>
-      <TimeSinceLastFire>1.6944730461160304</TimeSinceLastFire>
+      <TimeSinceLastFire>22.22055262342397</TimeSinceLastFire>
     </c:DefenderWeapon>
+    <c:DoubleJump/>
     <c:Health/>
     <c:Physics>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
@@ -36,7 +37,10 @@
   <Children>
     <Entity name="Camera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Transform>
           <Position X="0" Y="1.27700007" Z="0"/>
         </c:Transform>
@@ -371,7 +375,7 @@
           <Components>
             <c:Animation>
               <AnimationName1>Idle</AnimationName1>
-              <Time1>0.67172915251515519</Time1>
+              <Time1>1.1978087298230946</Time1>
               <Speed1>1</Speed1>
               <AnimationName2></AnimationName2>
               <AnimationName3></AnimationName3>
@@ -385,25 +389,25 @@
           <Children>
             <Entity name="PrimaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>DefenderWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/DefenderWeaponViewRed.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>DefenderWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
             <Entity name="SecondaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>AssaultWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/AssaultWeaponView.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>AssaultWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
@@ -413,7 +417,10 @@
     </Entity>
     <Entity name="ThirdPersonCamera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Model>
           <Resource>Models/Widgets/Camera.mesh</Resource>
           <Visible>false</Visible>
@@ -429,6 +436,7 @@
       <Components>
         <c:Animation>
           <AnimationName1>Idle</AnimationName1>
+          <Time1>0.69274608502888668</Time1>
           <Speed1>1</Speed1>
           <AnimationName2></AnimationName2>
           <AnimationName3></AnimationName3>
@@ -448,31 +456,31 @@
       <Children>
         <Entity name="PrimaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/DefenderWeaponWorldRed.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>DefenderWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/DefenderWeaponWorldRed.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>
         <Entity name="SecondaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>AssaultWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -2,8 +2,6 @@
 
 layout (binding = 0) uniform sampler2D SceneTexture;
 layout (binding = 1) uniform sampler2D BloomTexture;
-layout (binding = 2) uniform sampler2D SceneTextureLowRes;
-layout (binding = 3) uniform sampler2D BloomTextureLowRes;
 uniform float Exposure;
 uniform float Gamma;
 
@@ -17,21 +15,12 @@ void main()
 {
 	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
 	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
-	vec4 hdrColorLowRes = texture(SceneTextureLowRes, Input.TextureCoordinate);
-	vec4 bloomColorLowRes = texture(BloomTextureLowRes, Input.TextureCoordinate);
 
 	//hdrColor = hdrColor * SSAO;
 	hdrColor += bloomColor;
-	hdrColorLowRes;
 
-	float hdrColorsum = hdrColorLowRes.r + hdrColorLowRes.g + hdrColorLowRes.b;
 	//Toon mapping thingy
-	vec3 result;
+	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
-	if(hdrColorsum > 0.0) {
-		result = vec3(1.0) - exp(-hdrColorLowRes.rgb * Exposure);
-	} else {
-		result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
-	}
 
 	//gamme correction
 	result = pow(result, vec3(1.0 / Gamma));

resources/Shaders/ForwardPlus.frag.glsl

@@ -171,7 +171,8 @@ void main()
 	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
 	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
 	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
-	color_result = color_result * clamp(1/specularTexel, 0, 1)*2 + reflectionColor * clamp(specularTexel, 0, 1)/2;
+	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a;
+	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
 	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
 	
 
@@ -182,9 +183,9 @@ void main()
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
 	//sceneColor = vec4(reflectionColor.xyz, 1);
-	color_result += glowTexel*GlowIntensity;
+	color_result.xyz += glowTexel.xyz*GlowIntensity;
 
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), clamp(color_result.a, 0, 1));
+	bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1));
 
 	//Tiled Debug Code
 	/*

resources/Shaders/ForwardPlusShieldCheck.frag.glsl

@@ -0,0 +1,207 @@
+#version 430
+
+#define MIN_AMBIENT_LIGHT 0.3
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec4 Color;
+uniform vec4 DiffuseColor;
+uniform vec2 ScreenDimensions;
+uniform vec4 FillColor;
+uniform vec4 AmbientColor;
+uniform float FillPercentage;
+uniform float GlowIntensity = 10;
+uniform vec3 CameraPosition;
+uniform int SSAOQuality;
+
+uniform vec2 DiffuseUVRepeat;
+uniform vec2 NormalUVRepeat;
+uniform vec2 SpecularUVRepeat;
+uniform vec2 GlowUVRepeat;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 1) uniform sampler2D DiffuseTexture;
+layout (binding = 2) uniform sampler2D NormalMapTexture;
+layout (binding = 3) uniform sampler2D SpecularMapTexture;
+layout (binding = 4) uniform sampler2D GlowMapTexture;
+layout (binding = 5) uniform samplerCube CubeMap;
+layout (binding = 31) uniform sampler2D ShieldBuffer;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+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;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist, float falloff) {
+	return 1.0 - smoothstep(radius * falloff, 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 CalcPointLightSource(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;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+void main()
+{
+	float shieldDepthValue = texelFetch(ShieldBuffer, ivec2(gl_FragCoord.xy), 0).r;
+	
+	if(shieldDepthValue < gl_FragCoord.z){
+		discard;
+	}
+
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);
+	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position);
+	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
+	vec3 R = reflect(-I, Input.Normal);
+	//R = vec3(P * vec4(R, 1.0));
+	vec4 reflectionColor = texture(CubeMap, R);
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
+	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 = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
+		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
+	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a;
+	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//sceneColor = vec4(reflectionColor.xyz, 1);
+	color_result.xyz += glowTexel.xyz*GlowIntensity;
+
+	bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1));
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

resources/Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl

@@ -0,0 +1,254 @@
+#version 430
+
+#define MIN_AMBIENT_LIGHT 0.3
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec2 ScreenDimensions;
+uniform float FillPercentage;
+uniform vec4 DiffuseColor;
+uniform vec4 FillColor;
+uniform vec4 Color;
+uniform vec4 AmbientColor;
+uniform int SSAOQuality;
+
+//Get bineded at the same time as the textures
+uniform vec2 DiffuseUVRepeat1;
+uniform vec2 DiffuseUVRepeat2;
+uniform vec2 DiffuseUVRepeat3;
+uniform vec2 NormalUVRepeat1;
+uniform vec2 NormalUVRepeat2;
+uniform vec2 NormalUVRepeat3;
+uniform vec2 SpecularUVRepeat1;
+uniform vec2 SpecularUVRepeat2;
+uniform vec2 SpecularUVRepeat3;
+uniform vec2 GlowUVRepeat1;
+uniform vec2 GlowUVRepeat2;
+uniform vec2 GlowUVRepeat3;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 1) uniform sampler2D SplatMapTexture;
+layout (binding = 2) uniform sampler2D DiffuseTexture1;
+layout (binding = 3) uniform sampler2D DiffuseTexture2;
+layout (binding = 4) uniform sampler2D DiffuseTexture3;
+layout (binding = 5) uniform sampler2D NormalMapTexture1;
+layout (binding = 6) uniform sampler2D NormalMapTexture2;
+layout (binding = 7) uniform sampler2D NormalMapTexture3;
+layout (binding = 8) uniform sampler2D SpecularMapTexture1;
+layout (binding = 9) uniform sampler2D SpecularMapTexture2;
+layout (binding = 10) uniform sampler2D SpecularMapTexture3;
+layout (binding = 11) uniform sampler2D GlowMapTexture1;
+layout (binding = 12) uniform sampler2D GlowMapTexture2;
+layout (binding = 13) uniform sampler2D GlowMapTexture3;
+layout (binding = 13) uniform sampler2D GlowMapTexture3;
+layout (binding = 31) uniform samplerCube ShieldBuffer;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+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;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+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 CalcPointLightSource(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;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+vec4 CalcBlendedTexel(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+	 				  vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	vec4 R_Channel = texture2D(R, Input.TextureCoordinate * R_TileValues);
+	vec4 G_Channel = texture2D(G, Input.TextureCoordinate * G_TileValues);
+	vec4 B_Channel = texture2D(B, Input.TextureCoordinate * B_TileValues);
+
+	float total = blendValue.r + blendValue.g + blendValue.b;
+	float totalDiv = 1.0f / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	return blendValue.r * R_Channel
+		 + blendValue.g * G_Channel
+		 + blendValue.b * B_Channel;
+}
+
+vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+					   vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	mat3 TBN = mat3(Input.Tangent, Input.BiTangent, Input.Normal);
+	vec3 R_Channel = texture(R, Input.TextureCoordinate * R_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 G_Channel = texture(G, Input.TextureCoordinate * G_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 B_Channel = texture(B, Input.TextureCoordinate * B_TileValues).xyz * 2.0 - vec3(1.0);
+
+	float total = blendValue.r + blendValue.g + blendValue.b + blendValue.a;
+	float totalDiv = 1 / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	vec3 Normal_result = blendValue.r * R_Channel
+					   + blendValue.g * G_Channel 
+		 			   + blendValue.b * B_Channel;
+
+	return vec4(TBN * normalize(Normal_result), 0.0);
+}
+
+void main()
+{
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
+
+	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);
+
+	vec4 diffuseTexel = CalcBlendedTexel(splatTexel, DiffuseTexture1, DiffuseTexture2, DiffuseTexture3,
+	 									 DiffuseUVRepeat1, DiffuseUVRepeat2, DiffuseUVRepeat3);
+	vec4 glowTexel = CalcBlendedTexel(splatTexel, GlowMapTexture1, GlowMapTexture2, GlowMapTexture3,
+	 									 GlowUVRepeat1, GlowUVRepeat2, GlowUVRepeat3);
+	vec4 specularTexel = CalcBlendedTexel(splatTexel, SpecularMapTexture1, SpecularMapTexture2, SpecularMapTexture3,
+										 SpecularUVRepeat1, SpecularUVRepeat2, SpecularUVRepeat3);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	//vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate, SplatMapTexture);
+	vec4 normal = V * CalcBlendedNormal(splatTexel, NormalMapTexture1, NormalMapTexture2, NormalMapTexture3,
+		   								NormalUVRepeat1, NormalUVRepeat2, NormalUVRepeat3);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position); 
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
+	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 = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
+		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	color_result += glowTexel*3;
+
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

resources/Shaders/MergeProgram.frag.glsl

@@ -1,27 +0,0 @@
-#version 430
-
-layout (binding = 1) uniform sampler2D DepthStencilTexture;
-layout (binding = 2) uniform sampler2D SceneTexture;
-layout (binding = 3) uniform sampler2D BloomTexture;
-
-in VertexData{
-	vec2 TextureCoordinate;
-}Input;
-
-out vec4 sceneColor;
-out vec4 bloomColor;
-
-void main()
-{
-	float texel = texelFetch(DepthStencilTexture, ivec2(gl_FragCoord.xy / 8.0f), 0).g;
-	if(texel >= 0.9f)
-	{
-		discard;
-	}
-	sceneColor = vec4(texture2D(SceneTexture, Input.TextureCoordinate).rgb * texel, 1.0f);
-	bloomColor = vec4(texture2D(BloomTexture, Input.TextureCoordinate).rgb * texel, 1.0f);
-	//sceneColor = texel;
-	//bloomColor = vec4(1,0.5,0.7,1);
-}
-
-

resources/Shaders/SpriteShieldCheck.frag.glsl

@@ -0,0 +1,41 @@
+#version 430
+
+uniform vec4 Color;
+uniform vec4 FillColor;
+uniform float FillPercentage;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout (binding = 1) uniform sampler2D DiffuseTexture;
+layout (binding = 2) uniform sampler2D GlowMapTexture;
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+}Input;
+
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+void main()
+{
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate);
+
+	vec4 color_result = Color * diffuseTexel;
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+	if(pos <= FillPercentage) {
+		color_result = FillColor*diffuseTexel.a;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+
+	//bloomColor = vec4(clamp((glowTexel.xyz*3) - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(1.0, 1.0, 1.0, 0.0);
+}
+
+

src/Engine/Collision/CollisionSystem.cpp

@@ -12,6 +12,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     if (!boundingBox) {
         return;
     }
+
     ComponentWrapper& cTransform = entity["Transform"];
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
@@ -86,10 +87,12 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             glm::mat4 modelMatrix = Transform::ModelMatrix(boxB.Entity);
 
             glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
+            bool notMovingxz = glm::all(glm::lessThan(glm::abs(glm::vec2(inOutVelocity.x, inOutVelocity.z)), glm::vec2(0.01f))) && prevPosIt != m_PrevPositions.end();
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
             if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
-                (glm::vec3&)cTransform["Position"] += resolutionVector;
+                //Move the position to previous position if it is not moving in the xz-plane, else resolve with the resolution vector.
+                (glm::vec3&)cTransform["Position"] += notMovingxz ? prevPosIt->second - boxA.Origin() : resolutionVector;
                 boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {

src/Engine/Editor/EditorRenderSystem.cpp

@@ -54,7 +54,7 @@ void EditorRenderSystem::Update(double dt)
             EntityWrapper entity(m_World, cModel.EntityID);
             glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
-                std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f);
+                std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f, false);
                 if (cModel["Transparent"]) {
                     scene.Jobs.TransparentObjects.push_back(modelJob);
                 } else {

src/Engine/Rendering/DrawColorCorrectionPass.cpp

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

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1,17 +1,15 @@
 #include "Rendering/DrawFinalPass.h"
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, GLuint* depthBuffer)
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass)
 	: m_Renderer(renderer)
 	, m_LightCullingPass(lightCullingPass)
 	, m_CubeMapPass(cubeMapPass)
 	, m_SSAOPass(ssaoPass)
-	, m_DepthBuffer(depthBuffer)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
     m_ShieldPixelRate = 8;
     InitializeTextures();
     InitializeShaderPrograms();
     InitializeFrameBuffers();
-	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 }
 
 void DrawFinalPass::InitializeTextures()
@@ -31,40 +29,20 @@ void DrawFinalPass::InitializeFrameBuffers()
     //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
     //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
 
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
+	CommonFunctions::GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
     //m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_StencilTexture, GL_STENCIL_ATTACHMENT)));
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
     m_FinalPassFrameBuffer.Generate();
     GLERROR("FBO generation");
 
-   /* glGenRenderbuffers(1, &m_DepthBufferLowRes);
+	CommonFunctions::GenerateTexture(&m_ShieldBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferLowRes);
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
+	m_ShieldDepthFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_ShieldBuffer, GL_DEPTH_ATTACHMENT)));
-    GLERROR("RenderBufferLowRes generation");*/
+	m_ShieldDepthFrameBuffer.Generate();
-
-	CommonFunctions::GenerateTexture(&m_DepthBufferLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, 
-		glm::vec2((int)(m_Renderer->GetViewportSize().Width / m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height / m_ShieldPixelRate)), 
-		GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
-	
-	CommonFunctions::GenerateTexture(&m_SceneTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-	CommonFunctions::GenerateTexture(&m_BloomTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
-    //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
-
-    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBufferLowRes, GL_DEPTH_STENCIL_ATTACHMENT)));
-    //m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_StencilTexture, GL_STENCIL_ATTACHMENT)));
-    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTextureLowRes, GL_COLOR_ATTACHMENT0)));
-    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTextureLowRes, GL_COLOR_ATTACHMENT1)));
-    m_FinalPassFrameBufferLowRes.Generate();
-    GLERROR("FBO2 generation");
-
-	m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
-	m_MergeFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
-	m_MergeFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
-	m_MergeFrameBuffer.Generate();
-	GLERROR("FBO3 generation");
 }
 
 void DrawFinalPass::InitializeShaderPrograms()
@@ -96,6 +74,7 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_SpriteProgram->BindFragDataLocation(1, "bloomColor");
     m_SpriteProgram->Link();
     GLERROR("Creating sprite program");
+
 	m_ForwardPlusSplatMapProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram");
 	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
 	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGB.frag.glsl")));
@@ -152,194 +131,183 @@ void DrawFinalPass::InitializeShaderPrograms()
 	m_ForwardPlusSplatMapSkinnedProgram->Link();
 	GLERROR("Creating Forward SplatMap Skinned program");
 
-    m_ShieldToStencilProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgram");
+    m_FillDepthStencilBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
-    m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencil.vert.glsl")));
+    m_FillDepthStencilBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
-    m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
+    m_FillDepthStencilBufferProgram->Compile();
-    m_ShieldToStencilProgram->Compile();
+    m_FillDepthStencilBufferProgram->Link();
-    m_ShieldToStencilProgram->Link();
-    GLERROR("Creating Shield program");
-
-    m_ShieldToStencilSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgramSkinned");
-    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencilSkinned.vert.glsl")));
-    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
-    m_ShieldToStencilSkinnedProgram->Compile();
-    m_ShieldToStencilSkinnedProgram->Link();
-    GLERROR("Creating Shield Skinned program");
-
-    m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
-    m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
-    //m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
-    m_FillDepthBufferProgram->Compile();
-    m_FillDepthBufferProgram->Link();
     GLERROR("Creating DepthFill program");
 
-    m_FillDepthBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
+    m_FillDepthStencilBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
-    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
+    m_FillDepthStencilBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
-    //m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthStencilBufferSkinnedProgram->Compile();
-    m_FillDepthBufferSkinnedProgram->Compile();
+    m_FillDepthStencilBufferSkinnedProgram->Link();
-    m_FillDepthBufferSkinnedProgram->Link();
     GLERROR("Creating DepthFill program");
 
-	m_MergeProgram = ResourceManager::Load<ShaderProgram>("#MergeProgram");
+
-	m_MergeProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
+
-	m_MergeProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/MergeProgram.frag.glsl")));
+
-	m_MergeProgram->Compile();
+
-	m_MergeProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusShieldCheckProgram");
-	m_MergeProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
-	m_MergeProgram->Link();
+	m_ForwardPlusShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusShieldCheck.frag.glsl")));
-	GLERROR("Creating merge program");
+	m_ForwardPlusShieldCheckProgram->Compile();
+	m_ForwardPlusShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusShieldCheckProgram->Link();
+	GLERROR("Creating forward+ program");
+
+	m_ExplosionEffectShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectShieldCheckProgram");
+	m_ExplosionEffectShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+	m_ExplosionEffectShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
+	m_ExplosionEffectShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusShieldCheck.frag.glsl")));
+	m_ExplosionEffectShieldCheckProgram->Compile();
+	m_ExplosionEffectShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectShieldCheckProgram->Link();
+	GLERROR("Creating explosion program");
+
+	m_SpriteShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#SpriteShieldCheckProgram");
+	m_SpriteShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Sprite.vert.glsl")));
+	m_SpriteShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SpriteShieldCheck.frag.glsl")));
+	m_SpriteShieldCheckProgram->Compile();
+	m_SpriteShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_SpriteShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_SpriteShieldCheckProgram->Link();
+	GLERROR("Creating sprite program");
+
+	m_ForwardPlusSplatMapShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapShieldCheckProgram");
+	m_ForwardPlusSplatMapShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+	m_ForwardPlusSplatMapShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl")));
+	m_ForwardPlusSplatMapShieldCheckProgram->Compile();
+	m_ForwardPlusSplatMapShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSplatMapShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSplatMapShieldCheckProgram->Link();
+	GLERROR("Creating Forward SplatMap program");
+
+	m_ExplosionEffectSplatMapShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSplatMapShieldCheckProgram");
+	m_ExplosionEffectSplatMapShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+	m_ExplosionEffectSplatMapShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
+	m_ExplosionEffectSplatMapShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl")));
+	m_ExplosionEffectSplatMapShieldCheckProgram->Compile();
+	m_ExplosionEffectSplatMapShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSplatMapShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSplatMapShieldCheckProgram->Link();
+	GLERROR("Creating explosion SplatMap program");
+
+	m_ForwardPlusSkinnedShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedShieldCheckProgram");
+	m_ForwardPlusSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ForwardPlusSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusShieldCheck.frag.glsl")));
+	m_ForwardPlusSkinnedShieldCheckProgram->Compile();
+	m_ForwardPlusSkinnedShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSkinnedShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSkinnedShieldCheckProgram->Link();
+	GLERROR("Creating forward+ Skinned program");
+
+	m_ExplosionEffectSkinnedShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSkinnedShieldCheckProgram");
+	m_ExplosionEffectSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ExplosionEffectSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
+	m_ExplosionEffectSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusShieldCheck.frag.glsl")));
+	m_ExplosionEffectSkinnedShieldCheckProgram->Compile();
+	m_ExplosionEffectSkinnedShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSkinnedShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSkinnedShieldCheckProgram->Link();
+	GLERROR("Creating explosion Skinned program");
+
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSplatMapSkinnedShieldCheckProgram");
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl")));
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->Compile();
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->Link();
+	GLERROR("Creating Forward SplatMap Skinned program");
+
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapSkinnedShieldCheckProgram");
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl")));
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->Compile();
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSplatMapSkinnedShieldCheckProgram->Link();
+	GLERROR("Creating Forward SplatMap Skinned program");
+	
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("Pre");
+	DrawFinalPassState* stateDethp = new DrawFinalPassState(m_ShieldDepthFrameBuffer.GetHandle());
+	//Draw shields to stencil
+	DrawToDepthStencilBuffer(scene.Jobs.ShieldObjects, scene);
+	GLERROR("StencilPass");
+	delete stateDethp;
+
+
 	DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
     if (scene.ClearDepth) {
         //glClear(GL_DEPTH_BUFFER_BIT);
 		state->Disable(GL_DEPTH_TEST);
+		state->DepthMask(GL_FALSE);
     }
     //TODO: Do we need check for this or will it be per scene always?
-	state->Enable(GL_STENCIL_TEST);
     glClearStencil(0x00);
     glClear(GL_STENCIL_BUFFER_BIT);
 
-	//Draw Opaque shielded objects
+    //Fill depth buffer
-	state->Disable(GL_STENCIL_TEST);
-	DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
-	GLERROR("OpaqueObjects");
-	DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
-	GLERROR("Shielded Opaque object");
-
-	//DrawStencilState* stencilState = new DrawStencilState(m_FinalPassFrameBuffer.GetHandle());
-	//Draw shields to stencil pass
 	state->Enable(GL_STENCIL_TEST);
 	state->StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 	state->StencilFunc(GL_ALWAYS, 1, 0xFF);
 	state->StencilMask(0xFF);
-	DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
+	state->DepthMask(GL_FALSE);
-	GLERROR("StencilPass");
+	//DrawToDepthStencilBuffer(scene.Jobs.ShieldObjects, scene);
+	state->DepthMask(GL_TRUE);
 
+    //Draw Opaque shielded objects
+	state->Disable(GL_STENCIL_TEST);
+    state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
+    state->StencilMask(0x00);
+	DrawModelRenderQueuesWithShieldCheck(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
+    GLERROR("Shielded Opaque object");
 
-
+	//Draw Opaque objects
-	//state->BlendFunc(GL_ONE, GL_ONE);
+	//state->StencilMask(0x00);
-	//DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
-	//GLERROR("TransparentObjects");
-
-	////Draw Transparen Shielded objects
-	//DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
-	//GLERROR("Shielded Transparent objects");
-
- //   state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- //   DrawSprites(scene.Jobs.SpriteJob, scene);
- //   GLERROR("SpriteJobs");
-
-    GLERROR("END");
-    delete state;
-
-
-    DrawFinalPassState* stateLowRes = new DrawFinalPassState(m_FinalPassFrameBufferLowRes.GetHandle());
-    //Draw the lowres texture that will be shown behind the shield.
-    stateLowRes->Enable(GL_SCISSOR_TEST);
-    stateLowRes->Enable(GL_DEPTH_TEST);
-	stateLowRes->DepthMask(GL_TRUE);
-	stateLowRes->Enable(GL_STENCIL_TEST);
-	stateLowRes->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
-	stateLowRes->StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-	stateLowRes->StencilMask(0xFF);
-    //TODO: Viewports and scissor should be in state
-    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
-    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-
-    glClearStencil(0x00);
-    glClear(GL_STENCIL_BUFFER_BIT);
-
-    //TODO: This should not be here...
-    stateLowRes->StencilFunc(GL_ALWAYS, 1, 0xFF);
-    stateLowRes->StencilMask(0x00);
-    DrawToDepthBuffer(scene.Jobs.OpaqueObjects, scene);
-    //DrawToDepthBuffer(scene.Jobs.TransparentObjects, scene);
-
-    //Draw shields to stencil pass
-	stateLowRes->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
-    stateLowRes->StencilMask(0xFF);
-	stateLowRes->DepthMask(GL_FALSE);
-    DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
-    GLERROR("StencilPass");
-
-    //glClear(GL_DEPTH_BUFFER_BIT);
-
-    stateLowRes->Enable(GL_DEPTH_TEST);
-	//stateLowRes->DepthMask(GL_TRUE);
-	stateLowRes->DepthFunc(GL_LEQUAL);
-    stateLowRes->StencilFunc(GL_LEQUAL, 1, 0xFF);
-    stateLowRes->StencilMask(0x00);
 	DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
 	GLERROR("OpaqueObjects");
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
-    GLERROR("TransparentObjects");
-    glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-    delete stateLowRes;
-	m_FinalPassFrameBuffer.Unbind();
-	m_FinalPassFrameBufferLowRes.Unbind();
-
-	state = new DrawFinalPassState(m_MergeFrameBuffer.GetHandle());
-	state->Disable(GL_DEPTH_TEST);
-	state->Enable(GL_STENCIL_TEST);
-	state->StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-	state->StencilFunc(GL_LEQUAL, 1, 0xFF);
-	state->StencilMask(0x00);
-	MergeLayers();
-	delete state;
-
-	state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
-	//Draw Transparancy
-	state->BlendFunc(GL_ONE, GL_ONE);
-	DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
-	GLERROR("TransparentObjects");
 
+	//state->Disable(GL_STENCIL_TEST);
     //Draw Transparen Shielded objects
-	DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
+	state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	DrawModelRenderQueuesWithShieldCheck(scene.Jobs.TransparentObjects, scene); //might need changing
     GLERROR("Shielded Transparent objects");
 
-	state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	//Draw Transparen objects
+	//state->BlendFunc(GL_ONE, GL_ONE);
+	//state->StencilFunc(GL_EQUAL, 1, 0xFF);
+	//DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
+	GLERROR("TransparentObjects");
+	//state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	DrawSprites(scene.Jobs.SpriteJob, scene);
 	GLERROR("SpriteJobs");
 
-	GLERROR("END");
 	delete state;
+    GLERROR("END");
+    
 }
 
 
 void DrawFinalPass::ClearBuffer()
 {
     GLERROR("PRE");
-    m_FinalPassFrameBufferLowRes.Bind();
+	m_ShieldDepthFrameBuffer.Bind();
-    GLERROR("Bind LowRes");
+	glClear(GL_DEPTH_BUFFER_BIT);
-
+	m_ShieldDepthFrameBuffer.Unbind();
-    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
-    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-    GLERROR("ViewPort,Scissor LowRes");
-
-    glClearColor(0.f, 0.f, 0.f, 0.f);
-    GLERROR("1");
-
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-    GLERROR("2");
-
-    glDisable(GL_SCISSOR_TEST);
-    GLERROR("3");
-
-    m_FinalPassFrameBufferLowRes.Unbind();
-
-    GLERROR("prebind HighRes");
     m_FinalPassFrameBuffer.Bind();
     GLERROR("Bind HighRes");
     glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     GLERROR("ViewPort,Scissor LowRes");
     glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_FinalPassFrameBuffer.Unbind();
     GLERROR("END");
 }
@@ -348,39 +316,25 @@ void DrawFinalPass::ClearBuffer()
 void DrawFinalPass::OnWindowResize()
 {
     //InitializeFrameBuffers();
-
+	CommonFunctions::GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
     CommonFunctions::GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 	CommonFunctions::GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     m_FinalPassFrameBuffer.Generate();
 
-
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferLowRes);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
-
-	CommonFunctions::GenerateTexture(&m_SceneTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
-	CommonFunctions::GenerateTexture(&m_BloomTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
-    m_FinalPassFrameBufferLowRes.Generate();
     GLERROR("Error changing texture resolutions");
 }
 
 void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
-    GLERROR("forwardHandle");
 	GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
-    GLERROR("explosionHandle");
 	GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle();
-	GLERROR("explosionSplatMapHandle");
+	GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle();
-	GLuint forwardSplatHandle = m_ForwardPlusSplatMapProgram->GetHandle();
-	GLERROR("forwardSplatHandle");
 	GLuint forwardSkinnedHandle = m_ForwardPlusSkinnedProgram->GetHandle();
-	GLERROR("forwardSkinnedHandle");
 	GLuint explosionSkinnedHandle = m_ExplosionEffectSkinnedProgram->GetHandle();
-	GLERROR("explosionSkinnedHandle");
 	GLuint explosionSplatMapSkinnedHandle = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
-	GLERROR("explosionSplatMapSkinnedHandle");
 	GLuint forwardSplatMapSkinnedHandle = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
-	GLERROR("forwardSplatSkinnedHandle");
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
@@ -411,11 +365,13 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 						std::vector<glm::mat4> frameBones;
 						if (explosionEffectJob->AnimationOffset.animation != nullptr) {
 							frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
-                    } else {
+						}
+						else {
 							frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
 						}
 						glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                } else {
+					}
+					else {
 						m_ExplosionEffectProgram->Bind();
 						GLERROR("Bind ExplosionEffect program");
 						//bind uniforms
@@ -425,7 +381,6 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 						glActiveTexture(GL_TEXTURE5);
 						glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
 						glUniform3fv(glGetUniformLocation(explosionHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
-
 					}
 					break;
 			}
@@ -442,12 +397,13 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 						std::vector<glm::mat4> frameBones;
 						if (explosionEffectJob->AnimationOffset.animation != nullptr) {
 							frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
-                    } else {
+						}
+						else {
 							frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
 						}
 						glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-
+					}
-                } else {
+					else {
 						m_ExplosionEffectSplatMapProgram->Bind();
 						GLERROR("Bind ExplosionEffectSplatMap program");
 						//bind uniforms
@@ -491,12 +447,14 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 						std::vector<glm::mat4> frameBones;
 						if (modelJob->AnimationOffset.animation != nullptr) {
 							frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                            } else {
+						}
+						else {
 							frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
 						}
 						glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                        } else {
+					}
+					else {
 						m_ForwardPlusProgram->Bind();
 						GLERROR("Bind ForwardPlusProgram");
 						//bind uniforms
@@ -522,18 +480,20 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 						std::vector<glm::mat4> frameBones;
 						if (modelJob->AnimationOffset.animation != nullptr) {
 							frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                            } else {
+						}
+						else {
 							frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
 						}
 						glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                        } else {
+					}
+					else {
 						m_ForwardPlusSplatMapProgram->Bind();
 						GLERROR("Bind SplatMap program");
 						//bind uniforms
-                            BindModelUniforms(forwardSplatHandle, modelJob, scene);
+						BindModelUniforms(forwardSplatMapHandle, modelJob, scene);
 						//bind textures
-                            BindModelTextures(forwardSplatHandle, modelJob);
+						BindModelTextures(forwardSplatMapHandle, modelJob);
 						GLERROR("asdasd");
 					}
 					break;
@@ -551,39 +511,341 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     }
 }
 
-
+void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
-void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
+	GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
+	GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
+	GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle();
+	GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle();
+	GLuint forwardSkinnedHandle = m_ForwardPlusSkinnedProgram->GetHandle();
+	GLuint explosionSkinnedHandle = m_ExplosionEffectSkinnedProgram->GetHandle();
+	GLuint explosionSplatMapSkinnedHandle = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
+	GLuint forwardSplatMapSkinnedHandle = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
 
+	GLuint forwardShieldCheckHandle = m_ForwardPlusShieldCheckProgram->GetHandle();
+	GLuint explosionShieldCheckHandle = m_ExplosionEffectShieldCheckProgram->GetHandle();
+	GLuint explosionSplatMapShieldCheckHandle = m_ExplosionEffectSplatMapShieldCheckProgram->GetHandle();
+	GLuint forwardSplatShieldCheckHandle = m_ForwardPlusSplatMapShieldCheckProgram->GetHandle();
+	GLuint forwardSkinnedShieldCheckHandle = m_ForwardPlusSkinnedShieldCheckProgram->GetHandle();
+	GLuint explosionSkinnedShieldCheckHandle = m_ExplosionEffectSkinnedShieldCheckProgram->GetHandle();
+	GLuint explosionSplatMapSkinnedShieldCheckHandle = m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->GetHandle();
+	GLuint forwardSplatMapSkinnedShieldCheckHandle = m_ForwardPlusSplatMapSkinnedShieldCheckProgram->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());
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, m_SSAOPass->SSAOTexture());
+
+	glActiveTexture(GL_TEXTURE31);
+	glBindTexture(GL_TEXTURE_2D, m_ShieldBuffer);
 
 	for (auto &job : jobs) {
+		auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
+		if (explosionEffectJob) {
+			if (explosionEffectJob->IsShielded) {
+				switch (explosionEffectJob->Type) {
+				case RawModel::MaterialType::Basic:
+				case RawModel::MaterialType::SingleTextures:
+					{
+						if (explosionEffectJob->Model->IsSkinned()) {
+
+							m_ExplosionEffectSkinnedShieldCheckProgram->Bind();
+							GLERROR("Bind ExplosionEffectSkinned program");
+							//bind uniforms
+							BindExplosionUniforms(explosionSkinnedShieldCheckHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSkinnedShieldCheckHandle, explosionEffectJob);
+							glActiveTexture(GL_TEXTURE5);
+							glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+							glUniform3fv(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
+							std::vector<glm::mat4> frameBones;
+							if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+							}
+							else {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+							}
+							glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+						}
+						else {
+							m_ExplosionEffectShieldCheckProgram->Bind();
+							GLERROR("Bind ExplosionEffect program");
+							//bind uniforms
+							BindExplosionUniforms(explosionShieldCheckHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionShieldCheckHandle, explosionEffectJob);
+							glActiveTexture(GL_TEXTURE5);
+							glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+							glUniform3fv(glGetUniformLocation(explosionShieldCheckHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
+						}
+						break;
+					}
+				case RawModel::MaterialType::SplatMapping:
+					{
+						if (explosionEffectJob->Model->IsSkinned()) {
+							m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->Bind();
+							GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+							//bind uniforms
+							BindExplosionUniforms(explosionSplatMapSkinnedShieldCheckHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSplatMapSkinnedShieldCheckHandle, explosionEffectJob);
+							GLERROR("asdasd");
+							std::vector<glm::mat4> frameBones;
+							if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+							}
+							else {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+							}
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+						}
+						else {
+							m_ExplosionEffectSplatMapShieldCheckProgram->Bind();
+							GLERROR("Bind ExplosionEffectSplatMap program");
+							//bind uniforms
+							//bind uniforms
+							BindExplosionUniforms(explosionSplatMapShieldCheckHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSplatMapShieldCheckHandle, explosionEffectJob);
+							GLERROR("asdasd");
+						}
+						break;
+					}
+				}
+			} else {
+				switch (explosionEffectJob->Type) {
+				case RawModel::MaterialType::Basic:
+				case RawModel::MaterialType::SingleTextures:
+					{
+						if (explosionEffectJob->Model->IsSkinned()) {
+
+							m_ExplosionEffectSkinnedProgram->Bind();
+							GLERROR("Bind ExplosionEffectSkinned program");
+							//bind uniforms
+							BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+							glActiveTexture(GL_TEXTURE5);
+							glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+							glUniform3fv(glGetUniformLocation(explosionSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
+							std::vector<glm::mat4> frameBones;
+							if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+							}
+							else {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+							}
+							glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+						}
+						else {
+							m_ExplosionEffectProgram->Bind();
+							GLERROR("Bind ExplosionEffect program");
+							//bind uniforms
+							BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionHandle, explosionEffectJob);
+							glActiveTexture(GL_TEXTURE5);
+							glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+							glUniform3fv(glGetUniformLocation(explosionHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+						}
+						break;
+					}
+				case RawModel::MaterialType::SplatMapping:
+					{
+						if (explosionEffectJob->Model->IsSkinned()) {
+							m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+							GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+							//bind uniforms
+							BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
+							GLERROR("asdasd");
+							std::vector<glm::mat4> frameBones;
+							if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+							}
+							else {
+								frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+							}
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+						}
+						else {
+							m_ExplosionEffectSplatMapProgram->Bind();
+							GLERROR("Bind ExplosionEffectSplatMap program");
+							//bind uniforms
+							//bind uniforms
+							BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
+							//bind textures
+							BindExplosionTextures(explosionSplatMapHandle, explosionEffectJob);
+							GLERROR("asdasd");
+						}
+						break;
+					}
+				}
+			}
+			glDisable(GL_CULL_FACE);
+
+			//draw
+			glBindVertexArray(explosionEffectJob->Model->VAO);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+			glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
+			glEnable(GL_CULL_FACE);
+			GLERROR("explosion effect end");
+		} else {
 			auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 			if (modelJob) {
-
+				//bind forward program
+				//TODO: JOHAN/TOBIAS: Bind shader based on ModelJob->ShaderID;
+				if (modelJob->IsShielded) {
+					switch (modelJob->Type) {
+					case RawModel::MaterialType::Basic:
+					case RawModel::MaterialType::SingleTextures:
+						{
 							if (modelJob->Model->IsSkinned()) {
-                m_ShieldToStencilSkinnedProgram->Bind();
+								m_ForwardPlusSkinnedShieldCheckProgram->Bind();
-                GLuint shaderHandle = m_ShieldToStencilSkinnedProgram->GetHandle();
+								GLERROR("Bind ForwardPlusSkinnedProgram");
+								//bind uniforms
+								BindModelUniforms(forwardSkinnedShieldCheckHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSkinnedShieldCheckHandle, modelJob);
+								glActiveTexture(GL_TEXTURE5);
+								glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+								glUniform3fv(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
-                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()));
 								std::vector<glm::mat4> frameBones;
 								if (modelJob->AnimationOffset.animation != nullptr) {
 									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                } else {
+								}
+								else {
 									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
 								}
-                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+								glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-            } else {
-                m_ShieldToStencilProgram->Bind();
-                GLuint shaderHandle = m_ShieldToStencilProgram->GetHandle();
-
-                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()));
 
 							}
+							else {
+								m_ForwardPlusShieldCheckProgram->Bind();
+								GLERROR("Bind ForwardPlusProgram");
+								//bind uniforms
+								BindModelUniforms(forwardShieldCheckHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardShieldCheckHandle, modelJob);
+								glActiveTexture(GL_TEXTURE5);
+								glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+								glUniform3fv(glGetUniformLocation(forwardShieldCheckHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+							}
+							break;
+						}
+					case RawModel::MaterialType::SplatMapping:
+						{
+							if (modelJob->Model->IsSkinned()) {
+								m_ForwardPlusSplatMapSkinnedShieldCheckProgram->Bind();
+								GLERROR("Bind SplatMap program");
+								//bind uniforms
+								BindModelUniforms(forwardSplatMapSkinnedShieldCheckHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSplatMapSkinnedShieldCheckHandle, modelJob);
+								GLERROR("asdasd");
+								std::vector<glm::mat4> frameBones;
+								if (modelJob->AnimationOffset.animation != nullptr) {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+								}
+								else {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+								}
+								glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
+							}
+							else {
+								m_ForwardPlusSplatMapShieldCheckProgram->Bind();
+								GLERROR("Bind SplatMap program");
+								//bind uniforms
+								BindModelUniforms(forwardSplatShieldCheckHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSplatShieldCheckHandle, modelJob);
+								GLERROR("asdasd");
+							}
+							break;
+						}
+					}
+				} else {
+					switch (modelJob->Type) {
+					case RawModel::MaterialType::Basic:
+					case RawModel::MaterialType::SingleTextures:
+						{
+							if (modelJob->Model->IsSkinned()) {
+								m_ForwardPlusSkinnedProgram->Bind();
+								GLERROR("Bind ForwardPlusSkinnedProgram");
+								//bind uniforms
+								BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSkinnedHandle, modelJob);
+								glActiveTexture(GL_TEXTURE5);
+								glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+								glUniform3fv(glGetUniformLocation(forwardSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+
+								std::vector<glm::mat4> frameBones;
+								if (modelJob->AnimationOffset.animation != nullptr) {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+								}
+								else {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+								}
+								glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+							}
+							else {
+								m_ForwardPlusProgram->Bind();
+								GLERROR("Bind ForwardPlusProgram");
+								//bind uniforms
+								BindModelUniforms(forwardHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardHandle, modelJob);
+								glActiveTexture(GL_TEXTURE5);
+								glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
+								glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+							}
+							break;
+						}
+					case RawModel::MaterialType::SplatMapping:
+						{
+							if (modelJob->Model->IsSkinned()) {
+								m_ForwardPlusSplatMapSkinnedProgram->Bind();
+								GLERROR("Bind SplatMap program");
+								//bind uniforms
+								BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
+								GLERROR("asdasd");
+								std::vector<glm::mat4> frameBones;
+								if (modelJob->AnimationOffset.animation != nullptr) {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+								}
+								else {
+									frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+								}
+								glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+							}
+							else {
+								m_ForwardPlusSplatMapProgram->Bind();
+								GLERROR("Bind SplatMap program");
+								//bind uniforms
+								BindModelUniforms(forwardSplatMapHandle, modelJob, scene);
+								//bind textures
+								BindModelTextures(forwardSplatMapHandle, modelJob);
+								GLERROR("asdasd");
+							}
+							break;
+						}
+					}
+				}
+				//draw
 				glBindVertexArray(modelJob->Model->VAO);
 				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
 				glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
@@ -593,6 +855,7 @@ void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJo
 			}
 		}
 	}
+}
 
 void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
@@ -686,7 +949,7 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
 }
 
 
-void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
+void DrawFinalPass::DrawToDepthStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
     
    
@@ -694,8 +957,8 @@ void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& job
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
       
         if(modelJob->Model->IsSkinned()) {
-            m_FillDepthBufferSkinnedProgram->Bind();
+            m_FillDepthStencilBufferSkinnedProgram->Bind();
-            GLuint shaderHandle = m_FillDepthBufferSkinnedProgram->GetHandle();
+            GLuint shaderHandle = m_FillDepthStencilBufferSkinnedProgram->GetHandle();
             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()));
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
@@ -709,8 +972,8 @@ void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& job
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
         } else {
-            m_FillDepthBufferProgram->Bind();
+            m_FillDepthStencilBufferProgram->Bind();
-            GLuint shaderHandle = m_FillDepthBufferProgram->GetHandle();
+            GLuint shaderHandle = m_FillDepthStencilBufferProgram->GetHandle();
             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()));
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
@@ -774,28 +1037,6 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
    // m_SpriteProgram->Unbind();
 }
 
-void DrawFinalPass::MergeLayers() 
-{
-	GLuint shaderHandle = m_MergeProgram->GetHandle();
-
-	m_MergeProgram->Bind();
-	GLERROR("MergeLayers 1");
-	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_2D, m_DepthBufferLowRes);
-	GLERROR("MergeLayers 2");
-	glActiveTexture(GL_TEXTURE2);
-	glBindTexture(GL_TEXTURE_2D, m_SceneTextureLowRes);
-	GLERROR("MergeLayers 3");
-	glActiveTexture(GL_TEXTURE3);
-	glBindTexture(GL_TEXTURE_2D, m_BloomTextureLowRes);
-	GLERROR("MergeLayers 4");
-	glBindVertexArray(m_ScreenQuad->VAO);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
-		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
-	GLERROR("MergeLayers 5");
-}
-
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
 	glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -8,8 +8,7 @@ DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
-	DepthMask(GL_FALSE);
+	DepthMask(GL_TRUE);
-	DepthFunc(GL_LEQUAL);
     Enable(GL_CULL_FACE);
    // Enable(GL_STENCIL_TEST);
    // StencilFunc(GL_NOTEQUAL, 1, 0xFF);
@@ -26,11 +25,9 @@ DrawFinalPassState::~DrawFinalPassState()
 DrawStencilState::DrawStencilState(GLuint frameBuffer)
 {
     BindFramebuffer(frameBuffer);
-    Enable(GL_STENCIL_TEST);
-    StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-    StencilFunc(GL_ALWAYS, 1, 0xFF);
-    StencilMask(0xFF);
     Enable(GL_DEPTH_TEST);
+	DepthMask(GL_TRUE);
+	Enable(GL_CULL_FACE);
     ClearColor(glm::vec4(0.f));
 }
 

src/Engine/Rendering/PickingPass.cpp

@@ -23,11 +23,12 @@ void PickingPass::InitializeTextures()
         glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
 
 	CommonFunctions::GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
-		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+		glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
 }
 
 void PickingPass::InitializeFrameBuffers()
 {
+
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
     m_PickingBuffer.Generate();

src/Engine/Rendering/PickingPassState.cpp

@@ -9,7 +9,6 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
     Disable(GL_BLEND);
-
     glm::vec4 clearColor = glm::vec4(0.f);
     //ClearColor(clearColor);
     //Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

src/Engine/Rendering/RenderSystem.cpp

@@ -240,6 +240,8 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
             fillColor = (glm::vec4)fillComponent["Color"];
         }
 
+		bool isShielded = m_World->HasComponent(cModel.EntityID, "Shielded") || m_World->HasComponent(cModel.EntityID, "Player");
+
         glm::mat4 modelMatrix = Transform::ModelMatrix(cModel.EntityID, m_World);
         //Loop through all materialgroups of a model
         for (auto matGroup : model->MaterialGroups()) {
@@ -255,20 +257,19 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     cModel, 
                     m_World, 
                     fillColor, 
-                    fillPercentage
+                    fillPercentage,
+					isShielded
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")){
                     explosionEffectJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(explosionEffectJob);
-                } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
+                } else if (isShielded) {
-                    || m_World->HasComponent(cModel.EntityID, "Player")) {
-
                     if (explosionEffectJob->Color.a != 1.f || explosionEffectJob->EndColor.a != 1.f || explosionEffectJob->DiffuseColor.a != 1.f) {
                         cModel["Transparent"] = true;
                     }
 
                     if (cModel["Transparent"]) {
-                        Jobs.TransparentShieldedObjects.push_back(explosionEffectJob);
+                        Jobs.TransparentObjects.push_back(explosionEffectJob);
                     } else {
 					    explosionEffectJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(explosionEffectJob);
@@ -294,20 +295,20 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     cModel, 
                     m_World, 
                     fillColor, 
-                    fillPercentage
+                    fillPercentage,
+					isShielded
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")) {
                     modelJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(modelJob);
-                } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
+                } else if (isShielded) {
-                    || m_World->HasComponent(cModel.EntityID, "Player")) {
 
                     if (modelJob->Color.a != 1.f || modelJob->DiffuseColor.a != 1.f) {
                         cModel["Transparent"] = true;
                     }
 
                     if (cModel["Transparent"]) {
-                        Jobs.TransparentShieldedObjects.push_back(modelJob);
+                        Jobs.TransparentObjects.push_back(modelJob);
                     } else {
 					    modelJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(modelJob);

src/Engine/Rendering/Renderer.cpp

@@ -110,7 +110,7 @@ void Renderer::Draw(RenderFrame& frame)
 {
     GLERROR("PRE");
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking\0Ambient Occlusion");
     ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
     if(m_CubeMapTexture == 0) {
         m_CubeMapPass->LoadTextures("Nevada");
@@ -174,7 +174,7 @@ void Renderer::Draw(RenderFrame& frame)
 
     if (m_DebugTextureToDraw == 0) {
         PerformanceTimer::StartTimer("Renderer-Color Correction Pass");
-        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), frame.Gamma, frame.Exposure);
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), frame.Gamma, frame.Exposure);
         PerformanceTimer::StopTimer("Renderer-Color Correction Pass");
     }
 
@@ -186,18 +186,12 @@ void Renderer::Draw(RenderFrame& frame)
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture());
     }
     if (m_DebugTextureToDraw == 3) {
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTextureLowRes());
-    }
-    if (m_DebugTextureToDraw == 4) {
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTextureLowRes());
-    }
-    if (m_DebugTextureToDraw == 5) {
         m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
     }
-    if (m_DebugTextureToDraw == 6) {
+    if (m_DebugTextureToDraw == 4) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
-	if (m_DebugTextureToDraw == 7) {
+	if (m_DebugTextureToDraw == 5) {
 		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
 	}
 	PerformanceTimer::StopTimer("Renderer-Misc Debug Draws");
@@ -250,7 +244,7 @@ void Renderer::InitializeRenderPasses()
     m_LightCullingPass = new LightCullingPass(this);
     m_CubeMapPass = new CubeMapPass(this);
 	m_SSAOPass = new SSAOPass(this, m_Config);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass, m_PickingPass->DepthBuffer());
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this, m_Config);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);

src/Game/Game.cpp

@@ -48,7 +48,6 @@ Game::Game(int argc, char* argv[])
     ResourceManager::UseThreading = m_Config->Get<bool>("Multithreading.ResourceLoading", true);
     DisableMemoryPool::Value = m_Config->Get<bool>("Debug.DisableMemoryPool", false);
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
-    PlayerSpawnSystem::SetRespawnTime(m_Config->Get<float>("Debug.RespawnTime", 15.0f));
 
     // Create the core event broker
     m_EventBroker = new EventBroker();
@@ -139,7 +138,6 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
-    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<HealthHUDSystem>(updateOrderLevel);
@@ -149,6 +147,9 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
+    // Octree for frustum culling must be updated after collisions, otherwise players frustum may be moved after tree is filled, and wrong things are culled.
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
     ++updateOrderLevel;

src/Game/Systems/PlayerMovementSystem.cpp

@@ -116,12 +116,18 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             }
 
-            //you cant jump and dash at the same time - since there is no friction in the air and we would thus dash much further in the air
-            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (isOnGround || !controller->DoubleJumping())) {
-                (bool)cPhysics["IsOnGround"] = false;
             if (isOnGround) {
                 controller->SetDoubleJumping(false);
-                } else {
+            }
+            //If player presses Jump and is not crouching.
+            if (controller->Jumping() && !controller->Crouching()) {
+                if (isOnGround) {
+                    (bool)cPhysics["IsOnGround"] = false;
+                    velocity.y = player["Player"]["JumpSpeed"];
+                } else if (player.HasComponent("DoubleJump") && !controller->DoubleJumping()) {
+                    //Enter here if player can double jump and is doing so.
+                    (bool)cPhysics["IsOnGround"] = false;
+                    velocity.y = player["DoubleJump"]["DoubleJumpSpeed"];
                     // If IsServer and network is off this will not work
                     if (IsClient) {
                         //put a hexagon at the players feet
@@ -133,7 +139,6 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                         m_EventBroker->Publish(e);
                     }
                 }
-                velocity.y = 4.f;
             }
 
             if (player.HasComponent("AABB")) {

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,27 +1,38 @@
 #include "Systems/PlayerSpawnSystem.h"
 
-//This should be set by the config anyway.
-float PlayerSpawnSystem::m_RespawnTime = 15.0f;
-
 PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params)
     : System(params)
-    , m_Timer(0.f)
+    , m_DbgConfigForceRespawn(false)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerSpawnSystem::OnPlayerDeath);
-    m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_NetworkEnabled = config->Get("Networking.StartNetwork", false);
+    m_ForcedRespawnTime = config->Get("Debug.RespawnTime", -1.0f);
+    m_DbgConfigForceRespawn = m_ForcedRespawnTime > 0;
 }
 
 void PlayerSpawnSystem::Update(double dt)
 {
+    // If there are no CapturePointGameMode components we will just spawn immediately.
+    // Should be able to support older maps with this.
+    // TODO: In the future we might want to return instead, to avoid spawning in the menu for instance.
+    auto pool = m_World->GetComponents("CapturePointGameMode");
+    if (pool != nullptr && pool->size() > 0)
+    {
+        // Take the first CapturePointGameMode component found.
+        ComponentWrapper& modeComponent = *pool->begin();
         // Increase timer.
-    m_Timer += dt;
+        double& timer = (double&)modeComponent["RespawnTime"];
-    if (m_Timer < m_RespawnTime) {
+        timer += dt;
+        double maxRespawnTime = m_DbgConfigForceRespawn ? m_ForcedRespawnTime : (double)modeComponent["MaxRespawnTime"];
+        if (timer < maxRespawnTime) {
             return;
         }
         // If respawn time has passed, we spawn all players that have requested to be spawned.
-    m_Timer = 0.f;
+        timer = 0;
+    }
 
     // If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty.
     if (m_SpawnRequests.size() == 0) {