Merge remote-tracking branch 'origin/master' into SplitSnapshots

2016-03-10 10:52:51 +01:00
parent 37355b1afc f26b24ef6b
commit 15c54d2be6
35 changed files with 2605 additions and 40 deletions
@@ -11,12 +11,13 @@
 #include "Util/UnorderedMapVec2.h"
 #include "Util/CommonFunctions.h"
 #include "Texture.h"
+#include "ShadowPass.h"
 #include "BlurHUD.h"

 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, ShadowPass* shadowPass);
 	~DrawFinalPass();
    void InitializeTextures();
    void InitializeFrameBuffers();
@@ -72,6 +73,7 @@ private:
    const LightCullingPass* m_LightCullingPass;
    const CubeMapPass* m_CubeMapPass;
 	const SSAOPass* m_SSAOPass;
+	const ShadowPass* m_ShadowPass;

    ShaderProgram* m_ForwardPlusProgram;
    ShaderProgram* m_ExplosionEffectProgram;
@@ -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, bool isShielded)
-        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded)
+    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded, bool shadow)
+        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded, shadow)
    {
        ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
        TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];
@@ -43,6 +43,16 @@ public:
    ~RenderBuffer();
 };

+class Texture2DArray : public ResourceType<GL_TEXTURE_2D_ARRAY>
+{
+public:
+	Texture2DArray(GLuint* resourceHandle, GLenum attachment)
+		: ResourceType(resourceHandle, attachment)
+	{ };
+
+	~Texture2DArray();
+};
+
 class FrameBuffer
 {
 public:
@@ -19,7 +19,7 @@

 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded, bool shadow)
        : RenderJob()
    {
        Model = model;
@@ -115,6 +115,7 @@ struct ModelJob : RenderJob
        glm::vec3 worldpos = glm::vec3(camera->ViewMatrix() * glm::vec4(abspos, 1));
        Depth = worldpos.z;
        World = world;
+		Shadow = shadow;

        FillColor = fillColor;
        FillPercentage = fillPercentage;
@@ -162,6 +163,8 @@ struct ModelJob : RenderJob
    glm::vec4 FillColor = glm::vec4(0);
    float FillPercentage = 0.0;
 	bool IsShielded;
+	bool Shadow;
+
    void CalculateHash() override
    {
 		Hash = TextureID;
@@ -27,6 +27,7 @@
 #include "TextPass.h"
 #include "Util/CommonFunctions.h"
 #include "Core/PerformanceTimer.h"
+#include "ShadowPass.h"

 class Renderer : public IRenderer
 {
@@ -77,6 +78,7 @@ private:
    DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 	SSAOPass* m_SSAOPass;
    CubeMapPass* m_CubeMapPass;
+	ShadowPass* m_ShadowPass;
    BlurHUD* m_BlurHUDPass;

    //----------------------Functions----------------------//
@@ -0,0 +1,88 @@
+#ifndef ShadowPass_h__
+#define ShadowPass_h__
+
+#include "IRenderer.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "../Core/EventBroker.h"
+#include "../Core/World.h"
+#include "ShadowPassState.h"
+#include "imgui/imgui.h"
+
+#define MAX_SPLITS 4
+
+enum NearFar { NEAR = 0, FAR = 1 };
+enum LRBT { LEFT = 0, RIGHT = 1, BOTTOM = 2, TOP = 3 };
+
+struct ShadowFrustum
+{
+	float NearClip;
+	float FarClip;
+	float FOV;
+	float AspectRatio;
+	glm::vec3 MiddlePoint;
+	float Radius;
+	std::array<float, 4> LRBT;
+	std::array<glm::vec3, 8> CornerPoint;
+};
+
+class ShadowPass
+{
+public:
+	ShadowPass(IRenderer* renderer);
+	ShadowPass(IRenderer * renderer, int ShadowResX, int ShadowResY);
+	~ShadowPass();
+
+	void InitializeFrameBuffers();
+	void InitializeShaderPrograms();
+	void ClearBuffer();
+	void Draw(RenderScene& scene);
+
+	void DebugGUI();
+
+	GLuint DepthMap() const { return m_DepthMap; }
+	std::array<glm::mat4, MAX_SPLITS> LightP() const { return m_LightProjection; }
+	std::array<glm::mat4, MAX_SPLITS> LightV() const { return m_LightView; }
+	std::array<float, MAX_SPLITS> FarDistance() const { std::array<float, MAX_SPLITS> f; for (int i = 0; i < MAX_SPLITS; i++) f[i] = m_shadowFrusta[i].FarClip; return f; }
+	int CurrentNrOfSplits() const { return m_CurrentNrOfSplits; }
+
+	void SetSplitWeight(float split_weight) { m_SplitWeight = split_weight; };
+private:
+	void InitializeCameras(RenderScene & scene);
+	void UpdateSplitDist(std::array<ShadowFrustum, MAX_SPLITS>& frusta, float near_distance, float far_distance);
+	void UpdateFrustumPoints(ShadowFrustum& frustum, glm::vec3 camera_position, glm::vec3 view_dir);
+	void UpdateFrustumPoints(ShadowFrustum& frustum, glm::mat4 p, glm::mat4 v);
+
+	void PointsToLightspace(ShadowFrustum& frustum, glm::mat4 v);
+
+	float FindRadius(ShadowFrustum& frustum);
+	void RadiusToLightspace(ShadowFrustum& frustum);
+
+	EventBroker* m_EventBroker;
+	const IRenderer* m_Renderer;
+
+	GLuint m_DepthMap;
+	FrameBuffer m_DepthBuffer;
+    ShaderProgram* m_ShadowProgram;
+    ShaderProgram* m_ShadowProgramSkinned;
+
+	std::array<glm::mat4, MAX_SPLITS> m_LightProjection;
+	std::array<glm::mat4, MAX_SPLITS> m_LightView;
+
+	GLfloat m_NearFarPlane[2] = { -34.f, 27.f };
+	GLuint m_ResolutionSizeWidth = 1024 * 2;
+	GLuint m_ResolutionSizeHeight = 1024 * 2;
+
+	bool m_TransparentObjects = false;
+	bool m_TexturedShadows = false;
+	bool m_EnableShadows = true;
+
+	int m_CurrentNrOfSplits = 4;
+	float m_SplitWeight = 0.962f;
+
+	std::array<ShadowFrustum, MAX_SPLITS> m_shadowFrusta;
+
+	Texture* m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/White.png");
+};
+
+#endif
@@ -0,0 +1,15 @@
+#ifndef ShadowPassState_h_
+#define ShadowPassState_h_
+
+#include "Rendering/RenderState.h"
+
+class ShadowPassState : public RenderState
+{
+public:
+	ShadowPassState(GLuint frameBuffer);
+	~ShadowPassState();
+
+private:
+};
+
+#endif
@@ -8,5 +8,6 @@
 	<NormalMap>true</NormalMap>
 	<SpecularMap>true</SpecularMap>
 	<GlowMap>true</GlowMap>
+	<Shadow>true</Shadow>
 	<GlowIntensity>3.0</GlowIntensity>
 </Model>
@@ -36,6 +36,9 @@
 				<xs:element name="GlowIntensity" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>Intensity of the glow map</xs:documentation></xs:annotation>
 				</xs:element>
+				<xs:element name="Shadow" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Whether the object cast/recieve shadows or not</xs:documentation></xs:annotation>
+				</xs:element>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>
@@ -245,6 +245,13 @@
        </Entity>
      </Children>
    </Entity>
+    <Entity name="Ambient">
+      <Components>
+        <c:SceneLight/>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
  </Children>

 </Entity>
@@ -553,8 +553,8 @@
        <Entity name="Cube1">
          <Components>
            <c:Model>
-              <Resource>Models/Core/UnitCube.mesh</Resource>
-              <Color A="0.505882382" B="0" G="1" R="0"/>
+              <Resource>Models/BushAlive.mesh</Resource>
+              <Color A="1" B="0" G="1" R="0"/>
              <Transparent>true</Transparent>
            </c:Model>
            <c:Transform>
@@ -1,5 +1,7 @@
 #version 430

+#define MAX_SPLITS 4
+
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
@@ -22,6 +24,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input[];

 out VertexData{
@@ -32,6 +35,7 @@ out VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Output;

 layout(triangles) in;
@@ -145,6 +149,10 @@ void main()
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
 			Output.Tangent = Input[i].Tangent;
 			Output.BiTangent = Input[i].BiTangent;
+			for (int j = 0; j < MAX_SPLITS; j++)
+			{
+				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
+			}
 			
 			// convert to model space for the gravity to always be in -y
 			vec4 ExplodedPositionInModelSpace = M * vec4(ExplodedPosition, 1.0);
@@ -186,6 +194,10 @@ void main()
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
 			Output.Tangent = Input[i].Tangent;
 			Output.BiTangent = Input[i].BiTangent;
+			for (int j = 0; j < MAX_SPLITS; j++)
+			{
+				Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
+			}

 			// no change in position, pass through vertex
 			gl_Position = gl_in[i].gl_Position;
@@ -1,6 +1,7 @@
 #version 430

 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4

 uniform mat4 VM;
 uniform mat4 M;
@@ -15,6 +16,7 @@ uniform float FillPercentage;
 uniform float GlowIntensity;
 uniform vec3 CameraPosition;
 uniform int SSAOQuality;
+uniform float FarDistance[MAX_SPLITS];

 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
@@ -26,6 +28,7 @@ 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 = 30) uniform sampler2DArrayShadow DepthMap;

 #define TILE_SIZE 16

@@ -60,7 +63,6 @@ layout (std430, binding = 4) buffer LightIndexBuffer
 	float LightIndex[];
 };

-
 in VertexData{
 	vec3 Position;
 	vec3 Normal;
@@ -69,6 +71,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;

 out vec4 sceneColor;
@@ -79,6 +82,25 @@ struct LightResult {
 	vec4 Specular;
 };

+vec2 poissonDisk[16] = vec2[]( 
+	vec2( -0.94201624, -0.39906216 ), 
+	vec2( 0.94558609, -0.76890725 ), 
+	vec2( -0.094184101, -0.92938870 ), 
+	vec2( 0.34495938, 0.29387760 ), 
+	vec2( -0.91588581, 0.45771432 ), 
+	vec2( -0.81544232, -0.87912464 ), 
+	vec2( -0.38277543, 0.27676845 ), 
+	vec2( 0.97484398, 0.75648379 ), 
+	vec2( 0.44323325, -0.97511554 ), 
+	vec2( 0.53742981, -0.47373420 ), 
+	vec2( -0.26496911, -0.41893023 ), 
+	vec2( 0.79197514, 0.19090188 ), 
+	vec2( -0.24188840, 0.99706507 ), 
+	vec2( -0.81409955, 0.91437590 ), 
+	vec2( 0.19984126, 0.78641367 ), 
+	vec2( 0.14383161, -0.14100790 ) 
+	);
+
 float CalcAttenuation(float radius, float dist, float falloff) {
 	return 1.0 - smoothstep(radius * falloff, radius, dist);
 }
@@ -125,6 +147,154 @@ vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textu
 	return vec4(TBN * normalize(NormalMap), 0.0);
 }

+// Returns a "random" value.
+float Random(vec3 seed, int i)
+{
+	vec4 seed4 = vec4(seed, i);
+	float dot_product = dot(seed4, vec4(12.9898, 78.233, 45.164, 94.673));
+	return fract(sin(dot_product) * 43758.5453);
+}
+
+int getShadowIndex(float far_distance[1])
+{
+	return 0;
+}
+
+int getShadowIndex(float far_distance[2])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 1;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[3])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 2;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[4])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 3;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+	else if ( depth < far_distance[2] && depth > far_distance[1] )
+	{
+		index = 2;
+	}
+
+	return index;
+}
+
+// Standard hardware-calculated PCF method
+float PCFShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index)
+{
+	return texture(depth_texture_array, vec4(projection_coords.xy, layer_index, projection_coords.z));
+}
+
+// PCF + Poisson model method
+float PoissonShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, int taps, float spread)
+{
+	int loop;
+	float multiplier = 1.0 / float(taps);
+	float shadowMapDepth;
+	
+    for (int i = 0; i < taps; i++)
+	{
+		loop = i;
+		vec3 newProjCoords = projection_coords + vec3(poissonDisk[loop], 0.0) / (spread * (1.0 + layer_index));
+		shadowMapDepth += multiplier * texture(depth_texture_array, vec4(newProjCoords.xy, layer_index, newProjCoords.z));
+	}
+	
+	return shadowMapDepth;
+}
+
+// PCF + Poisson + RandomSample model method
+float PoissonDotShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, int taps, float spread)
+{
+	int loop;
+	float multiplier = 1.0 / float(taps);
+	float shadowMapDepth;
+	
+    for (int i = 0; i < taps; i++)
+	{
+		loop = int(16.0 * Random(gl_FragCoord.xyy, i)) % 16;
+		vec3 newProjCoords = projection_coords + vec3(poissonDisk[loop], 0.0) / (spread * (1.0 + layer_index));
+		shadowMapDepth += multiplier * texture(depth_texture_array, vec4(newProjCoords.xy, layer_index, newProjCoords.z));
+	}
+	
+	return shadowMapDepth;
+}
+
+// Hardware PCF + Additional software PCF method
+float SoftwarePCF(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, float bias)
+{
+	float shadow = 0.0;
+	
+	vec3 texelSize = 1.0 / textureSize(depth_texture_array, 0);
+	for(int x = -1; x <= 1; x++)
+	{
+		for(int y = -1; y <= 1; y++)
+		{
+			shadow += texture(depth_texture_array, vec4(projection_coords.xy + vec2(x, y) * texelSize.xy / (1.0 + layer_index), layer_index, projection_coords.z)); 
+		}    
+	}
+	
+	return shadow / 9.0;
+}
+
+float CalcShadowValue(vec4 light_space_pos, vec3 normal, vec3 light_dir, sampler2DArrayShadow depth_texture_array, int layer_index)
+{
+	float shadowMapDepth;
+	float bias = 0.005;
+	
+	// Various bias methods.
+	
+	//bias = max(0.05 * (1.0 - dot(normal, light_dir)), bias);
+	//bias = bias * tan(acos(clamp(dot(normal, -light_dir), 0.0, 1.0)));
+	bias = bias + bias * tan(acos(clamp(dot(normal, -light_dir), 0.0, 1.0)));
+	
+	// Calculate coordinates in projection space.
+	
+    vec3 projCoords = vec3(light_space_pos.xy, light_space_pos.z + bias) / light_space_pos.w;
+    projCoords = projCoords * 0.5 + 0.5;
+	//projCoords = (floor(projCoords * 255.0)) / 255.0;
+	
+	// Various methods for shadow calculation in fastest to slowest order.
+	
+	//shadowMapDepth = PCFShadow(depth_texture_array, projCoords, layer_index);
+	//shadowMapDepth = PoissonShadow(depth_texture_array, projCoords, layer_index, 4, 25.0 * FarDistance[MAX_SPLITS - 1]);
+	//shadowMapDepth = PoissonDotShadow(depth_texture_array, projCoords, layer_index, 4, 25.0 * FarDistance[MAX_SPLITS - 1]);
+	shadowMapDepth = SoftwarePCF(depth_texture_array, projCoords, layer_index, bias);
+
+    return shadowMapDepth;
+}
+
 void main()
 {
 	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
@@ -153,6 +323,8 @@ void main()
 	int start = int(LightGrids.Data[currentTile].Start);
 	int amount = int(LightGrids.Data[currentTile].Amount);
 	
+	float shadowFactor = 0.0;
+
 	for(int i = start; i < start + amount; i++) {

 		int l = int(LightIndex[i]);
@@ -163,12 +335,17 @@ void main()
 		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
+			int DepthMapIndex = getShadowIndex(FarDistance);
 			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+			shadowFactor = CalcShadowValue(Input.PositionLightSpace[DepthMapIndex], Input.Normal, vec3(light.Direction), DepthMap, DepthMapIndex);
 		}
 		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
 		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
 	}
 	
+	totalLighting.Diffuse *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
+	totalLighting.Specular *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
+
 	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;
@@ -1,9 +1,13 @@
 #version 430
 uniform mat4 PVM;
+#define MAX_SPLITS 4
 uniform mat4 TIM;
+
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
+uniform mat4 LightV[MAX_SPLITS];
+uniform mat4 LightP[MAX_SPLITS];

 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
@@ -19,6 +23,7 @@ out VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Output;

 void main()
@@ -32,4 +37,9 @@ void main()
 	Output.BiTangent = vec3(TIM * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
+	
+	for(int i = 0; i < MAX_SPLITS; i++)
+	{
+		Output.PositionLightSpace[i] = LightP[i] * LightV[i] * M * vec4(Position, 1.0);
+	}
 }
@@ -1,6 +1,7 @@
 #version 430

 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4

 uniform mat4 VM;
 uniform mat4 M;
@@ -70,6 +71,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;

 out vec4 sceneColor;
@@ -1,11 +1,15 @@
 #version 430

+#define MAX_SPLITS 4
+
 uniform mat4 PVM;
 uniform mat4 TIM;
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
 uniform mat4 Bones[100];
+uniform mat4 LightV[MAX_SPLITS];
+uniform mat4 LightP[MAX_SPLITS];

 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
@@ -23,6 +27,7 @@ out VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Output;

 void main()
@@ -45,4 +50,9 @@ void main()
 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
+	
+	for(int i = 0; i < MAX_SPLITS; i++)
+	{
+		Output.PositionLightSpace[i] = LightP[i] * LightV[i] * M * boneTransform * vec4(Position, 1.0);
+	}
 }
@@ -1,5 +1,7 @@
 #version 430

+#define MAX_SPLITS 4
+
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
@@ -95,6 +97,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;

 out vec4 sceneColor;
@@ -1,6 +1,7 @@
 #version 430

 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4

 uniform mat4 VM;
 uniform mat4 M;
@@ -13,6 +14,10 @@ uniform vec4 FillColor;
 uniform vec4 Color;
 uniform vec4 AmbientColor;
 uniform int SSAOQuality;
+uniform float FarDistance[MAX_SPLITS];
+
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 30) uniform sampler2DArrayShadow DepthMap;

 //Get bineded at the same time as the textures
 uniform vec2 DiffuseUVRepeat1;
@@ -27,7 +32,6 @@ 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;
@@ -84,6 +88,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;

 out vec4 sceneColor;
@@ -94,6 +99,25 @@ struct LightResult {
 	vec4 Specular;
 };

+vec2 poissonDisk[16] = vec2[]( 
+	vec2( -0.94201624, -0.39906216 ), 
+	vec2( 0.94558609, -0.76890725 ), 
+	vec2( -0.094184101, -0.92938870 ), 
+	vec2( 0.34495938, 0.29387760 ), 
+	vec2( -0.91588581, 0.45771432 ), 
+	vec2( -0.81544232, -0.87912464 ), 
+	vec2( -0.38277543, 0.27676845 ), 
+	vec2( 0.97484398, 0.75648379 ), 
+	vec2( 0.44323325, -0.97511554 ), 
+	vec2( 0.53742981, -0.47373420 ), 
+	vec2( -0.26496911, -0.41893023 ), 
+	vec2( 0.79197514, 0.19090188 ), 
+	vec2( -0.24188840, 0.99706507 ), 
+	vec2( -0.81409955, 0.91437590 ), 
+	vec2( 0.19984126, 0.78641367 ), 
+	vec2( 0.14383161, -0.14100790 ) 
+	);
+
 float CalcAttenuation(float radius, float dist, float falloff) {
 	return 1.0 - smoothstep(radius * 0.3, radius, dist);
 }
@@ -177,6 +201,154 @@ vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
 	return vec4(TBN * normalize(Normal_result), 0.0);
 }

+// Returns a "random" value.
+float Random(vec3 seed, int i)
+{
+	vec4 seed4 = vec4(seed, i);
+	float dot_product = dot(seed4, vec4(12.9898, 78.233, 45.164, 94.673));
+	return fract(sin(dot_product) * 43758.5453);
+}
+
+int getShadowIndex(float far_distance[1])
+{
+	return 0;
+}
+
+int getShadowIndex(float far_distance[2])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 1;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[3])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 2;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[4])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 3;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+	else if ( depth < far_distance[2] && depth > far_distance[1] )
+	{
+		index = 2;
+	}
+
+	return index;
+}
+
+// Standard hardware-calculated PCF method
+float PCFShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index)
+{
+	return texture(depth_texture_array, vec4(projection_coords.xy, layer_index, projection_coords.z));
+}
+
+// PCF + Poisson model method
+float PoissonShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, int taps, float spread)
+{
+	int loop;
+	float multiplier = 1.0 / float(taps);
+	float shadowMapDepth;
+	
+    for (int i = 0; i < taps; i++)
+	{
+		loop = i;
+		vec3 newProjCoords = projection_coords + vec3(poissonDisk[loop], 0.0) / (spread * (1.0 + layer_index));
+		shadowMapDepth += multiplier * texture(depth_texture_array, vec4(newProjCoords.xy, layer_index, newProjCoords.z));
+	}
+	
+	return shadowMapDepth;
+}
+
+// PCF + Poisson + RandomSample model method
+float PoissonDotShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, int taps, float spread)
+{
+	int loop;
+	float multiplier = 1.0 / float(taps);
+	float shadowMapDepth;
+	
+    for (int i = 0; i < taps; i++)
+	{
+		loop = int(16.0 * Random(gl_FragCoord.xyy, i)) % 16;
+		vec3 newProjCoords = projection_coords + vec3(poissonDisk[loop], 0.0) / (spread * (1.0 + layer_index));
+		shadowMapDepth += multiplier * texture(depth_texture_array, vec4(newProjCoords.xy, layer_index, newProjCoords.z));
+	}
+	
+	return shadowMapDepth;
+}
+
+// Hardware PCF + Additional software PCF method
+float SoftwarePCF(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index, float bias)
+{
+	float shadow = 0.0;
+	
+	vec3 texelSize = 1.0 / textureSize(depth_texture_array, 0);
+	for(int x = -1; x <= 1; x++)
+	{
+		for(int y = -1; y <= 1; y++)
+		{
+			shadow += texture(depth_texture_array, vec4(projection_coords.xy + vec2(x, y) * texelSize.xy / (1.0 + layer_index), layer_index, projection_coords.z)); 
+		}    
+	}
+	
+	return shadow / 9.0;
+}
+
+float CalcShadowValue(vec4 light_space_pos, vec3 normal, vec3 light_dir, sampler2DArrayShadow depth_texture_array, int layer_index)
+{
+	float shadowMapDepth;
+	float bias = 0.005;
+	
+	// Various bias methods.
+	
+	//bias = max(0.05 * (1.0 - dot(normal, light_dir)), bias);
+	//bias = bias * tan(acos(clamp(dot(normal, -light_dir), 0.0, 1.0)));
+	bias = bias + bias * tan(acos(clamp(dot(normal, -light_dir), 0.0, 1.0)));
+	
+	// Calculate coordinates in projection space.
+	
+    vec3 projCoords = vec3(light_space_pos.xy, light_space_pos.z + bias) / light_space_pos.w;
+    projCoords = projCoords * 0.5 + 0.5;
+	//projCoords = (floor(projCoords * 255.0)) / 255.0;
+	
+	// Various methods for shadow calculation in fastest to slowest order.
+	
+	//shadowMapDepth = PCFShadow(depth_texture_array, projCoords, layer_index);
+	//shadowMapDepth = PoissonShadow(depth_texture_array, projCoords, layer_index, 4, 25.0 * FarDistance[MAX_SPLITS - 1]);
+	//shadowMapDepth = PoissonDotShadow(depth_texture_array, projCoords, layer_index, 4, 25.0 * FarDistance[MAX_SPLITS - 1]);
+	shadowMapDepth = SoftwarePCF(depth_texture_array, projCoords, layer_index, bias);
+
+    return shadowMapDepth;
+}
+
 void main()
 {
 	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
@@ -209,6 +381,8 @@ void main()
 	int start = int(LightGrids.Data[currentTile].Start);
 	int amount = int(LightGrids.Data[currentTile].Amount);

+	float shadowFactor = 0.0;
+
 	for(int i = start; i < start + amount; i++) {

 		int l = int(LightIndex[i]);
@@ -219,12 +393,17 @@ void main()
 		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
+			int DepthMapIndex = getShadowIndex(FarDistance);
 			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+			shadowFactor = CalcShadowValue(Input.PositionLightSpace[DepthMapIndex], Input.Normal, vec3(light.Direction), DepthMap, DepthMapIndex);
 		}
 		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
 		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
 	}

+	totalLighting.Diffuse *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
+	totalLighting.Specular *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
+
 	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;
@@ -1,6 +1,7 @@
 #version 430

 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4

 uniform mat4 VM;
 uniform mat4 M;
@@ -85,6 +86,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;

 out vec4 sceneColor;
@@ -0,0 +1,22 @@
+#version 430
+
+#define ALPHA_CUTOFF 0.3
+
+layout (binding = 24) uniform sampler2D DiffuseTexture;
+uniform float Alpha;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+layout (location = 0) out float ShadowMap;
+
+void main()
+{
+	vec4 diffuseTexel = texture(DiffuseTexture, Input.TextureCoordinate) * Alpha;
+	
+	if (diffuseTexel.a < ALPHA_CUTOFF)
+	{
+		discard;
+	}
+}
@@ -0,0 +1,18 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout (location = 0) in vec3 Position;
+layout (location = 4) in vec2 TextureCoords;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{	
+	gl_Position = P * V * M * vec4(Position, 1.0);
+	Output.TextureCoordinate = TextureCoords;
+}
@@ -0,0 +1,29 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout (location = 0) in vec3 Position;
+layout (location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{	
+	mat4 boneTransform = mat4(1);
+	if(BoneWeights[0] > 0.0f){
+	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
+				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
+				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
+				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
+	}
+
+	gl_Position = P * V * M * boneTransform * vec4(Position, 1.0);
+	Output.TextureCoordinate = TextureCoords;
+}
@@ -24,7 +24,7 @@ glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
    while (entity != EntityID_Invalid) {
        ComponentWrapper transform = world->GetComponent(entity, "Transform");
        EntityID parent = world->GetParent(entity);
-        position += Transform::AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"];
+        position += Transform::AbsoluteScale(world, parent) * (Transform::AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"]);
        entity = parent;
    }

@@ -89,12 +89,12 @@ glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
 {
    return AbsoluteTransformation(EntityWrapper(world, entity));

-    glm::vec3 position = Transform::AbsolutePosition(world, entity);
-    glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
-    glm::vec3 scale = Transform::AbsoluteScale(world, entity);
+    //glm::vec3 position = Transform::AbsolutePosition(world, entity);
+    //glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
+    //glm::vec3 scale = Transform::AbsoluteScale(world, entity);

-    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
-    return modelMatrix;
+    //glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
+    //return modelMatrix;
 }

 glm::vec3 Transform::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
@@ -7,7 +7,7 @@ EditorRenderSystem::EditorRenderSystem(SystemParams params, IRenderer* renderer,
 {
    EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &EditorRenderSystem::OnSetCamera);
    auto resolution = Rectangle::Rectangle(1280, 720);
-    m_EditorCamera = new Camera((float)resolution.Width / resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
+    m_EditorCamera = new Camera((float)resolution.Width / resolution.Height, glm::radians(45.f), 0.001f, 500.f);
 }

 void EditorRenderSystem::Update(double dt)
@@ -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, false);
+                std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f, false, false);
                if (cModel["Transparent"]) {
                    scene.Jobs.TransparentObjects.push_back(modelJob);
                } else {
@@ -204,14 +204,21 @@ bool EditorSystem::OnWidgetDelta(const Events::WidgetDelta& e)
    if (m_CurrentSelection.Valid()) {
        if (m_WidgetSpace == EditorGUI::WidgetSpace::Global) {
            glm::quat parentOrientation;
+            glm::vec3 parentScale(1.f);
            EntityWrapper parent = m_CurrentSelection.Parent();
            if (parent.Valid()) {
                parentOrientation = glm::inverse(Transform::AbsoluteOrientation(parent));
+                parentScale = Transform::AbsoluteScale(parent);
            }
-            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation;
+            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation / parentScale;
        } else if (m_WidgetSpace == EditorGUI::WidgetSpace::Local) {
+            glm::vec3 parentScale(1.f);
+            EntityWrapper parent = m_CurrentSelection.Parent();
+            if (parent.Valid()) {
+                parentScale = Transform::AbsoluteScale(parent);
+            }
            glm::quat selectionOri = glm::quat((glm::vec3)m_CurrentSelection["Transform"]["Orientation"]);
-            glm::vec3 localTranslation = selectionOri * e.Translation;
+            glm::vec3 localTranslation = selectionOri * e.Translation / parentScale;
            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += localTranslation;
        }
        m_EditorGUI->SetDirty(m_CurrentSelection);
@@ -127,12 +127,12 @@ void AnimationSystem::UpdateAnimations(double dt)
 void AnimationSystem::UpdateWeights(double dt)
 {
    for (auto it = m_AutoBlendQueues.begin(); it != m_AutoBlendQueues.end(); ) {
-        LOG_INFO("%s", it->first.Name().c_str());
-        it->second.PrintQueue();
+       /* LOG_INFO("%s", it->first.Name().c_str());
+        it->second.PrintQueue();*/
        
        if(it->second.HasActiveBlendJob()) {
            AutoBlendQueue::AutoBlendJob& blendJob = it->second.GetActiveBlendJob();
-            LOG_INFO("%s", blendJob.RootNode.Name().c_str());
+            //LOG_INFO("%s", blendJob.RootNode.Name().c_str());
            std::shared_ptr<BlendTree> blendTree = it->second.GetBlendTree();
            if (blendTree != nullptr) {
                if (blendJob.Duration != 0.0) {
@@ -1,9 +1,10 @@
 #include "Rendering/DrawFinalPass.h"
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass)
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, ShadowPass* shadowPass)
 	: m_Renderer(renderer)
 	, m_LightCullingPass(lightCullingPass)
 	, m_CubeMapPass(cubeMapPass)
 	, m_SSAOPass(ssaoPass)
+	, m_ShadowPass(shadowPass)
 {
    //TODO: Make sure that uniforms are not sent into shader if not needed.
    m_ShieldPixelRate = 8;
@@ -369,6 +370,13 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_SSAOPass->SSAOTexture());

+	glActiveTexture(GL_TEXTURE30);
+	if (m_ShadowPass->DepthMap() != NULL) {
+		glBindTexture(GL_TEXTURE_2D_ARRAY, m_ShadowPass->DepthMap());
+	} else {
+		glBindTexture(GL_TEXTURE_2D_ARRAY, m_WhiteTexture->m_Texture);
+	}
+
    for (auto &job : jobs) {
        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
        if (explosionEffectJob) {
@@ -1339,6 +1347,10 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
    glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
 	GLERROR("Bind 19 uniform");
    glUniform1f(glGetUniformLocation(shaderHandle, "GlowIntensity"), job->GlowIntensity);
+
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightV().data()));
+	glUniform1fv(glGetUniformLocation(shaderHandle, "FarDistance"), MAX_SPLITS, m_ShadowPass->FarDistance().data());
    GLERROR("END");
 }

@@ -1366,9 +1378,12 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 	GLint Location_Color = glGetUniformLocation(shaderHandle, "Color");
 	glUniform4fv(Location_Color, 1, glm::value_ptr(job->Color));
    GLint Location_GlowIntensity = glGetUniformLocation(shaderHandle, "GlowIntensity");
-
 	glUniform1f(Location_GlowIntensity, job->GlowIntensity);

+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightV().data()));
+	glUniform1fv(glGetUniformLocation(shaderHandle, "FarDistance"), MAX_SPLITS, m_ShadowPass->FarDistance().data());
+
 	GLERROR("END");
 }

@@ -24,6 +24,13 @@ RenderBuffer::~RenderBuffer()
    }
 }

+Texture2DArray::~Texture2DArray()
+{
+	if (m_ResourceHandle != 0) {
+		glDeleteTextures(1, m_ResourceHandle);
+	}
+}
+

 FrameBuffer::~FrameBuffer()
 {
@@ -53,12 +60,15 @@ void FrameBuffer::Generate()
 		case GL_TEXTURE_2D:
 			glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
 			GLERROR("FrameBuffer generate: glFramebufferTexture2D");
-
 			break;
 		case GL_RENDERBUFFER:
 			glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
 			GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
 			break;
+		case GL_TEXTURE_2D_ARRAY:
+			glFramebufferTexture(GL_FRAMEBUFFER, (*it)->m_Attachment, *(*it)->m_ResourceHandle, 0);
+			GLERROR("FrameBuffer generate: glFramebufferTexture2DArray");
+			break;
 		}
 		GLERROR("2");

@@ -219,7 +219,7 @@ void PickingPass::Draw(RenderScene& scene)
 					m_PickingSkinnedProgram->Bind();
 					lastShader = m_PickingSkinnedProgram->GetHandle();
 				}
-				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
+				glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));

                std::vector<glm::mat4> frameBones;
@@ -258,7 +258,8 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                    m_World, 
                    fillColor, 
                    fillPercentage,
-					isShielded
+					isShielded,
+					false
                ));
                if (m_World->HasComponent(cModel.EntityID, "Shield")){
                    explosionEffectJob->CalculateHash();
@@ -296,7 +297,8 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                    m_World, 
                    fillColor, 
                    fillPercentage,
-					isShielded
+					isShielded,
+					(bool)cModel["Shadow"]
                ));
                if (m_World->HasComponent(cModel.EntityID, "Shield")) {
                    modelJob->CalculateHash();
@@ -146,7 +146,9 @@ void Renderer::Draw(RenderFrame& frame)
    m_DrawFinalPass->ClearBuffer();
    m_DrawBloomPass->ClearBuffer();
 	m_SSAOPass->ClearBuffer();
+	m_ShadowPass->ClearBuffer();
    m_BlurHUDPass->ClearBuffer();
+	m_ShadowPass->DebugGUI();
    PerformanceTimer::StopTimer("Renderer-ClearBuffers");
    GLERROR("ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
@@ -162,6 +164,9 @@ void Renderer::Draw(RenderFrame& frame)
        PerformanceTimer::StartTimer("Renderer-Depth");
        SortRenderJobsByDepth(*scene);
        GLERROR("SortByDepth");
+		PerformanceTimer::StartTimerAndStopPrevious("Draw shadow maps");
+		m_ShadowPass->Draw(*scene);
+		GLERROR("Draw shadow maps");
        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Generate Frustrums");
        m_LightCullingPass->GenerateNewFrustum(*scene);
        GLERROR("Generate frustums");
@@ -264,8 +269,9 @@ void Renderer::InitializeRenderPasses()
    m_LightCullingPass = new LightCullingPass(this);
    m_CubeMapPass = new CubeMapPass(this);
 	m_SSAOPass = new SSAOPass(this, m_Config);
+	m_ShadowPass = new ShadowPass(this);
    m_BlurHUDPass = new BlurHUD(this);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass, m_ShadowPass);
    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
    m_DrawBloomPass = new DrawBloomPass(this, m_Config);
    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
@@ -0,0 +1,365 @@
+#include "Rendering/ShadowPass.h"
+
+ShadowPass::ShadowPass(IRenderer * renderer, int shadow_res_x, int shadow_res_y)
+{
+	m_Renderer = renderer;
+	m_ResolutionSizeWidth = shadow_res_x;
+	m_ResolutionSizeHeight = shadow_res_y;
+
+	InitializeFrameBuffers();
+	InitializeShaderPrograms();
+}
+
+ShadowPass::ShadowPass(IRenderer * renderer)
+{
+	m_Renderer = renderer;
+
+	InitializeFrameBuffers();
+	InitializeShaderPrograms();
+}
+
+ShadowPass::~ShadowPass()
+{
+
+}
+
+void ShadowPass::DebugGUI()
+{
+	ImGui::Checkbox("EnableShadows", &m_EnableShadows);
+	ImGui::DragFloat2("ShadowMapNearFar", m_NearFarPlane, 1.f, -1000.f, 1000.f);
+	ImGui::DragFloat("ShadowClippingWeight", &m_SplitWeight, 0.001f, 0.f, 1.f);
+	ImGui::Checkbox("ShadowTransparentObjects", &m_TransparentObjects);
+	ImGui::Checkbox("ShadowOnTextureAlphas", &m_TexturedShadows);
+}
+
+void ShadowPass::InitializeCameras(RenderScene & scene)
+{
+	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
+		m_shadowFrusta[i].AspectRatio = scene.Camera->AspectRatio();
+		m_shadowFrusta[i].FOV = scene.Camera->FOV();
+	}
+}
+
+// UpdateSplitDist computes the near and far distances for every frustum slice
+// in camera eye space - that is, at what distance does a slice start and end
+void ShadowPass::UpdateSplitDist(std::array<ShadowFrustum, MAX_SPLITS>& frusta, float near_distance, float far_distance)
+{
+	float lambda = m_SplitWeight;
+	float ratio = far_distance / near_distance;
+
+	frusta[0].NearClip = near_distance;
+
+	for (int i = 1; i < m_CurrentNrOfSplits; i++) {
+		float si = i / static_cast<float>(m_CurrentNrOfSplits);
+
+		frusta[i].NearClip = lambda * (near_distance * powf(ratio, si)) + (1 - lambda) * (near_distance + (far_distance - near_distance) * si);
+		frusta[i - 1].FarClip = frusta[i].NearClip * 1.005f;
+	}
+
+	frusta[m_CurrentNrOfSplits - 1].FarClip = far_distance;
+}
+
+void ShadowPass::UpdateFrustumPoints(ShadowFrustum& frustum, glm::mat4 p, glm::mat4 v)
+{
+	std::array<glm::vec4, 8> CornerPoint = {
+		glm::vec4(-1.f, -1.f,	-1.f,	1.f),
+		glm::vec4(-1.f, 1.f,	-1.f,	1.f),
+		glm::vec4(1.f,	1.f,	-1.f,	1.f),
+		glm::vec4(1.f,	-1.f,	-1.f,	1.f),
+		glm::vec4(-1.f,	-1.f,	1.f,	1.f),
+		glm::vec4(-1.f,	1.f,	1.f,	1.f),
+		glm::vec4(1.f,	1.f,	1.f,	1.f),
+		glm::vec4(1.f,	-1.f,	1.f,	1.f)
+	};
+
+	for (int i = 0; i < 8; i++) {
+		glm::vec4 NDC = glm::inverse(p) * CornerPoint[i];
+		NDC = NDC / NDC.w;
+		frustum.CornerPoint[i] = glm::vec3(glm::inverse(v) * NDC);
+	}
+}
+
+// Compute the 8 corner points of the current view frustum in world space
+void ShadowPass::UpdateFrustumPoints(ShadowFrustum& frustum, glm::vec3 camera_position, glm::vec3 view_dir)
+{
+	glm::vec3 up = glm::vec3(0.f, 1.f, 0.f);
+	glm::vec3 right = glm::normalize(glm::cross(view_dir, up));
+
+	glm::vec3 far_center = camera_position + glm::normalize(view_dir) * frustum.FarClip;
+	glm::vec3 near_center = camera_position + glm::normalize(view_dir) * frustum.NearClip;
+	frustum.MiddlePoint = near_center + (far_center - near_center) * 0.5f;
+
+	up = glm::normalize(glm::cross(right, view_dir));
+
+	// these heights and widths are half the heights and widths of the near and far plane rectangles.
+	float near_height = tan(frustum.FOV / 2.f) * frustum.NearClip;
+	float near_width = near_height * frustum.AspectRatio;
+	float far_height = tan(frustum.FOV / 2.f) * frustum.FarClip;
+	float far_width = far_height * frustum.AspectRatio;
+
+	frustum.CornerPoint[0] = near_center - up * near_height - right * near_width;
+	frustum.CornerPoint[1] = near_center + up * near_height - right * near_width;
+	frustum.CornerPoint[2] = near_center + up * near_height + right * near_width;
+	frustum.CornerPoint[3] = near_center - up * near_height + right * near_width;
+
+	frustum.CornerPoint[4] = far_center - up * far_height - right * far_width;
+	frustum.CornerPoint[5] = far_center + up * far_height - right * far_width;
+	frustum.CornerPoint[6] = far_center + up * far_height + right * far_width;
+	frustum.CornerPoint[7] = far_center - up * far_height + right * far_width;
+}
+
+float ShadowPass::FindRadius(ShadowFrustum& frustum)
+{
+	float radius = 0.f;
+
+	for (int i = 0; i < 8; i++) {
+		float distance = glm::distance(frustum.MiddlePoint, frustum.CornerPoint[i]);
+		if (distance > radius) {
+			radius = distance;
+		}
+	}
+
+	frustum.Radius = radius;
+	return radius;
+}
+
+void ShadowPass::InitializeFrameBuffers()
+{
+	// Depth texture
+	glGenTextures(1, &m_DepthMap);
+
+	glBindTexture(GL_TEXTURE_2D_ARRAY, m_DepthMap);
+	glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_DEPTH_COMPONENT16, m_ResolutionSizeWidth, m_ResolutionSizeHeight, m_CurrentNrOfSplits);
+
+	//glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight, m_CurrentNrOfSplits, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
+
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
+	glTexParameterfv(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BORDER_COLOR, glm::vec4(1.f).data);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
+
+	m_DepthBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2DArray(&m_DepthMap, GL_DEPTH_ATTACHMENT)));
+	m_DepthBuffer.Generate();
+
+	GLERROR("depthMap failed END");
+}
+
+void ShadowPass::InitializeShaderPrograms()
+{
+	m_ShadowProgram = ResourceManager::Load<ShaderProgram>("#ShadowProgram");
+	m_ShadowProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Shadow.vert.glsl")));
+	m_ShadowProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Shadow.frag.glsl")));
+	m_ShadowProgram->Compile();
+	m_ShadowProgram->BindFragDataLocation(0, "ShadowMap");
+	m_ShadowProgram->Link();
+
+    m_ShadowProgramSkinned = ResourceManager::Load<ShaderProgram>("#ShadowProgramSkinned");
+    m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShadowSkinned.vert.glsl")));
+    m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Shadow.frag.glsl")));
+    m_ShadowProgramSkinned->Compile();
+    m_ShadowProgramSkinned->BindFragDataLocation(0, "ShadowMap");
+    m_ShadowProgramSkinned->Link();
+}
+
+void ShadowPass::ClearBuffer()
+{
+	m_DepthBuffer.Bind();
+
+	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
+		glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+
+	m_DepthBuffer.Unbind();
+}
+
+void ShadowPass::PointsToLightspace(ShadowFrustum& frustum, glm::mat4 v)
+{
+	float left = INFINITY;
+	float right = -INFINITY;
+	float bottom = INFINITY;
+	float top = -INFINITY;
+
+	for (int i = 0; i < 8; i++)
+	{
+		glm::vec3 tempPoint = glm::vec3(v * glm::vec4(frustum.CornerPoint[i], 1.f));
+
+		if (tempPoint.x < left) { left = tempPoint.x; }
+		if (tempPoint.x > right) { right = tempPoint.x; }
+		if (tempPoint.y < bottom) { bottom = tempPoint.y; }
+		if (tempPoint.y > top) { top = tempPoint.y; }
+	}
+
+	frustum.LRBT = { left, right, bottom, top };
+}
+
+void ShadowPass::RadiusToLightspace(ShadowFrustum& frustum)
+{
+	float quantizationStep = 1.0f / m_ResolutionSizeHeight;
+
+	float left = -frustum.Radius;
+	float right = frustum.Radius;
+	float bottom = -frustum.Radius;
+	float top = frustum.Radius;
+
+	frustum.LRBT = { left, right, bottom, top };
+}
+
+void ShadowPass::Draw(RenderScene & scene)
+{
+	if (m_EnableShadows) {
+		InitializeCameras(scene);
+		UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip());
+
+		ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
+
+		
+		glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight);
+
+		for (int i = 0; i < m_CurrentNrOfSplits; i++) {
+			UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward());
+
+			glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
+
+
+            GLuint shaderHandle;
+
+			for (auto &job : scene.Jobs.DirectionalLight) {
+
+				auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
+
+				if (directionalLightJob) {
+					m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f));
+
+					PointsToLightspace(m_shadowFrusta[i], m_LightView[i]);
+					//FindRadius(m_shadowFrusta[i]);
+					//RadiusToLightspace(m_shadowFrusta[i]);
+					m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]);
+
+
+                    m_ShadowProgram->Bind();
+                    shaderHandle = m_ShadowProgram->GetHandle();
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
+
+                    m_ShadowProgramSkinned->Bind();
+                    shaderHandle = m_ShadowProgramSkinned->GetHandle();
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
+
+
+
+					GLERROR("ShadowLight ERROR");
+
+					for (auto &objectJob : scene.Jobs.OpaqueObjects) {
+						if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
+							auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+
+							if (!modelJob->Shadow) {
+								continue;
+							}
+
+                            if(modelJob->Model->IsSkinned()) {
+                                m_ShadowProgramSkinned->Bind();
+                                shaderHandle = m_ShadowProgramSkinned->GetHandle();
+
+                                std::vector<glm::mat4> frameBones;
+                                if (modelJob->BlendTree != nullptr) {
+                                    frameBones = modelJob->BlendTree->GetFinalPose();
+                                } else {
+                                    frameBones = modelJob->Skeleton->GetTPose();
+                                }
+                                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+                            } else {
+                                m_ShadowProgram->Bind();
+                                shaderHandle = m_ShadowProgram->GetHandle();
+                            }
+
+							glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+							glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f);
+
+							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)));
+
+							GLERROR("Shadow Draw ERROR");
+						}
+					}
+					if (m_TransparentObjects) {
+						state->CullFace(GL_BACK);
+						for (auto &objectJob : scene.Jobs.TransparentObjects) {
+							if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
+								auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+
+								if (!modelJob->Shadow) {
+									continue;
+								}
+
+                                if (modelJob->Model->IsSkinned()) {
+                                    m_ShadowProgramSkinned->Bind();
+                                    shaderHandle = m_ShadowProgramSkinned->GetHandle();
+
+                                    std::vector<glm::mat4> frameBones;
+                                    if (modelJob->BlendTree != nullptr) {
+                                        frameBones = modelJob->BlendTree->GetFinalPose();
+                                    } else {
+                                        frameBones = modelJob->Skeleton->GetTPose();
+                                    }
+                                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+                                } else {
+                                    m_ShadowProgram->Bind();
+                                    shaderHandle = m_ShadowProgram->GetHandle();
+                                }
+
+								glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+								glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a);
+
+								if (m_TexturedShadows) {
+									switch (modelJob->Type) {
+									case RawModel::MaterialType::SingleTextures:
+									case RawModel::MaterialType::Basic:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) {
+											glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat));
+										}
+										else {
+											glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										}
+										break;
+									}
+									case RawModel::MaterialType::SplatMapping:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+										glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										break;
+									}
+									}
+								}
+
+								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)));
+
+								GLERROR("Shadow Draw ERROR");
+							}
+						}
+						state->CullFace(GL_FRONT);
+					}
+				}
+			}
+		}
+		glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+		m_DepthBuffer.Unbind();
+		delete state;
+	}
+}
@@ -0,0 +1,19 @@
+#include "Rendering/ShadowPassState.h"
+
+ShadowPassState::ShadowPassState(GLuint frameBuffer)
+{
+	BindFramebuffer(frameBuffer);
+	Enable(GL_DEPTH_TEST);
+	Enable(GL_CULL_FACE);
+	Disable(GL_BLEND);
+	Disable(GL_TEXTURE_2D);
+	CullFace(GL_FRONT);
+	ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
+	//Enable(GL_ALPHA_TEST);
+	//glAlphaFunc(GL_GREATER, 0.9f);
+}
+
+ShadowPassState::~ShadowPassState()
+{
+
+}
@@ -208,18 +208,6 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
        m_EventBroker->Publish(lock);
    }

-    // HACK: Set the player model color to team color
-    EntityWrapper playerModel = e.Player.FirstChildByName("PlayerModel");
-    if (playerModel.Valid() && e.Player.HasComponent("Team")) {
-        ComponentWrapper cTeam = e.Player["Team"];
-        ComponentWrapper cModel = playerModel["Model"];
-        if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Red")) {
-            cModel["Color"] = glm::vec3(1.f, 0.f, 0.f);
-        } else if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Blue")) {
-            cModel["Color"] = glm::vec3(0.f, 0.25f, 1.f);
-        }
-    }
-
    return true;
 }