Fix Indent

src/Shaders/ShadersInclude/lightFragment.fx

@@ -2,103 +2,103 @@
     #if defined(SHADOWONLY) || (defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X}) && defined(LIGHTMAPNOSPECULAR{X}))
         //No light calculation
     #else
-		#ifdef PBR
-			#ifdef SPOTLIGHT{X}
-				info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
-			#endif
-			#ifdef HEMILIGHT{X}
-				info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
-			#endif
-			#if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
-				info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
-			#endif
-		#else
-			#ifdef SPOTLIGHT{X}
-				info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, glossiness);
-			#endif
-			#ifdef HEMILIGHT{X}
-				info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, glossiness);
-			#endif
-			#if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
-				info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, glossiness);
-			#endif
-		#endif
-		#ifdef PROJECTEDLIGHTTEXTURE{X}
-			info.diffuse *= computeProjectionTextureDiffuseLighting(projectionLightSampler{X}, textureProjectionMatrix{X});
-		#endif
+        #ifdef PBR
+            #ifdef SPOTLIGHT{X}
+                info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
+            #endif
+            #ifdef HEMILIGHT{X}
+                info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
+            #endif
+            #if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
+                info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
+            #endif
+        #else
+            #ifdef SPOTLIGHT{X}
+                info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, glossiness);
+            #endif
+            #ifdef HEMILIGHT{X}
+                info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, glossiness);
+            #endif
+            #if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
+                info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, glossiness);
+            #endif
+        #endif
+        #ifdef PROJECTEDLIGHTTEXTURE{X}
+            info.diffuse *= computeProjectionTextureDiffuseLighting(projectionLightSampler{X}, textureProjectionMatrix{X});
+        #endif
     #endif
-	#ifdef SHADOW{X}
-		#ifdef SHADOWCLOSEESM{X}
-			#if defined(SHADOWCUBE{X})
-				shadow = computeShadowWithCloseESMCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.depthValues);
-			#else
-				shadow = computeShadowWithCloseESM(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.shadowsInfo.w);
-			#endif
-		#elif defined(SHADOWESM{X})
-			#if defined(SHADOWCUBE{X})
-				shadow = computeShadowWithESMCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.depthValues);
-			#else
-				shadow = computeShadowWithESM(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.shadowsInfo.w);
-			#endif
-		#elif defined(SHADOWPOISSON{X})
-			#if defined(SHADOWCUBE{X})
-				shadow = computeShadowWithPoissonSamplingCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.x, light{X}.depthValues);
-			#else
-				shadow = computeShadowWithPoissonSampling(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#endif
-		#elif defined(SHADOWPCF{X})
-			#if defined(SHADOWLOWQUALITY{X})
-				shadow = computeShadowWithPCF1(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#elif defined(SHADOWMEDIUMQUALITY{X})
-				shadow = computeShadowWithPCF3(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.yz, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#else
-				shadow = computeShadowWithPCF5(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.yz, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#endif
-		#elif defined(SHADOWPCSS{X})
-			#if defined(SHADOWLOWQUALITY{X})
-				shadow = computeShadowWithPCSS16(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#elif defined(SHADOWMEDIUMQUALITY{X})
-				shadow = computeShadowWithPCSS32(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#else
-				shadow = computeShadowWithPCSS64(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#endif
-		#else
-			#if defined(SHADOWCUBE{X})
-				shadow = computeShadowCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.depthValues);
-			#else
-				shadow = computeShadow(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
-			#endif
-		#endif
+    #ifdef SHADOW{X}
+        #ifdef SHADOWCLOSEESM{X}
+            #if defined(SHADOWCUBE{X})
+                shadow = computeShadowWithCloseESMCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.depthValues);
+            #else
+                shadow = computeShadowWithCloseESM(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.shadowsInfo.w);
+            #endif
+        #elif defined(SHADOWESM{X})
+            #if defined(SHADOWCUBE{X})
+                shadow = computeShadowWithESMCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.depthValues);
+            #else
+                shadow = computeShadowWithESM(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.z, light{X}.shadowsInfo.w);
+            #endif
+        #elif defined(SHADOWPOISSON{X})
+            #if defined(SHADOWCUBE{X})
+                shadow = computeShadowWithPoissonSamplingCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.x, light{X}.depthValues);
+            #else
+                shadow = computeShadowWithPoissonSampling(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #endif
+        #elif defined(SHADOWPCF{X})
+            #if defined(SHADOWLOWQUALITY{X})
+                shadow = computeShadowWithPCF1(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #elif defined(SHADOWMEDIUMQUALITY{X})
+                shadow = computeShadowWithPCF3(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.yz, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #else
+                shadow = computeShadowWithPCF5(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.yz, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #endif
+        #elif defined(SHADOWPCSS{X})
+            #if defined(SHADOWLOWQUALITY{X})
+                shadow = computeShadowWithPCSS16(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #elif defined(SHADOWMEDIUMQUALITY{X})
+                shadow = computeShadowWithPCSS32(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #else
+                shadow = computeShadowWithPCSS64(vPositionFromLight{X}, vDepthMetric{X}, depthSampler{X}, shadowSampler{X}, light{X}.shadowsInfo.y, light{X}.shadowsInfo.z, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #endif
+        #else
+            #if defined(SHADOWCUBE{X})
+                shadow = computeShadowCube(light{X}.vLightData.xyz, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.depthValues);
+            #else
+                shadow = computeShadow(vPositionFromLight{X}, vDepthMetric{X}, shadowSampler{X}, light{X}.shadowsInfo.x, light{X}.shadowsInfo.w);
+            #endif
+        #endif
 
-		#ifdef SHADOWONLY
-			#ifndef SHADOWINUSE
-				#define SHADOWINUSE
-			#endif
-			globalShadow += shadow;
-			shadowLightCount += 1.0;
-		#endif
-	#else
-		shadow = 1.;
-	#endif
+        #ifdef SHADOWONLY
+            #ifndef SHADOWINUSE
+                #define SHADOWINUSE
+            #endif
+            globalShadow += shadow;
+            shadowLightCount += 1.0;
+        #endif
+    #else
+        shadow = 1.;
+    #endif
 
-	#ifndef SHADOWONLY
-		#ifdef CUSTOMUSERLIGHTING
-			diffuseBase += computeCustomDiffuseLighting(info, diffuseBase, shadow);
-			#ifdef SPECULARTERM
-				specularBase += computeCustomSpecularLighting(info, specularBase, shadow);
-			#endif
-		#elif defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X})
-			diffuseBase += lightmapColor * shadow;
-			#ifdef SPECULARTERM
-				#ifndef LIGHTMAPNOSPECULAR{X}
-					specularBase += info.specular * shadow * lightmapColor;
-				#endif
-			#endif
-		#else
-			diffuseBase += info.diffuse * shadow;
-			#ifdef SPECULARTERM
-				specularBase += info.specular * shadow;
-			#endif
-		#endif
-	#endif
+    #ifndef SHADOWONLY
+        #ifdef CUSTOMUSERLIGHTING
+            diffuseBase += computeCustomDiffuseLighting(info, diffuseBase, shadow);
+            #ifdef SPECULARTERM
+                specularBase += computeCustomSpecularLighting(info, specularBase, shadow);
+            #endif
+        #elif defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X})
+            diffuseBase += lightmapColor * shadow;
+            #ifdef SPECULARTERM
+                #ifndef LIGHTMAPNOSPECULAR{X}
+                    specularBase += info.specular * shadow * lightmapColor;
+                #endif
+            #endif
+        #else
+            diffuseBase += info.diffuse * shadow;
+            #ifdef SPECULARTERM
+                specularBase += info.specular * shadow;
+            #endif
+        #endif
+    #endif
 #endif

src/Shaders/shadowMap.fragment.fx

@@ -1,13 +1,13 @@
 #ifndef FLOAT
 vec4 pack(float depth)
 {
-	const vec4 bit_shift = vec4(255.0 * 255.0 * 255.0, 255.0 * 255.0, 255.0, 1.0);
-	const vec4 bit_mask = vec4(0.0, 1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0);
+    const vec4 bit_shift = vec4(255.0 * 255.0 * 255.0, 255.0 * 255.0, 255.0, 1.0);
+    const vec4 bit_mask = vec4(0.0, 1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0);
 
-	vec4 res = fract(depth * bit_shift);
-	res -= res.xxyz * bit_mask;
+    vec4 res = fract(depth * bit_shift);
+    res -= res.xxyz * bit_mask;
 
-	return res;
+    return res;
 }
 #endif
 
@@ -24,19 +24,19 @@ uniform vec2 depthValues;
 void main(void)
 {
 #ifdef ALPHATEST
-	if (texture2D(diffuseSampler, vUV).a < 0.4)
-		discard;
+    if (texture2D(diffuseSampler, vUV).a < 0.4)
+        discard;
 #endif
 
-	float depth = vDepthMetric;
+    float depth = vDepthMetric;
 
 #ifdef ESM
-	depth = clamp(exp(-min(87., biasAndScale.z * depth)), 0., 1.);
+    depth = clamp(exp(-min(87., biasAndScale.z * depth)), 0., 1.);
 #endif
 
 #ifdef FLOAT
-	gl_FragColor = vec4(depth, 1.0, 1.0, 1.0);
+    gl_FragColor = vec4(depth, 1.0, 1.0, 1.0);
 #else
-	gl_FragColor = pack(depth);
+    gl_FragColor = pack(depth);
 #endif
 }

src/Shaders/shadowMap.vertex.fx

@@ -2,8 +2,8 @@
 attribute vec3 position;
 
 #ifdef NORMAL
-	attribute vec3 normal;
-	uniform vec3 lightData;
+    attribute vec3 normal;
+    uniform vec3 lightData;
 #endif
 
 #include<bonesDeclaration>
@@ -38,45 +38,45 @@ vec4 worldPos = finalWorld * vec4(position, 1.0);
 
 // Normal inset Bias.
 #ifdef NORMAL
-	mat3 normalWorld = mat3(finalWorld);
+    mat3 normalWorld = mat3(finalWorld);
 
-	#ifdef NONUNIFORMSCALING
-		normalWorld = transposeMat3(inverseMat3(normalWorld));
-	#endif
+    #ifdef NONUNIFORMSCALING
+        normalWorld = transposeMat3(inverseMat3(normalWorld));
+    #endif
 
-	vec3 worldNor = normalize(normalWorld * normal);
+    vec3 worldNor = normalize(normalWorld * normal);
 
-	#ifdef DIRECTIONINLIGHTDATA
-		vec3 worldLightDir = normalize(-lightData.xyz);
-	#else
-		vec3 directionToLight = lightData.xyz - worldPos.xyz;
-		vec3 worldLightDir = normalize(directionToLight);
-	#endif
+    #ifdef DIRECTIONINLIGHTDATA
+        vec3 worldLightDir = normalize(-lightData.xyz);
+    #else
+        vec3 directionToLight = lightData.xyz - worldPos.xyz;
+        vec3 worldLightDir = normalize(directionToLight);
+    #endif
 
-	float ndl = dot(worldNor, worldLightDir);
-	float sinNL = sqrt(1.0 - ndl * ndl);
-	float normalBias = biasAndScale.y * sinNL;
+    float ndl = dot(worldNor, worldLightDir);
+    float sinNL = sqrt(1.0 - ndl * ndl);
+    float normalBias = biasAndScale.y * sinNL;
 
-	worldPos.xyz -= worldNor * normalBias;
+    worldPos.xyz -= worldNor * normalBias;
 #endif
 
 // Projection.
 gl_Position = viewProjection * worldPos;
 
 #ifdef DEPTHTEXTURE
-	// Depth texture Linear bias.
-	gl_Position.z += biasAndScale.x * gl_Position.w;
+    // Depth texture Linear bias.
+    gl_Position.z += biasAndScale.x * gl_Position.w;
 #endif
 
-	// Color Texture Linear bias.
-	vDepthMetric = ((gl_Position.z + depthValues.x) / (depthValues.y)) + biasAndScale.x;
+    // Color Texture Linear bias.
+    vDepthMetric = ((gl_Position.z + depthValues.x) / (depthValues.y)) + biasAndScale.x;
 
 #ifdef ALPHATEST
-	#ifdef UV1
-		vUV = vec2(diffuseMatrix * vec4(uv, 1.0, 0.0));
-	#endif
-	#ifdef UV2
-		vUV = vec2(diffuseMatrix * vec4(uv2, 1.0, 0.0));
-	#endif
+    #ifdef UV1
+        vUV = vec2(diffuseMatrix * vec4(uv, 1.0, 0.0));
+    #endif
+    #ifdef UV2
+        vUV = vec2(diffuseMatrix * vec4(uv2, 1.0, 0.0));
+    #endif
 #endif
 }