Merge branch 'master' into Shadows

# Conflicts:
#	assets
#	include/Engine/Rendering/DrawFinalPass.h
#	include/Engine/Rendering/Renderer.h
#	resources/Shaders/ForwardPlus.frag.glsl
#	resources/Shaders/ForwardPlus.vert.glsl
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/FrameBuffer.cpp
#	src/Engine/Rendering/Renderer.cpp

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -2,6 +2,8 @@
 
 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;
 
@@ -15,14 +17,24 @@ void main()
 {
 	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
 	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
-	hdrColor += bloomColor;
+	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(1.0) - exp(-hdrColor.rgb * Exposure);
+	vec3 result;
+	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));
-
 	fragmentColor = vec4(result, 1.0);
 	//fragmentColor = hdrColor;
 	//fragmentColor = bloomColor;

resources/Shaders/FillDepthBuffer.frag.glsl

@@ -0,0 +1,11 @@
+#version 430
+
+in VertexData{
+	vec3 Position;
+}Input;
+
+void main()
+{
+}
+
+

resources/Shaders/FillDepthBuffer.vert.glsl

@@ -0,0 +1,21 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{
+	gl_Position = P * V * M * vec4(Position, 1.0);
+
+	Output.Position = Position;
+}

resources/Shaders/FillDepthBufferSkinned.vert.glsl

@@ -0,0 +1,33 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+
+layout(location = 0) in vec3 Position;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+
+
+out VertexData{
+	vec3 Position;
+}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.Position = vec3(0.0);
+}

resources/Shaders/ForwardPlus.frag.glsl

@@ -1,6 +1,7 @@
 #version 430
 
 #define MAX_SPLITS 4
+#define MIN_AMBIENT_LIGHT 0.3
 
 uniform mat4 M;
 uniform mat4 V;
@@ -12,13 +13,20 @@ uniform vec4 FillColor;
 uniform vec4 AmbientColor;
 uniform float FillPercentage;
 uniform float FarDistance[MAX_SPLITS];
+uniform float GlowIntensity = 10;
+uniform vec3 CameraPosition;
 
-layout (binding = 0) uniform sampler2D DiffuseTexture;
-layout (binding = 1) uniform sampler2D NormalMapTexture;
-layout (binding = 2) uniform sampler2D SpecularMapTexture;
-layout (binding = 3) uniform sampler2D GlowMapTexture;
-layout (binding = 4) uniform sampler2DArrayShadow DepthMap;
-
+uniform vec2 DiffuseUVRepeat;
+uniform vec2 NormalUVRepeat;
+uniform vec2 SpecularUVRepeat;
+uniform vec2 GlowUVRepeat;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 6) uniform sampler2DArrayShadow DepthMap;
+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;
 
 #define TILE_SIZE 16
 
@@ -93,7 +101,7 @@ vec2 poissonDisk[16] = vec2[](
 	);
 
 float CalcAttenuation(float radius, float dist, float falloff) {
-	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+	return 1.0 - smoothstep(radius * falloff, radius, dist);
 }
 
 vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
@@ -288,21 +296,27 @@ int getShadowIndex(float far_distance[4])
 
 void main()
 {
-	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
-	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate);
-	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate);
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy), 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, NormalMapTexture);
+	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); 
+	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, 1.0);
+	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);
@@ -324,9 +338,8 @@ void main()
 			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 += light_result.Diffuse;
-		totalLighting.Specular += light_result.Specular;
+		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 *= (1.5 + vec4(AmbientColor.rgba)) - vec4(vec3(shadowFactor), 0.0); 
@@ -336,6 +349,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;
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
 
@@ -343,9 +358,10 @@ void main()
 		color_result += FillColor;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
-	color_result += glowTexel*3;
+	//sceneColor = vec4(reflectionColor.xyz, 1);
+	color_result += glowTexel*GlowIntensity;
 
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), clamp(color_result.a, 0, 1));
 
 	//Tiled Debug Code
 	/*

resources/Shaders/ForwardPlus.vert.glsl

@@ -7,15 +7,12 @@ uniform mat4 V;
 uniform mat4 P;
 uniform mat4 LightV[MAX_SPLITS];
 uniform mat4 LightP[MAX_SPLITS];
-uniform mat4 Bones[100];
 
 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
 layout(location = 2) in vec3 Tangent;
 layout(location = 3) in vec3 BiTangent;
 layout(location = 4) in vec2 TextureCoords;
-layout(location = 5) in vec4 BoneIndices;
-layout(location = 6) in vec4 BoneWeights;
 
 out VertexData{
 	vec3 Position;
@@ -38,23 +35,13 @@ vec4(0.5, 0.5, 0.5, 1.0)
 
 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.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	gl_Position = P*V*M * vec4(Position, 1.0);
+	mat4 TIM = transpose(inverse(M));
+	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;
-	Output.Normal = vec3(M * vec4(Normal, 0.0));
-	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
- 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
+	Output.Normal = vec3(TIM * vec4(Normal, 0.0));
+	Output.Tangent = vec3(TIM * vec4(Tangent, 0.0));
+ 	Output.BiTangent = vec3(TIM * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
 	

resources/Shaders/ForwardPlusSkinned.vert.glsl

@@ -0,0 +1,46 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+out VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}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.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	Output.TextureCoordinate = TextureCoords;
+	Output.Normal = vec3(M * boneTransform * vec4(Normal, 0.0));
+	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
+ 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
+	Output.ExplosionColor = vec4(1.0);
+	Output.ExplosionPercentageElapsed = 0.0;
+}

resources/Shaders/ForwardPlusSplatMap.frag.glsl

@@ -0,0 +1,277 @@
+#version 430
+
+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;
+
+//Get bineded at the same time as the textures
+uniform vec2 DiffuseUVRepeat1;
+uniform vec2 DiffuseUVRepeat2;
+uniform vec2 DiffuseUVRepeat3;
+uniform vec2 DiffuseUVRepeat4;
+uniform vec2 DiffuseUVRepeat5;
+uniform vec2 NormalUVRepeat1;
+uniform vec2 NormalUVRepeat2;
+uniform vec2 NormalUVRepeat3;
+uniform vec2 NormalUVRepeat4;
+uniform vec2 NormalUVRepeat5;
+uniform vec2 SpecularUVRepeat1;
+uniform vec2 SpecularUVRepeat2;
+uniform vec2 SpecularUVRepeat3;
+uniform vec2 SpecularUVRepeat4;
+uniform vec2 SpecularUVRepeat5;
+uniform vec2 GlowUVRepeat1;
+uniform vec2 GlowUVRepeat2;
+uniform vec2 GlowUVRepeat3;
+uniform vec2 GlowUVRepeat4;
+uniform vec2 GlowUVRepeat5;
+layout (binding = 0) uniform sampler2D SplatMapTexture;
+layout (binding = 1) uniform sampler2D DiffuseTexture1;
+layout (binding = 2) uniform sampler2D DiffuseTexture2;
+layout (binding = 3) uniform sampler2D DiffuseTexture3;
+layout (binding = 4) uniform sampler2D DiffuseTexture4;
+layout (binding = 5) uniform sampler2D DiffuseTexture5;
+layout (binding = 6) uniform sampler2D NormalMapTexture1;
+layout (binding = 7) uniform sampler2D NormalMapTexture2;
+layout (binding = 8) uniform sampler2D NormalMapTexture3;
+layout (binding = 9) uniform sampler2D NormalMapTexture4;
+layout (binding = 10) uniform sampler2D NormalMapTexture5;
+layout (binding = 11) uniform sampler2D SpecularMapTexture1;
+layout (binding = 12) uniform sampler2D SpecularMapTexture2;
+layout (binding = 13) uniform sampler2D SpecularMapTexture3;
+layout (binding = 14) uniform sampler2D SpecularMapTexture4;
+layout (binding = 15) uniform sampler2D SpecularMapTexture5;
+layout (binding = 16) uniform sampler2D GlowMapTexture1;
+layout (binding = 17) uniform sampler2D GlowMapTexture2;
+layout (binding = 18) uniform sampler2D GlowMapTexture3;
+layout (binding = 19) uniform sampler2D GlowMapTexture4;
+layout (binding = 20) uniform sampler2D GlowMapTexture5;
+
+#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, sampler2D A, sampler2D D,
+	 				  vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues,  vec2 A_TileValues,  vec2 D_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);
+	vec4 A_Channel = texture2D(A, Input.TextureCoordinate * A_TileValues);
+	vec4 D_Channel = texture2D(D, Input.TextureCoordinate * D_TileValues);
+
+	float total = blendValue.r + blendValue.g + blendValue.b + blendValue.a;
+	if(total > 1.0f){
+		float totalDiv = 1.0f / total;
+		blendValue.r = blendValue.r * totalDiv;
+		blendValue.g = blendValue.g * totalDiv;
+		blendValue.b = blendValue.b * totalDiv;
+		blendValue.a = blendValue.a * totalDiv;
+	}
+	float D_percent = clamp( 1.0f - total, 0.0f, 1.0f);
+
+	return blendValue.r * R_Channel
+		 + blendValue.g * G_Channel
+		 + blendValue.b * B_Channel
+		 + blendValue.a * A_Channel 
+		 + D_percent    * D_Channel;
+}
+
+vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B, sampler2D A, sampler2D D,
+					   vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues,  vec2 A_TileValues,  vec2 D_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);
+	vec3 A_Channel = texture(A, Input.TextureCoordinate * A_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 D_Channel = texture(D, Input.TextureCoordinate * D_TileValues).xyz * 2.0 - vec3(1.0);
+
+	float total = blendValue.r + blendValue.g + blendValue.b + blendValue.a;
+	if(total > 1.0f){
+		float totalDiv = 1 / total;
+		blendValue.r = blendValue.r * totalDiv;
+		blendValue.g = blendValue.g * totalDiv;
+		blendValue.b = blendValue.b * totalDiv;
+		blendValue.a = blendValue.a * totalDiv;
+	}
+	float D_percent = clamp( 1.0f - total, 0.0f, 1.0f);
+
+	vec3 Normal_result = blendValue.r * R_Channel
+					   + blendValue.g * G_Channel 
+		 			   + blendValue.b * B_Channel 
+		 			   + blendValue.a * A_Channel 
+		 			   + D_percent    * D_Channel;
+
+	return vec4(TBN * normalize(Normal_result), 0.0);
+}
+
+void main()
+{
+	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);
+
+	vec4 diffuseTexel = CalcBlendedTexel(splatTexel, DiffuseTexture1, DiffuseTexture2, DiffuseTexture3, DiffuseTexture4, DiffuseTexture5,
+	 									 DiffuseUVRepeat1, DiffuseUVRepeat2, DiffuseUVRepeat3, DiffuseUVRepeat4, DiffuseUVRepeat5);
+	vec4 glowTexel = CalcBlendedTexel(splatTexel, GlowMapTexture1, GlowMapTexture2, GlowMapTexture3, GlowMapTexture4, GlowMapTexture5,
+	 									 GlowUVRepeat1, GlowUVRepeat2, GlowUVRepeat3, GlowUVRepeat4, GlowUVRepeat5);
+	vec4 specularTexel = CalcBlendedTexel(splatTexel, SpecularMapTexture1, SpecularMapTexture2, SpecularMapTexture3, SpecularMapTexture4, SpecularMapTexture5,
+										 SpecularUVRepeat1, SpecularUVRepeat2, SpecularUVRepeat3, SpecularUVRepeat4, SpecularUVRepeat5);
+	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, NormalMapTexture4, NormalMapTexture5,
+		   								NormalUVRepeat1, NormalUVRepeat2, NormalUVRepeat3, NormalUVRepeat4, NormalUVRepeat5);
+	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, 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 += light_result.Diffuse;
+		totalLighting.Specular += light_result.Specular;
+	}
+
+	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/ForwardPlusSplatMapRGB.frag.glsl

@@ -0,0 +1,251 @@
+#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;
+
+//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;
+
+#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), 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/Picking.vert.glsl

@@ -3,15 +3,12 @@
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
-uniform mat4 Bones[100];
 
 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
 layout(location = 2) in vec3 Tangent;
 layout(location = 3) in vec3 BiTangent;
 layout(location = 4) in vec2 TextureCoords;
-layout(location = 5) in vec4 BoneIndices;
-layout(location = 6) in vec4 BoneWeights;
 
 out VertexData{
 	vec3 Position;
@@ -19,14 +16,6 @@ out VertexData{
 
 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.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	gl_Position = P*V*M * vec4(Position, 1.0);
+	Output.Position = Position, 1.0;
 }

resources/Shaders/PickingSkinned.vert.glsl

@@ -0,0 +1,32 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+out VertexData{
+	vec3 Position;
+}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.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+}

resources/Shaders/SSAO.frag.glsl

@@ -0,0 +1,114 @@
+#version 430
+
+//Number of samples per pixel
+uniform int           uNumOfSamples;
+//#define NUM_SAMPLES (11)
+
+//Number of turns around the cirle
+uniform int           uNumOfTurns;
+//#define NUM_TURNS (7)
+
+layout (binding = 0) uniform sampler2D ViewSpaceZ;
+
+uniform vec4 uProjInfo;
+
+uniform float           uProjScale;
+//#define ProjScale 500
+
+uniform float           uRadius;
+//#define Radius 1.0f
+
+uniform float           uBias;
+//#define Bias 0.012f
+
+uniform float           uContrast;
+//#define IntensityDivR6 1
+
+uniform float           uIntensityScale;
+
+out float				AO;
+
+vec3 getVSPosition(ivec2 ScreenSpaceCoord) {
+    float z = texelFetch(ViewSpaceZ, ScreenSpaceCoord, 0).r;
+    //Get the xy view space coordinates and add the z value from ViewSpaceZ buffer.
+    return vec3((uProjInfo[0] + (ScreenSpaceCoord.x * uProjInfo[1])) * z, (uProjInfo[2] + (ScreenSpaceCoord.y * uProjInfo[3])) * z, z);
+}
+
+vec3 getVSFaceNormal(vec3 ViewSpacePosition) {
+	// Get tangets vector for the plane and ViewSpacePositin... don't ask how this functions works. It's pure magic. 
+	// They do this and it just works... I would guess that they approximate the function of a plane from pixels close to the pixel were on now.
+	return normalize(cross(dFdx(ViewSpacePosition), dFdy(ViewSpacePosition)));
+}
+
+
+vec3 getSampleViewSpacePos(ivec2 ScreenSpaceCoord, int SampleIndex, float RotationAngle, float ScreenSpaceSampleRadius){
+	// Pure Magic...
+	float alpha = float(SampleIndex) * (1.0 / uNumOfSamples);
+
+	// Angle to where to sample
+    float angle = alpha * (uNumOfTurns * 6.28) + RotationAngle;
+
+	//Lenght to were to sample
+    ScreenSpaceSampleRadius = ScreenSpaceSampleRadius * alpha;
+
+    vec2 screenSpaceSampleOffsetVecor = vec2(cos(angle), sin(angle));
+
+    // Get texel coordinate on where to sample by going screenSpaceSampleOffsetVecor direction in ScreenSpaceSampleRadius units from ScreenSpaceCoord (the point being shaded);
+    ivec2 screenSpaceSampleTexel = ivec2(ScreenSpaceSampleRadius * screenSpaceSampleOffsetVecor) + ScreenSpaceCoord;
+
+    return getVSPosition(screenSpaceSampleTexel);
+}
+
+
+
+float sampleAO(ivec2 ScreenSpaceCoord, vec3 Origin, vec3 OriginNormal, float ScreenSpaceSampleRadius, int SampleIndex, float RotationAngle, float Radius) {
+	float radius2 = Radius * Radius;
+	vec3 sampleViewSpacePosition = getSampleViewSpacePos(ScreenSpaceCoord, SampleIndex, RotationAngle, ScreenSpaceSampleRadius);
+
+	vec3 sampleVector = Origin - sampleViewSpacePosition;
+
+	// vv = sampleVectorLenght ^ 2
+	float vv = dot(sampleVector, sampleVector);
+	// vn = angle between sampleVector and Normal
+	float vn = dot(sampleVector, OriginNormal);
+
+	const float epsilon = 0.0001f;
+
+	// vv < radius2 if the vector is shorter then the radius;
+	// vn - bias, offset the angle to reduse self occlusion. 
+	// epsilon is here to make divison by 0 impossible.
+	return float(vv < radius2) * max((vn - uBias) / (epsilon + vv), 0.0);
+	//float f = max(radius2 - vv, 0.0); 
+	//return f * f * f * max((vn - uBias) / (epsilon + vv), 0.0);
+}
+
+
+void main() {
+	ivec2 originScreenCoord = ivec2(gl_FragCoord.xy);
+
+	vec3 origin = getVSPosition(originScreenCoord);
+
+	float radius;
+	if(origin.z < uRadius){
+		radius = origin.z;
+	} else {
+		radius = uRadius;
+	}
+
+
+	vec3 originNormal = getVSFaceNormal(origin);
+
+	float screenSpaceSampleRadius = -uProjScale * radius / origin.z;
+
+	float rotationAngleOffset = 30 * originScreenCoord.x ^ originScreenCoord.y + 10 * originScreenCoord.x * originScreenCoord.y;
+
+	float sum = 0.0;
+    for (int i = 0; i < uNumOfSamples; i++) {
+        sum += sampleAO(originScreenCoord, origin, originNormal, screenSpaceSampleRadius, i, rotationAngleOffset, radius);
+    }
+
+    //float A = max(0.0, 1.0 - sum * (2.0f / uNumOfSamples));
+    float A = 1.0 - sum * (2.0f * uIntensityScale / float(uNumOfSamples));
+    AO = clamp(pow(A, uContrast), 0.0f, 1.0f);
+	//AO = vec4(originNormal, 1.0f);
+}

resources/Shaders/SSAO.vert.glsl

@@ -0,0 +1,8 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+}

resources/Shaders/SSAOViewSpaceZ.frag.glsl

@@ -0,0 +1,14 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D DepthBuffer;
+uniform vec3 ClipInfo;
+
+out float depthLinear;
+//Just for Debug, should be depthLinear
+//out vec4 fragmentColor;
+void main() {
+	float depthSample = texelFetch(DepthBuffer, ivec2(gl_FragCoord.xy), 0).r;
+	depthLinear = ClipInfo[0] / (ClipInfo[1] * depthSample + ClipInfo[2]);
+	//float depthLinear = (NearClip) / ( -depthSample + 1.0f);
+	//fragmentColor = vec4(depthLinear, depthLinear, depthLinear, 1.0f);
+}

resources/Shaders/ShieldStencil.frag.glsl

@@ -0,0 +1,15 @@
+#version 430
+
+in VertexData{
+	vec3 Position;
+}Input;
+
+
+out vec4 fragmentColor;
+
+void main()
+{
+	fragmentColor = vec4(0.5, 0.0, 0.0, 0.0);
+}
+
+

resources/Shaders/ShieldStencil.vert.glsl

@@ -0,0 +1,19 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{
+	gl_Position = P * V * M * vec4(Position, 1.0);
+
+	Output.Position = Position;
+}

resources/Shaders/ShieldStencilSkinned.vert.glsl

@@ -0,0 +1,33 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+
+layout(location = 0) in vec3 Position;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+
+
+out VertexData{
+	vec3 Position;
+}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.Position = vec3(0.0);
+}

resources/Shaders/Sprite.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);
+}
+
+

resources/Shaders/Sprite.vert.glsl

@@ -0,0 +1,25 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 4) in vec2 TextureCoords;
+
+out VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+
+	gl_Position = P * V * M * vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.TextureCoordinate = TextureCoords;
+	Output.Normal = Normal;
+}