Style: Fix code formatting in GLES2 shaders

drivers/gles2/shaders/blend_shape.glsl

@@ -1,6 +1,5 @@
 [vertex]
 
-
 /*
 from VisualServer:
 
@@ -23,56 +22,56 @@ ARRAY_INDEX=8,
 
 /* INPUT ATTRIBS */
 
-layout(location=0) in highp VFORMAT vertex_attrib;
-layout(location=1) in vec3 normal_attrib;
+layout(location = 0) in highp VFORMAT vertex_attrib;
+layout(location = 1) in vec3 normal_attrib;
 
 #ifdef ENABLE_TANGENT
-layout(location=2) in vec4 tangent_attrib;
+layout(location = 2) in vec4 tangent_attrib;
 #endif
 
 #ifdef ENABLE_COLOR
-layout(location=3) in vec4 color_attrib;
+layout(location = 3) in vec4 color_attrib;
 #endif
 
 #ifdef ENABLE_UV
-layout(location=4) in vec2 uv_attrib;
+layout(location = 4) in vec2 uv_attrib;
 #endif
 
 #ifdef ENABLE_UV2
-layout(location=5) in vec2 uv2_attrib;
+layout(location = 5) in vec2 uv2_attrib;
 #endif
 
 #ifdef ENABLE_SKELETON
-layout(location=6) in ivec4 bone_attrib;
-layout(location=7) in vec4 weight_attrib;
+layout(location = 6) in ivec4 bone_attrib;
+layout(location = 7) in vec4 weight_attrib;
 #endif
 
 /* BLEND ATTRIBS */
 
 #ifdef ENABLE_BLEND
 
-layout(location=8) in highp VFORMAT vertex_attrib_blend;
-layout(location=9) in vec3 normal_attrib_blend;
+layout(location = 8) in highp VFORMAT vertex_attrib_blend;
+layout(location = 9) in vec3 normal_attrib_blend;
 
 #ifdef ENABLE_TANGENT
-layout(location=10) in vec4 tangent_attrib_blend;
+layout(location = 10) in vec4 tangent_attrib_blend;
 #endif
 
 #ifdef ENABLE_COLOR
-layout(location=11) in vec4 color_attrib_blend;
+layout(location = 11) in vec4 color_attrib_blend;
 #endif
 
 #ifdef ENABLE_UV
-layout(location=12) in vec2 uv_attrib_blend;
+layout(location = 12) in vec2 uv_attrib_blend;
 #endif
 
 #ifdef ENABLE_UV2
-layout(location=13) in vec2 uv2_attrib_blend;
+layout(location = 13) in vec2 uv2_attrib_blend;
 #endif
 
 #ifdef ENABLE_SKELETON
-layout(location=14) in ivec4 bone_attrib_blend;
-layout(location=15) in vec4 weight_attrib_blend;
+layout(location = 14) in ivec4 bone_attrib_blend;
+layout(location = 15) in vec4 weight_attrib_blend;
 #endif
 
 #endif
@@ -110,7 +109,6 @@ uniform float blend_amount;
 
 void main() {
 
-
 #ifdef ENABLE_BLEND
 
 	vertex_out = vertex_attrib_blend + vertex_attrib * blend_amount;
@@ -140,7 +138,6 @@ void main() {
 	uv2_out = uv2_attrib_blend + uv2_attrib * blend_amount;
 #endif
 
-
 #ifdef ENABLE_SKELETON
 
 	bone_out = bone_attrib_blend;
@@ -149,7 +146,6 @@ void main() {
 
 #else //ENABLE_BLEND
 
-
 	vertex_out = vertex_attrib * blend_amount;
 
 #ifdef ENABLE_NORMAL
@@ -177,7 +173,6 @@ void main() {
 	uv2_out = uv2_attrib * blend_amount;
 #endif
 
-
 #ifdef ENABLE_SKELETON
 
 	bone_out = bone_attrib;
@@ -190,8 +185,6 @@ void main() {
 
 [fragment]
 
-
 void main() {
 
 }
-

drivers/gles2/shaders/canvas.glsl

@@ -75,7 +75,7 @@ void main() {
 #endif
 
 {
-        vec2 src_vtx=outvec.xy;
+	vec2 src_vtx = outvec.xy;
 VERTEX_SHADER_CODE
 
 }
@@ -83,7 +83,6 @@ VERTEX_SHADER_CODE
 	color_interp = color;
 
 	gl_Position = projection_matrix * modelview_matrix * outvec;
-
 }
 
 [fragment]
@@ -121,7 +120,6 @@ uniform vec2 screen_pixel_size;
 
 FRAGMENT_SHADER_GLOBALS
 
-
 void main() {
 
 	vec4 color = color_interp;
@@ -135,11 +133,9 @@ void main() {
 
 FRAGMENT_SHADER_CODE
 
-
 }
 
 	color *= final_modulate;
 
 	gl_FragColor = color;
-
 }

drivers/gles2/shaders/canvas_shadow.glsl

@@ -1,20 +1,18 @@
 [vertex]
 
-
-
 uniform highp mat4 projection_matrix;
 uniform highp mat4 light_matrix;
 uniform highp mat4 world_matrix;
 uniform highp float distance_norm;
 
-layout(location=0) in highp vec3 vertex;
+layout(location = 0) in highp vec3 vertex;
 
 out highp vec4 position_interp;
 
 void main() {
 
-	gl_Position = projection_matrix * (light_matrix * (world_matrix *  vec4(vertex,1.0)));
-	position_interp=gl_Position;
+	gl_Position = projection_matrix * (light_matrix * (world_matrix * vec4(vertex, 1.0)));
+	position_interp = gl_Position;
 }
 
 [fragment]
@@ -23,27 +21,26 @@ in highp vec4 position_interp;
 
 #ifdef USE_RGBA_SHADOWS
 
-layout(location=0) out lowp vec4 distance_buf;
+layout(location = 0) out lowp vec4 distance_buf;
 
 #else
 
-layout(location=0) out highp float distance_buf;
+layout(location = 0) out highp float distance_buf;
 
 #endif
 
 void main() {
 
-	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0;//bias;
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0; //bias;
 
 #ifdef USE_RGBA_SHADOWS
 
 	highp vec4 comp = fract(depth * vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0));
 	comp -= comp.xxyz * vec4(0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
-	distance_buf=comp;
+	distance_buf = comp;
 #else
 
-	distance_buf=depth;
+	distance_buf = depth;
 
 #endif
 }
-

drivers/gles2/shaders/copy.glsl

@@ -85,17 +85,15 @@ uniform float custom_alpha;
 vec4 texturePanorama(sampler2D pano, vec3 normal) {
 
 	vec2 st = vec2(
-	        atan(normal.x, normal.z),
-	        acos(normal.y)
-	);
+			atan(normal.x, normal.z),
+			acos(normal.y));
 
-	if(st.x < 0.0)
-		st.x += M_PI*2.0;
+	if (st.x < 0.0)
+		st.x += M_PI * 2.0;
 
-	st/=vec2(M_PI*2.0,M_PI);
-
-	return texture2D(pano,st);
+	st /= vec2(M_PI * 2.0, M_PI);
 
+	return texture2D(pano, st);
 }
 
 #endif
@@ -109,16 +107,15 @@ void main() {
 #elif defined(USE_CUBEMAP)
 	vec4 color = textureCube(source_cube, normalize(cube_interp));
 #else
-	vec4 color = texture2D( source,  uv_interp );
+	vec4 color = texture2D(source, uv_interp);
 #endif
 
-
 #ifdef USE_NO_ALPHA
-	color.a=1.0;
+	color.a = 1.0;
 #endif
 
 #ifdef USE_CUSTOM_ALPHA
-	color.a=custom_alpha;
+	color.a = custom_alpha;
 #endif
 
 #ifdef USE_MULTIPLIER

drivers/gles2/shaders/cube_to_dp.glsl

@@ -39,55 +39,53 @@ uniform highp float bias;
 
 void main() {
 
-	highp vec3 normal = vec3( uv_interp * 2.0 - 1.0, 0.0 );
-/*
-	if(z_flip) {
-		normal.z = 0.5 - 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+	highp vec3 normal = vec3(uv_interp * 2.0 - 1.0, 0.0);
+	/*
+	if (z_flip) {
+		normal.z = 0.5 - 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
 	} else {
-		normal.z = -0.5 + 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+		normal.z = -0.5 + 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
 	}
-*/
+	*/
 
-	//normal.z = sqrt(1.0-dot(normal.xy,normal.xy));
-	//normal.xy*=1.0+normal.z;
+	//normal.z = sqrt(1.0 - dot(normal.xy, normal.xy));
+	//normal.xy *= 1.0 + normal.z;
 
-	normal.z = 0.5 - 0.5*((normal.x * normal.x) + (normal.y * normal.y));
+	normal.z = 0.5 - 0.5 * ((normal.x * normal.x) + (normal.y * normal.y));
 	normal = normalize(normal);
+	/*
+	normal.z = 0.5;
+	normal = normalize(normal);
+	*/
 
-/*
-	normal.z=0.5;
-	normal=normalize(normal);
-*/
 	if (!z_flip) {
-		normal.z=-normal.z;
+		normal.z = -normal.z;
 	}
 
 	//normal = normalize(vec3( uv_interp * 2.0 - 1.0, 1.0 ));
-	float depth = textureCube(source_cube,normal).r;
+	float depth = textureCube(source_cube, normal).r;
 
 	// absolute values for direction cosines, bigger value equals closer to basis axis
 	vec3 unorm = abs(normal);
 
-	if ( (unorm.x >= unorm.y) && (unorm.x >= unorm.z) ) {
-	    // x code
-	    unorm = normal.x > 0.0 ?  vec3( 1.0, 0.0, 0.0 ) : vec3( -1.0, 0.0, 0.0 ) ;
-	} else if ( (unorm.y > unorm.x) && (unorm.y >= unorm.z) ) {
-	    // y code
-	    unorm = normal.y > 0.0 ?  vec3( 0.0, 1.0, 0.0 ) :  vec3( 0.0, -1.0, 0.0 ) ;
-	} else if ( (unorm.z > unorm.x) && (unorm.z > unorm.y) ) {
-	    // z code
-	    unorm = normal.z > 0.0 ?  vec3( 0.0, 0.0, 1.0 ) :  vec3( 0.0, 0.0, -1.0 ) ;
+	if ((unorm.x >= unorm.y) && (unorm.x >= unorm.z)) {
+		// x code
+		unorm = normal.x > 0.0 ? vec3(1.0, 0.0, 0.0) : vec3(-1.0, 0.0, 0.0);
+	} else if ((unorm.y > unorm.x) && (unorm.y >= unorm.z)) {
+		// y code
+		unorm = normal.y > 0.0 ? vec3(0.0, 1.0, 0.0) : vec3(0.0, -1.0, 0.0);
+	} else if ((unorm.z > unorm.x) && (unorm.z > unorm.y)) {
+		// z code
+		unorm = normal.z > 0.0 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 0.0, -1.0);
 	} else {
-	    // oh-no we messed up code
-	    // has to be
-	    unorm = vec3( 1.0, 0.0, 0.0 );
+		// oh-no we messed up code
+		// has to be
+		unorm = vec3(1.0, 0.0, 0.0);
 	}
 
-	float depth_fix = 1.0 / dot(normal,unorm);
-
+	float depth_fix = 1.0 / dot(normal, unorm);
 
 	depth = 2.0 * depth - 1.0;
 	float linear_depth = 2.0 * z_near * z_far / (z_far + z_near - depth * (z_far - z_near));
-	gl_FragDepth = (linear_depth*depth_fix+bias) / z_far;
+	gl_FragDepth = (linear_depth * depth_fix + bias) / z_far;
 }
-

drivers/gles2/shaders/cubemap_filter.glsl

@@ -15,8 +15,8 @@ varying highp vec2 uv_interp;
 
 void main() {
 
-	uv_interp=uv;
-	gl_Position=vec4(vertex,0,1);
+	uv_interp = uv;
+	gl_Position = vec4(vertex, 0, 1);
 }
 
 [fragment]
@@ -65,17 +65,15 @@ uniform sampler2D radical_inverse_vdc_cache; // texunit:1
 vec4 texturePanorama(sampler2D pano, vec3 normal) {
 
 	vec2 st = vec2(
-	        atan(normal.x, normal.z),
-	        acos(normal.y)
-	);
+			atan(normal.x, normal.z),
+			acos(normal.y));
 
-	if(st.x < 0.0)
-		st.x += M_PI*2.0;
+	if (st.x < 0.0)
+		st.x += M_PI * 2.0;
 
-	st/=vec2(M_PI*2.0,M_PI);
-
-	return texture2DLod(pano,st,0.0);
+	st /= vec2(M_PI * 2.0, M_PI);
 
+	return texture2DLod(pano, st, 0.0);
 }
 
 #endif
@@ -84,24 +82,24 @@ vec3 texelCoordToVec(vec2 uv, int faceID) {
 	mat3 faceUvVectors[6];
 
 	// -x
-	faceUvVectors[0][0] = vec3(0.0, 0.0, 1.0);  // u -> +z
+	faceUvVectors[0][0] = vec3(0.0, 0.0, 1.0); // u -> +z
 	faceUvVectors[0][1] = vec3(0.0, -1.0, 0.0); // v -> -y
 	faceUvVectors[0][2] = vec3(-1.0, 0.0, 0.0); // -x face
 
 	// +x
 	faceUvVectors[1][0] = vec3(0.0, 0.0, -1.0); // u -> -z
 	faceUvVectors[1][1] = vec3(0.0, -1.0, 0.0); // v -> -y
-	faceUvVectors[1][2] = vec3(1.0, 0.0, 0.0);  // +x face
+	faceUvVectors[1][2] = vec3(1.0, 0.0, 0.0); // +x face
 
 	// -y
-	faceUvVectors[2][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+	faceUvVectors[2][0] = vec3(1.0, 0.0, 0.0); // u -> +x
 	faceUvVectors[2][1] = vec3(0.0, 0.0, -1.0); // v -> -z
 	faceUvVectors[2][2] = vec3(0.0, -1.0, 0.0); // -y face
 
 	// +y
-	faceUvVectors[3][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
-	faceUvVectors[3][1] = vec3(0.0, 0.0, 1.0);  // v -> +z
-	faceUvVectors[3][2] = vec3(0.0, 1.0, 0.0);  // +y face
+	faceUvVectors[3][0] = vec3(1.0, 0.0, 0.0); // u -> +x
+	faceUvVectors[3][1] = vec3(0.0, 0.0, 1.0); // v -> +z
+	faceUvVectors[3][2] = vec3(0.0, 1.0, 0.0); // +y face
 
 	// -z
 	faceUvVectors[4][0] = vec3(-1.0, 0.0, 0.0); // u -> -x
@@ -109,9 +107,9 @@ vec3 texelCoordToVec(vec2 uv, int faceID) {
 	faceUvVectors[4][2] = vec3(0.0, 0.0, -1.0); // -z face
 
 	// +z
-	faceUvVectors[5][0] = vec3(1.0, 0.0, 0.0);  // u -> +x
+	faceUvVectors[5][0] = vec3(1.0, 0.0, 0.0); // u -> +x
 	faceUvVectors[5][1] = vec3(0.0, -1.0, 0.0); // v -> -y
-	faceUvVectors[5][2] = vec3(0.0, 0.0, 1.0);  // +z face
+	faceUvVectors[5][2] = vec3(0.0, 0.0, 1.0); // +z face
 
 	// out = u * s_faceUv[0] + v * s_faceUv[1] + s_faceUv[2].
 	vec3 result = (faceUvVectors[faceID][0] * uv.x) + (faceUvVectors[faceID][1] * uv.y) + faceUvVectors[faceID][2];
@@ -123,7 +121,7 @@ vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N) {
 
 	// Compute distribution direction
 	float Phi = 2.0 * M_PI * Xi.x;
-	float CosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y));
+	float CosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y));
 	float SinTheta = sqrt(1.0 - CosTheta * CosTheta);
 
 	// Convert to spherical direction
@@ -179,14 +177,10 @@ void main() {
 #endif
 
 			sum.a += NdotL;
-
 		}
-
 	}
 
 	sum /= sum.a;
 
 	gl_FragColor = vec4(sum.rgb, 1.0);
-
 }
-

drivers/gles2/shaders/effect_blur.glsl

@@ -1,8 +1,7 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-layout(location=4) in vec2 uv_in;
+layout(location = 0) in highp vec4 vertex_attrib;
+layout(location = 4) in vec2 uv_in;
 
 out vec2 uv_interp;
 
@@ -39,7 +38,6 @@ uniform sampler2D source_ssao; //texunit:1
 uniform float lod;
 uniform vec2 pixel_size;
 
-
 layout(location = 0) out vec4 frag_color;
 
 #ifdef SSAO_MERGE
@@ -48,31 +46,31 @@ uniform vec4 ssao_color;
 
 #endif
 
-#if defined (GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
+#if defined(GLOW_GAUSSIAN_HORIZONTAL) || defined(GLOW_GAUSSIAN_VERTICAL)
 
 uniform float glow_strength;
 
 #endif
 
-#if defined(DOF_FAR_BLUR) || defined (DOF_NEAR_BLUR)
+#if defined(DOF_FAR_BLUR) || defined(DOF_NEAR_BLUR)
 
 #ifdef DOF_QUALITY_LOW
-const int dof_kernel_size=5;
-const int dof_kernel_from=2;
-const float dof_kernel[5] = float[] (0.153388,0.221461,0.250301,0.221461,0.153388);
+const int dof_kernel_size = 5;
+const int dof_kernel_from = 2;
+const float dof_kernel[5] = float[](0.153388, 0.221461, 0.250301, 0.221461, 0.153388);
 #endif
 
 #ifdef DOF_QUALITY_MEDIUM
-const int dof_kernel_size=11;
-const int dof_kernel_from=5;
-const float dof_kernel[11] = float[] (0.055037,0.072806,0.090506,0.105726,0.116061,0.119726,0.116061,0.105726,0.090506,0.072806,0.055037);
+const int dof_kernel_size = 11;
+const int dof_kernel_from = 5;
+const float dof_kernel[11] = float[](0.055037, 0.072806, 0.090506, 0.105726, 0.116061, 0.119726, 0.116061, 0.105726, 0.090506, 0.072806, 0.055037);
 
 #endif
 
 #ifdef DOF_QUALITY_HIGH
-const int dof_kernel_size=21;
-const int dof_kernel_from=10;
-const float dof_kernel[21] = float[] (0.028174,0.032676,0.037311,0.041944,0.046421,0.050582,0.054261,0.057307,0.059587,0.060998,0.061476,0.060998,0.059587,0.057307,0.054261,0.050582,0.046421,0.041944,0.037311,0.032676,0.028174);
+const int dof_kernel_size = 21;
+const int dof_kernel_from = 10;
+const float dof_kernel[21] = float[](0.028174, 0.032676, 0.037311, 0.041944, 0.046421, 0.050582, 0.054261, 0.057307, 0.059587, 0.060998, 0.061476, 0.060998, 0.059587, 0.057307, 0.054261, 0.050582, 0.046421, 0.041944, 0.037311, 0.032676, 0.028174);
 #endif
 
 uniform sampler2D dof_source_depth; //texunit:1
@@ -88,7 +86,6 @@ uniform sampler2D source_dof_original; //texunit:2
 
 #endif
 
-
 #ifdef GLOW_FIRST_PASS
 
 uniform float exposure;
@@ -112,53 +109,51 @@ uniform float camera_z_near;
 
 void main() {
 
-
-
 #ifdef GAUSSIAN_HORIZONTAL
 	vec2 pix_size = pixel_size;
-	pix_size*=0.5; //reading from larger buffer, so use more samples
-	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.214607;
-	color+=textureLod( source_color,  uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.189879;
-	color+=textureLod( source_color,  uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.157305;
-	color+=textureLod( source_color,  uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.071303;
-	color+=textureLod( source_color,  uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.189879;
-	color+=textureLod( source_color,  uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.157305;
-	color+=textureLod( source_color,  uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.071303;
+	pix_size *= 0.5; //reading from larger buffer, so use more samples
+	vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pix_size, lod) * 0.214607;
+	color += textureLod(source_color, uv_interp + vec2(1.0, 0.0) * pix_size, lod) * 0.189879;
+	color += textureLod(source_color, uv_interp + vec2(2.0, 0.0) * pix_size, lod) * 0.157305;
+	color += textureLod(source_color, uv_interp + vec2(3.0, 0.0) * pix_size, lod) * 0.071303;
+	color += textureLod(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size, lod) * 0.189879;
+	color += textureLod(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size, lod) * 0.157305;
+	color += textureLod(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size, lod) * 0.071303;
 	frag_color = color;
 #endif
 
 #ifdef GAUSSIAN_VERTICAL
-	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pixel_size,lod )*0.38774;
-	color+=textureLod( source_color,  uv_interp+vec2( 0.0, 1.0)*pixel_size,lod )*0.24477;
-	color+=textureLod( source_color,  uv_interp+vec2( 0.0, 2.0)*pixel_size,lod )*0.06136;
-	color+=textureLod( source_color,  uv_interp+vec2( 0.0,-1.0)*pixel_size,lod )*0.24477;
-	color+=textureLod( source_color,  uv_interp+vec2( 0.0,-2.0)*pixel_size,lod )*0.06136;
+	vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pixel_size, lod) * 0.38774;
+	color += textureLod(source_color, uv_interp + vec2(0.0, 1.0) * pixel_size, lod) * 0.24477;
+	color += textureLod(source_color, uv_interp + vec2(0.0, 2.0) * pixel_size, lod) * 0.06136;
+	color += textureLod(source_color, uv_interp + vec2(0.0, -1.0) * pixel_size, lod) * 0.24477;
+	color += textureLod(source_color, uv_interp + vec2(0.0, -2.0) * pixel_size, lod) * 0.06136;
 	frag_color = color;
 #endif
 
-//glow uses larger sigma for a more rounded blur effect
+	//glow uses larger sigma for a more rounded blur effect
 
 #ifdef GLOW_GAUSSIAN_HORIZONTAL
 	vec2 pix_size = pixel_size;
-	pix_size*=0.5; //reading from larger buffer, so use more samples
-	vec4 color =textureLod( source_color,  uv_interp+vec2( 0.0, 0.0)*pix_size,lod )*0.174938;
-	color+=textureLod( source_color,  uv_interp+vec2( 1.0, 0.0)*pix_size,lod )*0.165569;
-	color+=textureLod( source_color,  uv_interp+vec2( 2.0, 0.0)*pix_size,lod )*0.140367;
-	color+=textureLod( source_color,  uv_interp+vec2( 3.0, 0.0)*pix_size,lod )*0.106595;
-	color+=textureLod( source_color,  uv_interp+vec2(-1.0, 0.0)*pix_size,lod )*0.165569;
-	color+=textureLod( source_color,  uv_interp+vec2(-2.0, 0.0)*pix_size,lod )*0.140367;
-	color+=textureLod( source_color,  uv_interp+vec2(-3.0, 0.0)*pix_size,lod )*0.106595;
-	color*=glow_strength;
+	pix_size *= 0.5; //reading from larger buffer, so use more samples
+	vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pix_size, lod) * 0.174938;
+	color += textureLod(source_color, uv_interp + vec2(1.0, 0.0) * pix_size, lod) * 0.165569;
+	color += textureLod(source_color, uv_interp + vec2(2.0, 0.0) * pix_size, lod) * 0.140367;
+	color += textureLod(source_color, uv_interp + vec2(3.0, 0.0) * pix_size, lod) * 0.106595;
+	color += textureLod(source_color, uv_interp + vec2(-1.0, 0.0) * pix_size, lod) * 0.165569;
+	color += textureLod(source_color, uv_interp + vec2(-2.0, 0.0) * pix_size, lod) * 0.140367;
+	color += textureLod(source_color, uv_interp + vec2(-3.0, 0.0) * pix_size, lod) * 0.106595;
+	color *= glow_strength;
 	frag_color = color;
 #endif
 
 #ifdef GLOW_GAUSSIAN_VERTICAL
-	vec4 color =textureLod( source_color,  uv_interp+vec2(0.0, 0.0)*pixel_size,lod )*0.288713;
-	color+=textureLod( source_color,  uv_interp+vec2(0.0, 1.0)*pixel_size,lod )*0.233062;
-	color+=textureLod( source_color,  uv_interp+vec2(0.0, 2.0)*pixel_size,lod )*0.122581;
-	color+=textureLod( source_color,  uv_interp+vec2(0.0,-1.0)*pixel_size,lod )*0.233062;
-	color+=textureLod( source_color,  uv_interp+vec2(0.0,-2.0)*pixel_size,lod )*0.122581;
-	color*=glow_strength;
+	vec4 color = textureLod(source_color, uv_interp + vec2(0.0, 0.0) * pixel_size, lod) * 0.288713;
+	color += textureLod(source_color, uv_interp + vec2(0.0, 1.0) * pixel_size, lod) * 0.233062;
+	color += textureLod(source_color, uv_interp + vec2(0.0, 2.0) * pixel_size, lod) * 0.122581;
+	color += textureLod(source_color, uv_interp + vec2(0.0, -1.0) * pixel_size, lod) * 0.233062;
+	color += textureLod(source_color, uv_interp + vec2(0.0, -2.0) * pixel_size, lod) * 0.122581;
+	color *= glow_strength;
 	frag_color = color;
 #endif
 
@@ -166,47 +161,45 @@ void main() {
 
 	vec4 color_accum = vec4(0.0);
 
-	float depth = textureLod( dof_source_depth, uv_interp, 0.0).r;
+	float depth = textureLod(dof_source_depth, uv_interp, 0.0).r;
 	depth = depth * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-	depth = ((depth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+	depth = ((depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 	depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
 #endif
 
-	float amount = smoothstep(dof_begin,dof_end,depth);
-	float k_accum=0.0;
+	float amount = smoothstep(dof_begin, dof_end, depth);
+	float k_accum = 0.0;
 
-	for(int i=0;i<dof_kernel_size;i++) {
+	for (int i = 0; i < dof_kernel_size; i++) {
 
-		int int_ofs = i-dof_kernel_from;
+		int int_ofs = i - dof_kernel_from;
 		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * amount * dof_radius;
 
 		float tap_k = dof_kernel[i];
 
-		float tap_depth = texture( dof_source_depth, tap_uv, 0.0).r;
+		float tap_depth = texture(dof_source_depth, tap_uv, 0.0).r;
 		tap_depth = tap_depth * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-		tap_depth = ((tap_depth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+		tap_depth = ((tap_depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
 #endif
-		float tap_amount = mix(smoothstep(dof_begin,dof_end,tap_depth),1.0,int_ofs==0);
-		tap_amount*=tap_amount*tap_amount; //prevent undesired glow effect
-
-		vec4 tap_color = textureLod( source_color, tap_uv, 0.0) * tap_k;
-
-		k_accum+=tap_k*tap_amount;
-		color_accum+=tap_color*tap_amount;
+		float tap_amount = mix(smoothstep(dof_begin, dof_end, tap_depth), 1.0, int_ofs == 0);
+		tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
 
+		vec4 tap_color = textureLod(source_color, tap_uv, 0.0) * tap_k;
 
+		k_accum += tap_k * tap_amount;
+		color_accum += tap_color * tap_amount;
 	}
 
-	if (k_accum>0.0) {
-		color_accum/=k_accum;
+	if (k_accum > 0.0) {
+		color_accum /= k_accum;
 	}
 
-	frag_color = color_accum;///k_accum;
+	frag_color = color_accum; ///k_accum;
 
 #endif
 
@@ -214,47 +207,45 @@ void main() {
 
 	vec4 color_accum = vec4(0.0);
 
-	float max_accum=0;
+	float max_accum = 0;
 
-	for(int i=0;i<dof_kernel_size;i++) {
+	for (int i = 0; i < dof_kernel_size; i++) {
 
-		int int_ofs = i-dof_kernel_from;
+		int int_ofs = i - dof_kernel_from;
 		vec2 tap_uv = uv_interp + dof_dir * float(int_ofs) * dof_radius;
-		float ofs_influence = max(0.0,1.0-float(abs(int_ofs))/float(dof_kernel_from));
+		float ofs_influence = max(0.0, 1.0 - float(abs(int_ofs)) / float(dof_kernel_from));
 
 		float tap_k = dof_kernel[i];
 
-		vec4 tap_color = textureLod( source_color, tap_uv, 0.0);
+		vec4 tap_color = textureLod(source_color, tap_uv, 0.0);
 
-		float tap_depth = texture( dof_source_depth, tap_uv, 0.0).r;
+		float tap_depth = texture(dof_source_depth, tap_uv, 0.0).r;
 		tap_depth = tap_depth * 2.0 - 1.0;
-#ifdef USE_ORTHOGONAL_PROJECTION	
-		tap_depth = ((tap_depth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+#ifdef USE_ORTHOGONAL_PROJECTION
+		tap_depth = ((tap_depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 		tap_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - tap_depth * (camera_z_far - camera_z_near));
 #endif
-		float tap_amount = 1.0-smoothstep(dof_end,dof_begin,tap_depth);
-		tap_amount*=tap_amount*tap_amount; //prevent undesired glow effect
+		float tap_amount = 1.0 - smoothstep(dof_end, dof_begin, tap_depth);
+		tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
 
 #ifdef DOF_NEAR_FIRST_TAP
 
-		tap_color.a= 1.0-smoothstep(dof_end,dof_begin,tap_depth);
+		tap_color.a = 1.0 - smoothstep(dof_end, dof_begin, tap_depth);
 
 #endif
 
-		max_accum=max(max_accum,tap_amount*ofs_influence);
-
-		color_accum+=tap_color*tap_k;
+		max_accum = max(max_accum, tap_amount * ofs_influence);
 
+		color_accum += tap_color * tap_k;
 	}
 
-	color_accum.a=max(color_accum.a,sqrt(max_accum));
-
+	color_accum.a = max(color_accum.a, sqrt(max_accum));
 
 #ifdef DOF_NEAR_BLUR_MERGE
 
-	vec4 original = textureLod( source_dof_original, uv_interp, 0.0);
-	color_accum = mix(original,color_accum,color_accum.a);
+	vec4 original = textureLod(source_dof_original, uv_interp, 0.0);
+	color_accum = mix(original, color_accum, color_accum.a);
 
 #endif
 
@@ -265,37 +256,32 @@ void main() {
 
 #endif
 
-
-
 #ifdef GLOW_FIRST_PASS
 
 #ifdef GLOW_USE_AUTO_EXPOSURE
 
-	frag_color/=texelFetch(source_auto_exposure,ivec2(0,0),0).r/auto_exposure_grey;
+	frag_color /= texelFetch(source_auto_exposure, ivec2(0, 0), 0).r / auto_exposure_grey;
 #endif
-	frag_color*=exposure;
+	frag_color *= exposure;
 
-	float luminance = max(frag_color.r,max(frag_color.g,frag_color.b));
-	float feedback = max( smoothstep(glow_hdr_threshold,glow_hdr_threshold+glow_hdr_scale,luminance), glow_bloom );
+	float luminance = max(frag_color.r, max(frag_color.g, frag_color.b));
+	float feedback = max(smoothstep(glow_hdr_threshold, glow_hdr_threshold + glow_hdr_scale, luminance), glow_bloom);
 
 	frag_color *= feedback;
 
 #endif
 
-
 #ifdef SIMPLE_COPY
-	vec4 color =textureLod( source_color,  uv_interp,0.0);
+	vec4 color = textureLod(source_color, uv_interp, 0.0);
 	frag_color = color;
 #endif
 
 #ifdef SSAO_MERGE
 
-	vec4 color =textureLod( source_color,  uv_interp,0.0);
-	float ssao =textureLod( source_ssao,  uv_interp,0.0).r;
+	vec4 color = textureLod(source_color, uv_interp, 0.0);
+	float ssao = textureLod(source_ssao, uv_interp, 0.0).r;
 
-	frag_color = vec4( mix(color.rgb,color.rgb*mix(ssao_color.rgb,vec3(1.0),ssao),color.a), 1.0 );
+	frag_color = vec4(mix(color.rgb, color.rgb * mix(ssao_color.rgb, vec3(1.0), ssao), color.a), 1.0);
 
 #endif
-
-
 }

drivers/gles2/shaders/exposure.glsl

@@ -1,18 +1,14 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-
+layout(location = 0) in highp vec4 vertex_attrib;
 
 void main() {
 
 	gl_Position = vertex_attrib;
-
 }
 
 [fragment]
 
-
 uniform highp sampler2D source_exposure; //texunit:0
 
 #ifdef EXPOSURE_BEGIN
@@ -33,66 +29,56 @@ uniform highp float max_luminance;
 
 layout(location = 0) out highp float exposure;
 
-
-
 void main() {
 
-
-
 #ifdef EXPOSURE_BEGIN
 
-
-	ivec2 src_pos = ivec2(gl_FragCoord.xy)*source_render_size/target_size;
+	ivec2 src_pos = ivec2(gl_FragCoord.xy) * source_render_size / target_size;
 
 #if 1
 	//more precise and expensive, but less jittery
-	ivec2 next_pos = ivec2(gl_FragCoord.xy+ivec2(1))*source_render_size/target_size;
-	next_pos = max(next_pos,src_pos+ivec2(1)); //so it at least reads one pixel
-	highp vec3 source_color=vec3(0.0);
-	for(int i=src_pos.x;i<next_pos.x;i++) {
-		for(int j=src_pos.y;j<next_pos.y;j++) {
-			source_color += texelFetch(source_exposure,ivec2(i,j),0).rgb;
+	ivec2 next_pos = ivec2(gl_FragCoord.xy + ivec2(1)) * source_render_size / target_size;
+	next_pos = max(next_pos, src_pos + ivec2(1)); //so it at least reads one pixel
+	highp vec3 source_color = vec3(0.0);
+	for (int i = src_pos.x; i < next_pos.x; i++) {
+		for (int j = src_pos.y; j < next_pos.y; j++) {
+			source_color += texelFetch(source_exposure, ivec2(i, j), 0).rgb;
 		}
 	}
 
-	source_color/=float( (next_pos.x-src_pos.x)*(next_pos.y-src_pos.y) );
+	source_color /= float((next_pos.x - src_pos.x) * (next_pos.y - src_pos.y));
 #else
-	highp vec3 source_color = texelFetch(source_exposure,src_pos,0).rgb;
+	highp vec3 source_color = texelFetch(source_exposure, src_pos, 0).rgb;
 
 #endif
 
-	exposure = max(source_color.r,max(source_color.g,source_color.b));
+	exposure = max(source_color.r, max(source_color.g, source_color.b));
 
 #else
 
 	ivec2 coord = ivec2(gl_FragCoord.xy);
-	exposure  = texelFetch(source_exposure,coord*3+ivec2(0,0),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(1,0),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(2,0),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(0,1),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(1,1),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(2,1),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(0,2),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(1,2),0).r;
-	exposure += texelFetch(source_exposure,coord*3+ivec2(2,2),0).r;
-	exposure *= (1.0/9.0);
+	exposure = texelFetch(source_exposure, coord * 3 + ivec2(0, 0), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 0), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 0), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(0, 1), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 1), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 1), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(0, 2), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(1, 2), 0).r;
+	exposure += texelFetch(source_exposure, coord * 3 + ivec2(2, 2), 0).r;
+	exposure *= (1.0 / 9.0);
 
 #ifdef EXPOSURE_END
 
 #ifdef EXPOSURE_FORCE_SET
 	//will stay as is
 #else
-	highp float prev_lum = texelFetch(prev_exposure,ivec2(0,0),0).r; //1 pixel previous exposure
-	exposure = clamp( prev_lum + (exposure-prev_lum)*exposure_adjust,min_luminance,max_luminance);
+	highp float prev_lum = texelFetch(prev_exposure, ivec2(0, 0), 0).r; //1 pixel previous exposure
+	exposure = clamp(prev_lum + (exposure - prev_lum) * exposure_adjust, min_luminance, max_luminance);
 
 #endif //EXPOSURE_FORCE_SET
 
-
 #endif //EXPOSURE_END
 
 #endif //EXPOSURE_BEGIN
-
-
 }
-
-

drivers/gles2/shaders/particles.glsl

@@ -1,14 +1,11 @@
 [vertex]
 
-
-
-layout(location=0) in highp vec4 color;
-layout(location=1) in highp vec4 velocity_active;
-layout(location=2) in highp vec4 custom;
-layout(location=3) in highp vec4 xform_1;
-layout(location=4) in highp vec4 xform_2;
-layout(location=5) in highp vec4 xform_3;
-
+layout(location = 0) in highp vec4 color;
+layout(location = 1) in highp vec4 velocity_active;
+layout(location = 2) in highp vec4 custom;
+layout(location = 3) in highp vec4 xform_1;
+layout(location = 4) in highp vec4 xform_2;
+layout(location = 5) in highp vec4 xform_3;
 
 struct Attractor {
 
@@ -39,7 +36,6 @@ uniform float lifetime;
 uniform mat4 emission_transform;
 uniform uint random_seed;
 
-
 out highp vec4 out_color; //tfb:
 out highp vec4 out_velocity_active; //tfb:
 out highp vec4 out_custom; //tfb:
@@ -47,7 +43,6 @@ out highp vec4 out_xform_1; //tfb:
 out highp vec4 out_xform_2; //tfb:
 out highp vec4 out_xform_3; //tfb:
 
-
 #if defined(USE_MATERIAL)
 
 layout(std140) uniform UniformData { //ubo:0
@@ -58,7 +53,6 @@ MATERIAL_UNIFORMS
 
 #endif
 
-
 VERTEX_SHADER_GLOBALS
 
 uint hash(uint x) {
@@ -69,13 +63,12 @@ uint hash(uint x) {
 	return x;
 }
 
-
 void main() {
 
 #ifdef PARTICLES_COPY
 
-	out_color=color;
-	out_velocity_active=velocity_active;
+	out_color = color;
+	out_velocity_active = velocity_active;
 	out_custom = custom;
 	out_xform_1 = xform_1;
 	out_xform_2 = xform_2;
@@ -83,34 +76,34 @@ void main() {
 
 #else
 
-	bool apply_forces=true;
-	bool apply_velocity=true;
-	float local_delta=delta;
+	bool apply_forces = true;
+	bool apply_velocity = true;
+	float local_delta = delta;
 
 	float mass = 1.0;
 
-	float restart_phase = float(gl_VertexID)/float(total_particles);
+	float restart_phase = float(gl_VertexID) / float(total_particles);
 
-	if (randomness>0.0) {
+	if (randomness > 0.0) {
 		uint seed = cycle;
 		if (restart_phase >= system_phase) {
-			seed-=uint(1);
+			seed -= uint(1);
 		}
-		seed*=uint(total_particles);
-		seed+=uint(gl_VertexID);
+		seed *= uint(total_particles);
+		seed += uint(gl_VertexID);
 		float random = float(hash(seed) % uint(65536)) / 65536.0;
-		restart_phase+=randomness * random * 1.0 / float(total_particles);
+		restart_phase += randomness * random * 1.0 / float(total_particles);
 	}
 
-	restart_phase*= (1.0-explosiveness);
-	bool restart=false;
+	restart_phase *= (1.0 - explosiveness);
+	bool restart = false;
 	bool shader_active = velocity_active.a > 0.5;
 
 	if (system_phase > prev_system_phase) {
 		// restart_phase >= prev_system_phase is used so particles emit in the first frame they are processed
 
-		if (restart_phase >= prev_system_phase && restart_phase < system_phase ) {
-			restart=true;
+		if (restart_phase >= prev_system_phase && restart_phase < system_phase) {
+			restart = true;
 #ifdef USE_FRACTIONAL_DELTA
 			local_delta = (system_phase - restart_phase) * lifetime;
 #endif
@@ -118,12 +111,12 @@ void main() {
 
 	} else {
 		if (restart_phase >= prev_system_phase) {
-			restart=true;
+			restart = true;
 #ifdef USE_FRACTIONAL_DELTA
 			local_delta = (1.0 - restart_phase + system_phase) * lifetime;
 #endif
-		} else if (restart_phase < system_phase ) {
-			restart=true;
+		} else if (restart_phase < system_phase) {
+			restart = true;
 #ifdef USE_FRACTIONAL_DELTA
 			local_delta = (system_phase - restart_phase) * lifetime;
 #endif
@@ -133,14 +126,14 @@ void main() {
 	uint current_cycle = cycle;
 
 	if (system_phase < restart_phase) {
-		current_cycle-=uint(1);
+		current_cycle -= uint(1);
 	}
 
 	uint particle_number = current_cycle * uint(total_particles) + uint(gl_VertexID);
 	int index = int(gl_VertexID);
 
 	if (restart) {
-		shader_active=emitting;
+		shader_active = emitting;
 	}
 
 	mat4 xform;
@@ -150,30 +143,31 @@ void main() {
 #else
 	if (clear || restart) {
 #endif
-		out_color=vec4(1.0);
-		out_velocity_active=vec4(0.0);
-		out_custom=vec4(0.0);
+		out_color = vec4(1.0);
+		out_velocity_active = vec4(0.0);
+		out_custom = vec4(0.0);
 		if (!restart)
-			shader_active=false;
+			shader_active = false;
 
 		xform = mat4(
-				vec4(1.0,0.0,0.0,0.0),
-				vec4(0.0,1.0,0.0,0.0),
-				vec4(0.0,0.0,1.0,0.0),
-				vec4(0.0,0.0,0.0,1.0)
-			);
+				vec4(1.0, 0.0, 0.0, 0.0),
+				vec4(0.0, 1.0, 0.0, 0.0),
+				vec4(0.0, 0.0, 1.0, 0.0),
+				vec4(0.0, 0.0, 0.0, 1.0));
 	} else {
-		out_color=color;
-		out_velocity_active=velocity_active;
-		out_custom=custom;
-		xform = transpose(mat4(xform_1,xform_2,xform_3,vec4(vec3(0.0),1.0)));
+		out_color = color;
+		out_velocity_active = velocity_active;
+		out_custom = custom;
+		xform = transpose(mat4(xform_1, xform_2, xform_3, vec4(vec3(0.0), 1.0)));
 	}
 
 	if (shader_active) {
 		//execute shader
 
 		{
+
 VERTEX_SHADER_CODE
+
 		}
 
 #if !defined(DISABLE_FORCE)
@@ -181,26 +175,25 @@ VERTEX_SHADER_CODE
 		if (false) {
 
 			vec3 force = vec3(0.0);
-			for(int i=0;i<attractor_count;i++) {
+			for (int i = 0; i < attractor_count; i++) {
 
 				vec3 rel_vec = xform[3].xyz - attractors[i].pos;
 				float dist = length(rel_vec);
 				if (attractors[i].radius < dist)
 					continue;
-				if (attractors[i].eat_radius>0.0 &&  attractors[i].eat_radius > dist) {
-					out_velocity_active.a=0.0;
+				if (attractors[i].eat_radius > 0.0 && attractors[i].eat_radius > dist) {
+					out_velocity_active.a = 0.0;
 				}
 
 				rel_vec = normalize(rel_vec);
 
-				float attenuation = pow(dist / attractors[i].radius,attractors[i].attenuation);
+				float attenuation = pow(dist / attractors[i].radius, attractors[i].attenuation);
 
-				if (attractors[i].dir==vec3(0.0)) {
+				if (attractors[i].dir == vec3(0.0)) {
 					//towards center
-					force+=attractors[i].strength * rel_vec * attenuation * mass;
+					force += attractors[i].strength * rel_vec * attenuation * mass;
 				} else {
-					force+=attractors[i].strength * attractors[i].dir * attenuation *mass;
-
+					force += attractors[i].strength * attractors[i].dir * attenuation * mass;
 				}
 			}
 
@@ -216,26 +209,24 @@ VERTEX_SHADER_CODE
 		}
 #endif
 	} else {
-		xform=mat4(0.0);
+		xform = mat4(0.0);
 	}
 
 	xform = transpose(xform);
 
-	out_velocity_active.a = mix(0.0,1.0,shader_active);
+	out_velocity_active.a = mix(0.0, 1.0, shader_active);
 
 	out_xform_1 = xform[0];
 	out_xform_2 = xform[1];
 	out_xform_3 = xform[2];
 
 #endif //PARTICLES_COPY
-
 }
 
 [fragment]
 
 //any code here is never executed, stuff is filled just so it works
 
-
 #if defined(USE_MATERIAL)
 
 layout(std140) uniform UniformData {

drivers/gles2/shaders/resolve.glsl

@@ -1,12 +1,10 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-layout(location=4) in vec2 uv_in;
+layout(location = 0) in highp vec4 vertex_attrib;
+layout(location = 4) in vec2 uv_in;
 
 out vec2 uv_interp;
 
-
 void main() {
 
 	uv_interp = uv_in;
@@ -31,14 +29,12 @@ layout(location = 0) out vec4 frag_color;
 
 void main() {
 
-	vec4 specular = texture( source_specular,  uv_interp );
+	vec4 specular = texture(source_specular, uv_interp);
 
 #ifdef USE_SSR
-
-	vec4 ssr = textureLod(source_ssr,uv_interp,0.0);
-	specular.rgb = mix(specular.rgb,ssr.rgb*specular.a,ssr.a);
+	vec4 ssr = textureLod(source_ssr, uv_interp, 0.0);
+	specular.rgb = mix(specular.rgb, ssr.rgb * specular.a, ssr.a);
 #endif
 
-	frag_color = vec4(specular.rgb,1.0);
+	frag_color = vec4(specular.rgb, 1.0);
 }
-

drivers/gles2/shaders/scene.glsl

@@ -10,8 +10,6 @@ precision mediump int;
 
 #include "stdlib.glsl"
 
-
-
 //
 // attributes
 //
@@ -66,8 +64,6 @@ attribute highp vec4 instance_custom_data; // attrib:8
 
 #endif
 
-
-
 //
 // uniforms
 //
@@ -88,7 +84,6 @@ uniform float light_bias;
 uniform float light_normal_bias;
 #endif
 
-
 //
 // varyings
 //
@@ -113,7 +108,6 @@ varying vec2 uv_interp;
 varying vec2 uv2_interp;
 #endif
 
-
 VERTEX_SHADER_GLOBALS
 
 void main() {
@@ -124,10 +118,11 @@ void main() {
 
 #ifdef USE_INSTANCING
 	{
-		highp mat4 m = mat4(instance_xform_row_0,
-		                    instance_xform_row_1,
-		                    instance_xform_row_2,
-		                    vec4(0.0, 0.0, 0.0, 1.0));
+		highp mat4 m = mat4(
+				instance_xform_row_0,
+				instance_xform_row_1,
+				instance_xform_row_2,
+				vec4(0.0, 0.0, 0.0, 1.0));
 		world_matrix = world_matrix * transpose(m);
 	}
 #endif
@@ -161,7 +156,7 @@ void main() {
 	normal = normalize((world_matrix * vec4(normal, 0.0)).xyz);
 #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
 
-	tangent = normalize((world_matrix * vec4(tangent, 0.0)),xyz);
+	tangent = normalize((world_matrix * vec4(tangent, 0.0)), xyz);
 	binormal = normalize((world_matrix * vec4(binormal, 0.0)).xyz);
 #endif
 #endif
@@ -185,11 +180,12 @@ void main() {
 		for (int i = 0; i < 4; i++) {
 			ivec2 tex_ofs = ivec2(int(bone_ids[i]) * 3, 0);
 
-			highp mat4 b = mat4(texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(0, 0)),
-			              texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(1, 0)),
-			              texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(2, 0)),
-			              vec4(0.0, 0.0, 0.0, 1.0));
-			
+			highp mat4 b = mat4(
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(0, 0)),
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(1, 0)),
+					texel2DFetch(bone_transforms, skeleton_texture_size, tex_ofs + ivec2(2, 0)),
+					vec4(0.0, 0.0, 0.0, 1.0));
+
 			bone_transform += transpose(b) * bone_weights[i];
 		}
 	}
@@ -199,7 +195,6 @@ void main() {
 	world_matrix = bone_transform * world_matrix;
 #endif
 
-
 #ifdef USE_INSTANCING
 	vec4 instance_custom = instance_custom_data;
 #else
@@ -207,7 +202,6 @@ void main() {
 
 #endif
 
-
 	mat4 modelview = camera_matrix * world_matrix;
 
 #define world_transform world_matrix
@@ -258,7 +252,6 @@ VERTEX_SHADER_CODE
 #endif
 
 	gl_Position = projection_matrix * vec4(vertex_interp, 1.0);
-
 }
 
 [fragment]
@@ -294,7 +287,6 @@ uniform mat4 world_transform;
 
 uniform highp float time;
 
-
 #ifdef SCREEN_UV_USED
 uniform vec2 screen_pixel_size;
 #endif
@@ -348,7 +340,6 @@ uniform float light_spot_attenuation;
 uniform float light_spot_range;
 uniform float light_spot_angle;
 
-
 // shadows
 uniform highp sampler2D light_shadow_atlas; //texunit:-4
 uniform float light_has_shadow;
@@ -367,7 +358,6 @@ uniform mat4 light_shadow_matrix3;
 uniform mat4 light_shadow_matrix4;
 #endif
 
-
 //
 // varyings
 //
@@ -402,27 +392,27 @@ vec3 metallic_to_specular_color(float metallic, float specular, vec3 albedo) {
 
 FRAGMENT_SHADER_GLOBALS
 
-
 #ifdef LIGHT_PASS
-void light_compute(vec3 N,
-                   vec3 L,
-                   vec3 V,
-                   vec3 B,
-                   vec3 T,
-                   vec3 light_color,
-                   vec3 attenuation,
-                   vec3 diffuse_color,
-                   vec3 transmission,
-                   float specular_blob_intensity,
-                   float roughness,
-                   float metallic,
-                   float rim,
-                   float rim_tint,
-                   float clearcoat,
-                   float clearcoat_gloss,
-                   float anisotropy,
-                   inout vec3 diffuse_light,
-                   inout vec3 specular_light) {
+void light_compute(
+		vec3 N,
+		vec3 L,
+		vec3 V,
+		vec3 B,
+		vec3 T,
+		vec3 light_color,
+		vec3 attenuation,
+		vec3 diffuse_color,
+		vec3 transmission,
+		float specular_blob_intensity,
+		float roughness,
+		float metallic,
+		float rim,
+		float rim_tint,
+		float clearcoat,
+		float clearcoat_gloss,
+		float anisotropy,
+		inout vec3 diffuse_light,
+		inout vec3 specular_light) {
 
 	float NdotL = dot(N, L);
 	float cNdotL = max(NdotL, 0.0);
@@ -435,7 +425,7 @@ void light_compute(vec3 N,
 		// TODO hardcode Oren Nayar for now
 		float diffuse_brdf_NL;
 
-		diffuse_brdf_NL = max(0.0,(NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
+		diffuse_brdf_NL = max(0.0, (NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
 		// diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
 
 		diffuse_light += light_color * diffuse_color * diffuse_brdf_NL * attenuation;
@@ -444,25 +434,21 @@ void light_compute(vec3 N,
 	{
 		// calculate specular reflection
 
-		vec3 R = normalize(-reflect(L,N));
+		vec3 R = normalize(-reflect(L, N));
 		float cRdotV = max(dot(R, V), 0.0);
 		float blob_intensity = pow(cRdotV, (1.0 - roughness) * 256.0);
 		specular_light += light_color * attenuation * blob_intensity * specular_blob_intensity;
-
 	}
 }
 
-
-
-
 // shadows
 
-float sample_shadow(highp sampler2D shadow,
-                    vec2 shadow_pixel_size,
-                    vec2 pos,
-                    float depth,
-                    vec4 clamp_rect)
-{
+float sample_shadow(
+		highp sampler2D shadow,
+		vec2 shadow_pixel_size,
+		vec2 pos,
+		float depth,
+		vec4 clamp_rect) {
 	// vec4 depth_value = texture2D(shadow, pos);
 
 	// return depth_value.z;
@@ -470,11 +456,9 @@ float sample_shadow(highp sampler2D shadow,
 	// return (depth_value.x + depth_value.y + depth_value.z + depth_value.w) / 4.0;
 }
 
-
 #endif
 
-void main()
-{
+void main() {
 
 	highp vec3 vertex = vertex_interp;
 	vec3 albedo = vec3(1.0);
@@ -498,7 +482,6 @@ void main()
 	float ao_light_affect = 0.0;
 #endif
 
-
 #if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP)
 	vec3 binormal = normalize(binormal_interp) * side;
 	vec3 tangent = normalize(tangent_interp) * side;
@@ -513,7 +496,6 @@ void main()
 #endif
 	float normaldepth = 1.0;
 
-
 #ifdef ALPHA_SCISSOR_USED
 	float alpha_scissor = 0.5;
 #endif
@@ -526,7 +508,6 @@ void main()
 
 FRAGMENT_SHADER_CODE
 
-
 }
 
 #if defined(ENABLE_NORMALMAP)
@@ -572,7 +553,7 @@ FRAGMENT_SHADER_CODE
 		vec3 attenuation = vec3(omni_attenuation);
 
 		if (light_has_shadow > 0.5) {
-			highp vec3 splane =  (light_shadow_matrix * vec4(vertex, 1.0)).xyz;
+			highp vec3 splane = (light_shadow_matrix * vec4(vertex, 1.0)).xyz;
 			float shadow_len = length(splane);
 
 			splane = normalize(splane);
@@ -601,25 +582,26 @@ FRAGMENT_SHADER_CODE
 			}
 		}
 
-		light_compute(normal,
-		              normalize(light_vec),
-		              eye_position,
-		              binormal,
-		              tangent,
-		              light_color.xyz * light_energy,
-		              attenuation,
-		              albedo,
-		              transmission,
-		              specular * light_specular,
-		              roughness,
-		              metallic,
-		              rim,
-		              rim_tint,
-		              clearcoat,
-		              clearcoat_gloss,
-		              anisotropy,
-		              diffuse_light,
-		              specular_light);
+		light_compute(
+				normal,
+				normalize(light_vec),
+				eye_position,
+				binormal,
+				tangent,
+				light_color.xyz * light_energy,
+				attenuation,
+				albedo,
+				transmission,
+				specular * light_specular,
+				roughness,
+				metallic,
+				rim,
+				rim_tint,
+				clearcoat,
+				clearcoat_gloss,
+				anisotropy,
+				diffuse_light,
+				specular_light);
 
 	} else if (light_type == LIGHT_TYPE_DIRECTIONAL) {
 
@@ -638,133 +620,130 @@ FRAGMENT_SHADER_CODE
 			if (depth_z < light_split_offsets.x) {
 #endif
 
-			vec3 pssm_coord;
-			float pssm_fade = 0.0;
+				vec3 pssm_coord;
+				float pssm_fade = 0.0;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-			float pssm_blend;
-			vec3 pssm_coord2;
-			bool use_blend = true;
+				float pssm_blend;
+				vec3 pssm_coord2;
+				bool use_blend = true;
 #endif
 
 #ifdef LIGHT_USE_PSSM4
-			if (depth_z < light_split_offsets.y) {
-				if (depth_z < light_split_offsets.x) {
-					highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
+				if (depth_z < light_split_offsets.y) {
+					if (depth_z < light_split_offsets.x) {
+						highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
+						pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-					splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-					pssm_coord2 = splane.xyz / splane.w;
+						splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
+						pssm_coord2 = splane.xyz / splane.w;
 
-					pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+						pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
 #endif
-				} else {
-					highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
+					} else {
+						highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
+						pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-					splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
-					pssm_coord2 = splane.xyz / splane.w;
+						splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
+						pssm_coord2 = splane.xyz / splane.w;
 
-					pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+						pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
 #endif
-				}
-			} else {
-				if (depth_z < light_split_offsets.z) {
+					}
+				} else {
+					if (depth_z < light_split_offsets.z) {
 
-					highp vec4 splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
+						highp vec4 splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
+						pssm_coord = splane.xyz / splane.w;
 
 #if defined(LIGHT_USE_PSSM_BLEND)
-					splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
-					pssm_coord2 = splane.xyz / splane.w;
-					pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
+						splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
+						pssm_coord2 = splane.xyz / splane.w;
+						pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
 #endif
 
-				} else {
+					} else {
 
-					highp vec4 splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
-					pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
+						highp vec4 splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
+						pssm_coord = splane.xyz / splane.w;
+						pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
 
 #if defined(LIGHT_USE_PSSM_BLEND)
-					use_blend = false;
+						use_blend = false;
 #endif
+					}
 				}
-			}
 
 #endif // LIGHT_USE_PSSM4
 
 #ifdef LIGHT_USE_PSSM2
-			if (depth_z < light_split_offsets.x) {
+				if (depth_z < light_split_offsets.x) {
 
-				highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-				pssm_coord = splane.xyz / splane.w;
+					highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
+					pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-				splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-				pssm_coord2 = splane.xyz / splane.w;
-				pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+					splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
+					pssm_coord2 = splane.xyz / splane.w;
+					pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
 #endif
-			} else {
-				highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-				pssm_coord = splane.xyz / splane.w;
-				pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+				} else {
+					highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
+					pssm_coord = splane.xyz / splane.w;
+					pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
 #ifdef LIGHT_USE_PSSM_BLEND
-				use_blend = false;
+					use_blend = false;
 #endif
-			}
+				}
 
 #endif // LIGHT_USE_PSSM2
 
 #if !defined(LIGHT_USE_PSSM4) && !defined(LIGHT_USE_PSSM2)
-			{
-				highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-				pssm_coord = splane.xyz / splane.w;
-			}
+				{
+					highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
+					pssm_coord = splane.xyz / splane.w;
+				}
 #endif
 
-			float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord.xy, pssm_coord.z, light_clamp);
+				float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord.xy, pssm_coord.z, light_clamp);
 
 #ifdef LIGHT_USE_PSSM_BLEND
-			if (use_blend) {
-				shadow = mix(shadow, sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord2.xy, pssm_coord2.z, light_clamp), pssm_blend);
-			}
+				if (use_blend) {
+					shadow = mix(shadow, sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord2.xy, pssm_coord2.z, light_clamp), pssm_blend);
+				}
 #endif
 
-			attenuation *= shadow;
-
-
-		}
-
+				attenuation *= shadow;
+			}
 		}
 
 		light_compute(normal,
-		              normalize(light_vec),
-		              eye_position,
-		              binormal,
-		              tangent,
-		              light_color.xyz * light_energy,
-		              attenuation,
-		              albedo,
-		              transmission,
-		              specular * light_specular,
-		              roughness,
-		              metallic,
-		              rim,
-		              rim_tint,
-		              clearcoat,
-		              clearcoat_gloss,
-		              anisotropy,
-		              diffuse_light,
-		              specular_light);
+				normalize(light_vec),
+				eye_position,
+				binormal,
+				tangent,
+				light_color.xyz * light_energy,
+				attenuation,
+				albedo,
+				transmission,
+				specular * light_specular,
+				roughness,
+				metallic,
+				rim,
+				rim_tint,
+				clearcoat,
+				clearcoat_gloss,
+				anisotropy,
+				diffuse_light,
+				specular_light);
 	} else if (light_type == LIGHT_TYPE_SPOT) {
 
 		vec3 light_att = vec3(1.0);
 
 		if (light_has_shadow > 0.5) {
-			highp vec4 splane =  (light_shadow_matrix * vec4(vertex, 1.0));
+			highp vec4 splane = (light_shadow_matrix * vec4(vertex, 1.0));
 			splane.xyz /= splane.w;
 
 			float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), splane.xy, splane.z, light_clamp);
@@ -773,8 +752,6 @@ FRAGMENT_SHADER_CODE
 			} else {
 				light_att = vec3(0.0);
 			}
-
-
 		}
 
 		vec3 light_rel_vec = light_position - vertex;
@@ -793,25 +770,26 @@ FRAGMENT_SHADER_CODE
 
 		light_att *= vec3(spot_attenuation);
 
-		light_compute(normal,
-		              normalize(light_rel_vec),
-		              eye_position,
-		              binormal,
-		              tangent,
-		              light_color.xyz * light_energy,
-		              light_att,
-		              albedo,
-		              transmission,
-		              specular * light_specular,
-		              roughness,
-		              metallic,
-		              rim,
-		              rim_tint,
-		              clearcoat,
-		              clearcoat_gloss,
-		              anisotropy,
-		              diffuse_light,
-		              specular_light);
+		light_compute(
+				normal,
+				normalize(light_rel_vec),
+				eye_position,
+				binormal,
+				tangent,
+				light_color.xyz * light_energy,
+				light_att,
+				albedo,
+				transmission,
+				specular * light_specular,
+				roughness,
+				metallic,
+				rim,
+				rim_tint,
+				clearcoat,
+				clearcoat_gloss,
+				anisotropy,
+				diffuse_light,
+				specular_light);
 	}
 
 	gl_FragColor = vec4(ambient_light + diffuse_light + specular_light, alpha);
@@ -823,7 +801,6 @@ FRAGMENT_SHADER_CODE
 
 #ifdef USE_RADIANCE_MAP
 
-
 	vec3 ref_vec = reflect(-eye_position, N);
 	ref_vec = normalize((radiance_inverse_xform * vec4(ref_vec, 0.0)).xyz);
 
@@ -836,7 +813,6 @@ FRAGMENT_SHADER_CODE
 		vec3 env_ambient = textureCubeLod(radiance_map, ambient_dir, RADIANCE_MAX_LOD).xyz * bg_energy;
 
 		ambient_light = mix(ambient_color.rgb, env_ambient, ambient_sky_contribution);
-
 	}
 
 	ambient_light *= ambient_energy;
@@ -860,28 +836,23 @@ FRAGMENT_SHADER_CODE
 	// TODO shadeless
 	{
 		const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
-		const vec4 c1 = vec4( 1.0, 0.0425, 1.04, -0.04);
+		const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
 		vec4 r = roughness * c0 + c1;
-		float ndotv = clamp(dot(normal,eye_position),0.0,1.0);
-		float a004 = min( r.x * r.x, exp2( -9.28 * ndotv ) ) * r.x + r.y;
-		vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;
+		float ndotv = clamp(dot(normal, eye_position), 0.0, 1.0);
+		float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;
+		vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;
 
 		vec3 specular_color = metallic_to_specular_color(metallic, specular, albedo);
 		specular_light *= AB.x * specular_color + AB.y;
 	}
 
-
 	gl_FragColor = vec4(ambient_light + diffuse_light + specular_light, alpha);
 	// gl_FragColor = vec4(normal, 1.0);
 
-
 #else
 	gl_FragColor = vec4(albedo, alpha);
 #endif
 #endif // RENDER_DEPTH
 
-
 #endif // lighting
-
-
 }

drivers/gles2/shaders/screen_space_reflection.glsl

@@ -1,8 +1,7 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-layout(location=4) in vec2 uv_in;
+layout(location = 0) in highp vec4 vertex_attrib;
+layout(location = 4) in vec2 uv_in;
 
 out vec2 uv_interp;
 out vec2 pos_interp;
@@ -11,12 +10,11 @@ void main() {
 
 	uv_interp = uv_in;
 	gl_Position = vertex_attrib;
-	pos_interp.xy=gl_Position.xy;
+	pos_interp.xy = gl_Position.xy;
 }
 
 [fragment]
 
-
 in vec2 uv_interp;
 in vec2 pos_interp;
 
@@ -40,81 +38,70 @@ uniform float depth_tolerance;
 uniform float distance_fade;
 uniform float curve_fade_in;
 
-
 layout(location = 0) out vec4 frag_color;
 
-
-vec2 view_to_screen(vec3 view_pos,out float w) {
-    vec4 projected = projection * vec4(view_pos, 1.0);
-    projected.xyz /= projected.w;
-    projected.xy = projected.xy * 0.5 + 0.5;
-    w=projected.w;
-    return projected.xy;
+vec2 view_to_screen(vec3 view_pos, out float w) {
+	vec4 projected = projection * vec4(view_pos, 1.0);
+	projected.xyz /= projected.w;
+	projected.xy = projected.xy * 0.5 + 0.5;
+	w = projected.w;
+	return projected.xy;
 }
 
-
-
 #define M_PI 3.14159265359
 
 void main() {
 
-
-	////
-
-	vec4 diffuse = texture( source_diffuse,  uv_interp );
-	vec4 normal_roughness = texture( source_normal_roughness, uv_interp);
+	vec4 diffuse = texture(source_diffuse, uv_interp);
+	vec4 normal_roughness = texture(source_normal_roughness, uv_interp);
 
 	vec3 normal;
 
-	normal = normal_roughness.xyz*2.0-1.0;
+	normal = normal_roughness.xyz * 2.0 - 1.0;
 
 	float roughness = normal_roughness.w;
 
-	float depth_tex = texture(source_depth,uv_interp).r;
+	float depth_tex = texture(source_depth, uv_interp).r;
 
-	vec4 world_pos = inverse_projection * vec4( uv_interp*2.0-1.0, depth_tex*2.0-1.0, 1.0 );
-	vec3 vertex = world_pos.xyz/world_pos.w;
+	vec4 world_pos = inverse_projection * vec4(uv_interp * 2.0 - 1.0, depth_tex * 2.0 - 1.0, 1.0);
+	vec3 vertex = world_pos.xyz / world_pos.w;
 
 	vec3 view_dir = normalize(vertex);
 	vec3 ray_dir = normalize(reflect(view_dir, normal));
 
-	if (dot(ray_dir,normal)<0.001) {
-		frag_color=vec4(0.0);
+	if (dot(ray_dir, normal) < 0.001) {
+		frag_color = vec4(0.0);
 		return;
 	}
 	//ray_dir = normalize(view_dir - normal * dot(normal,view_dir) * 2.0);
 
 	//ray_dir = normalize(vec3(1,1,-1));
 
-
 	////////////////
 
-
 	//make ray length and clip it against the near plane (don't want to trace beyond visible)
 	float ray_len = (vertex.z + ray_dir.z * camera_z_far) > -camera_z_near ? (-camera_z_near - vertex.z) / ray_dir.z : camera_z_far;
-	vec3 ray_end = vertex + ray_dir*ray_len;
+	vec3 ray_end = vertex + ray_dir * ray_len;
 
 	float w_begin;
-	vec2 vp_line_begin = view_to_screen(vertex,w_begin);
+	vec2 vp_line_begin = view_to_screen(vertex, w_begin);
 	float w_end;
-	vec2 vp_line_end = view_to_screen( ray_end, w_end);
-	vec2 vp_line_dir = vp_line_end-vp_line_begin;
+	vec2 vp_line_end = view_to_screen(ray_end, w_end);
+	vec2 vp_line_dir = vp_line_end - vp_line_begin;
 
 	//we need to interpolate w along the ray, to generate perspective correct reflections
 
-	w_begin = 1.0/w_begin;
-	w_end = 1.0/w_end;
+	w_begin = 1.0 / w_begin;
+	w_end = 1.0 / w_end;
 
+	float z_begin = vertex.z * w_begin;
+	float z_end = ray_end.z * w_end;
 
-	float z_begin = vertex.z*w_begin;
-	float z_end = ray_end.z*w_end;
-
-	vec2 line_begin = vp_line_begin/pixel_size;
-	vec2 line_dir = vp_line_dir/pixel_size;
+	vec2 line_begin = vp_line_begin / pixel_size;
+	vec2 line_dir = vp_line_dir / pixel_size;
 	float z_dir = z_end - z_begin;
 	float w_dir = w_end - w_begin;
 
-
 	// clip the line to the viewport edges
 
 	float scale_max_x = min(1.0, 0.99 * (1.0 - vp_line_begin.x) / max(1e-5, vp_line_dir.x));
@@ -124,121 +111,109 @@ void main() {
 	float line_clip = min(scale_max_x, scale_max_y) * min(scale_min_x, scale_min_y);
 	line_dir *= line_clip;
 	z_dir *= line_clip;
-	w_dir *=line_clip;
+	w_dir *= line_clip;
 
 	//clip z and w advance to line advance
 	vec2 line_advance = normalize(line_dir); //down to pixel
-	float step_size = length(line_advance)/length(line_dir);
-	float z_advance = z_dir*step_size; // adapt z advance to line advance
-	float w_advance = w_dir*step_size; // adapt w advance to line advance
+	float step_size = length(line_advance) / length(line_dir);
+	float z_advance = z_dir * step_size; // adapt z advance to line advance
+	float w_advance = w_dir * step_size; // adapt w advance to line advance
 
 	//make line advance faster if direction is closer to pixel edges (this avoids sampling the same pixel twice)
-	float advance_angle_adj = 1.0/max(abs(line_advance.x),abs(line_advance.y));
-	line_advance*=advance_angle_adj; // adapt z advance to line advance
-	z_advance*=advance_angle_adj;
-	w_advance*=advance_angle_adj;
+	float advance_angle_adj = 1.0 / max(abs(line_advance.x), abs(line_advance.y));
+	line_advance *= advance_angle_adj; // adapt z advance to line advance
+	z_advance *= advance_angle_adj;
+	w_advance *= advance_angle_adj;
 
 	vec2 pos = line_begin;
 	float z = z_begin;
 	float w = w_begin;
-	float z_from=z/w;
-	float z_to=z_from;
+	float z_from = z / w;
+	float z_to = z_from;
 	float depth;
-	vec2 prev_pos=pos;
+	vec2 prev_pos = pos;
 
-	bool found=false;
+	bool found = false;
 
-	float steps_taken=0.0;
+	float steps_taken = 0.0;
 
-	for(int i=0;i<num_steps;i++) {
+	for (int i = 0; i < num_steps; i++) {
 
-		pos+=line_advance;
-		z+=z_advance;
-		w+=w_advance;
+		pos += line_advance;
+		z += z_advance;
+		w += w_advance;
 
 		//convert to linear depth
 
-		depth = texture(source_depth, pos*pixel_size).r * 2.0 - 1.0;
+		depth = texture(source_depth, pos * pixel_size).r * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-		depth = ((depth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+		depth = ((depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 		depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
 #endif
-		depth=-depth;
+		depth = -depth;
 
 		z_from = z_to;
-		z_to = z/w;
+		z_to = z / w;
 
-		if (depth>z_to) {
+		if (depth > z_to) {
 			//if depth was surpassed
-			if (depth<=max(z_to,z_from)+depth_tolerance) {
+			if (depth <= max(z_to, z_from) + depth_tolerance) {
 				//check the depth tolerance
-				found=true;
+				found = true;
 			}
 			break;
 		}
 
-		steps_taken+=1.0;
-		prev_pos=pos;
+		steps_taken += 1.0;
+		prev_pos = pos;
 	}
 
-
-
-
 	if (found) {
 
-		float margin_blend=1.0;
-
+		float margin_blend = 1.0;
 
-		vec2 margin = vec2((viewport_size.x+viewport_size.y)*0.5*0.05); //make a uniform margin
-		if (any(bvec4(lessThan(pos,-margin),greaterThan(pos,viewport_size+margin)))) {
+		vec2 margin = vec2((viewport_size.x + viewport_size.y) * 0.5 * 0.05); //make a uniform margin
+		if (any(bvec4(lessThan(pos, -margin), greaterThan(pos, viewport_size + margin)))) {
 			//clip outside screen + margin
-			frag_color=vec4(0.0);
+			frag_color = vec4(0.0);
 			return;
 		}
 
 		{
 			//blend fading out towards external margin
-			vec2 margin_grad = mix(pos-viewport_size,-pos,lessThan(pos,vec2(0.0)));
-			margin_blend = 1.0-smoothstep(0.0,margin.x,max(margin_grad.x,margin_grad.y));
+			vec2 margin_grad = mix(pos - viewport_size, -pos, lessThan(pos, vec2(0.0)));
+			margin_blend = 1.0 - smoothstep(0.0, margin.x, max(margin_grad.x, margin_grad.y));
 			//margin_blend=1.0;
-
 		}
 
 		vec2 final_pos;
 		float grad;
-		grad=steps_taken/float(num_steps);
-		float initial_fade = curve_fade_in==0.0 ? 1.0 : pow(clamp(grad,0.0,1.0),curve_fade_in);
-		float fade = pow(clamp(1.0-grad,0.0,1.0),distance_fade)*initial_fade;
-		final_pos=pos;
-
-
-
-
-
-
+		grad = steps_taken / float(num_steps);
+		float initial_fade = curve_fade_in == 0.0 ? 1.0 : pow(clamp(grad, 0.0, 1.0), curve_fade_in);
+		float fade = pow(clamp(1.0 - grad, 0.0, 1.0), distance_fade) * initial_fade;
+		final_pos = pos;
 
 #ifdef REFLECT_ROUGHNESS
 
-
 		vec4 final_color;
 		//if roughness is enabled, do screen space cone tracing
 		if (roughness > 0.001) {
 			///////////////////////////////////////////////////////////////////////////////////////
 			//use a blurred version (in consecutive mipmaps) of the screen to simulate roughness
 
-			float gloss = 1.0-roughness;
+			float gloss = 1.0 - roughness;
 			float cone_angle = roughness * M_PI * 0.5;
 			vec2 cone_dir = final_pos - line_begin;
 			float cone_len = length(cone_dir);
 			cone_dir = normalize(cone_dir); //will be used normalized from now on
 			float max_mipmap = filter_mipmap_levels - 1.0;
-			float gloss_mult=gloss;
+			float gloss_mult = gloss;
 
-			float rem_alpha=1.0;
+			float rem_alpha = 1.0;
 			final_color = vec4(0.0);
 
-			for(int i=0;i<7;i++) {
+			for (int i = 0; i < 7; i++) {
 
 				float op_len = 2.0 * tan(cone_angle) * cone_len; //opposite side of iso triangle
 				float radius;
@@ -258,30 +233,30 @@ void main() {
 				}
 
 				//find the place where screen must be sampled
-				vec2 sample_pos = ( line_begin + cone_dir * (cone_len - radius) ) * pixel_size;
+				vec2 sample_pos = (line_begin + cone_dir * (cone_len - radius)) * pixel_size;
 				//radius is in pixels, so it's natural that log2(radius) maps to the right mipmap for the amount of pixels
-				float mipmap = clamp( log2( radius ), 0.0, max_mipmap );
+				float mipmap = clamp(log2(radius), 0.0, max_mipmap);
 
 				//mipmap = max(mipmap-1.0,0.0);
 				//do sampling
 
 				vec4 sample_color;
 				{
-					sample_color = textureLod(source_diffuse,sample_pos,mipmap);
+					sample_color = textureLod(source_diffuse, sample_pos, mipmap);
 				}
 
 				//multiply by gloss
-				sample_color.rgb*=gloss_mult;
-				sample_color.a=gloss_mult;
+				sample_color.rgb *= gloss_mult;
+				sample_color.a = gloss_mult;
 
 				rem_alpha -= sample_color.a;
-				if(rem_alpha < 0.0) {
+				if (rem_alpha < 0.0) {
 					sample_color.rgb *= (1.0 - abs(rem_alpha));
 				}
 
-				final_color+=sample_color;
+				final_color += sample_color;
 
-				if (final_color.a>=0.95) {
+				if (final_color.a >= 0.95) {
 					// This code of accumulating gloss and aborting on near one
 					// makes sense when you think of cone tracing.
 					// Think of it as if roughness was 0, then we could abort on the first
@@ -290,29 +265,21 @@ void main() {
 					break;
 				}
 
-				cone_len-=radius*2.0; //go to next (smaller) circle.
-
-				gloss_mult*=gloss;
-
+				cone_len -= radius * 2.0; //go to next (smaller) circle.
 
+				gloss_mult *= gloss;
 			}
 		} else {
-			final_color = textureLod(source_diffuse,final_pos*pixel_size,0.0);
+			final_color = textureLod(source_diffuse, final_pos * pixel_size, 0.0);
 		}
 
-		frag_color = vec4(final_color.rgb,fade*margin_blend);
+		frag_color = vec4(final_color.rgb, fade * margin_blend);
 
 #else
-		frag_color = vec4(textureLod(source_diffuse,final_pos*pixel_size,0.0).rgb,fade*margin_blend);
+		frag_color = vec4(textureLod(source_diffuse, final_pos * pixel_size, 0.0).rgb, fade * margin_blend);
 #endif
 
-
-
 	} else {
-		frag_color = vec4(0.0,0.0,0.0,0.0);
+		frag_color = vec4(0.0, 0.0, 0.0, 0.0);
 	}
-
-
-
 }
-

drivers/gles2/shaders/ssao.glsl

@@ -1,12 +1,11 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
+layout(location = 0) in highp vec4 vertex_attrib;
 
 void main() {
 
 	gl_Position = vertex_attrib;
-	gl_Position.z=1.0;
+	gl_Position.z = 1.0;
 }
 
 [fragment]
@@ -43,19 +42,20 @@ void main() {
 // This is the number of turns around the circle that the spiral pattern makes.  This should be prime to prevent
 // taps from lining up.  This particular choice was tuned for NUM_SAMPLES == 9
 
-const int ROTATIONS[] = int[]( 1, 1, 2, 3, 2, 5, 2, 3, 2,
-3, 3, 5, 5, 3, 4, 7, 5, 5, 7,
-9, 8, 5, 5, 7, 7, 7, 8, 5, 8,
-11, 12, 7, 10, 13, 8, 11, 8, 7, 14,
-11, 11, 13, 12, 13, 19, 17, 13, 11, 18,
-19, 11, 11, 14, 17, 21, 15, 16, 17, 18,
-13, 17, 11, 17, 19, 18, 25, 18, 19, 19,
-29, 21, 19, 27, 31, 29, 21, 18, 17, 29,
-31, 31, 23, 18, 25, 26, 25, 23, 19, 34,
-19, 27, 21, 25, 39, 29, 17, 21, 27 );
+const int ROTATIONS[] = int[](
+		1, 1, 2, 3, 2, 5, 2, 3, 2,
+		3, 3, 5, 5, 3, 4, 7, 5, 5, 7,
+		9, 8, 5, 5, 7, 7, 7, 8, 5, 8,
+		11, 12, 7, 10, 13, 8, 11, 8, 7, 14,
+		11, 11, 13, 12, 13, 19, 17, 13, 11, 18,
+		19, 11, 11, 14, 17, 21, 15, 16, 17, 18,
+		13, 17, 11, 17, 19, 18, 25, 18, 19, 19,
+		29, 21, 19, 27, 31, 29, 21, 18, 17, 29,
+		31, 31, 23, 18, 25, 26, 25, 23, 19, 34,
+		19, 27, 21, 25, 39, 29, 17, 21, 27);
 
 //#define NUM_SPIRAL_TURNS (7)
-const int NUM_SPIRAL_TURNS = ROTATIONS[NUM_SAMPLES-1];
+const int NUM_SPIRAL_TURNS = ROTATIONS[NUM_SAMPLES - 1];
 
 uniform sampler2D source_depth; //texunit:0
 uniform highp usampler2D source_depth_mipmaps; //texunit:1
@@ -90,44 +90,41 @@ vec3 reconstructCSPosition(vec2 S, float z) {
 }
 
 vec3 getPosition(ivec2 ssP) {
-    vec3 P;
-    P.z = texelFetch(source_depth, ssP, 0).r;
+	vec3 P;
+	P.z = texelFetch(source_depth, ssP, 0).r;
 
-    P.z = P.z * 2.0 - 1.0;
+	P.z = P.z * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-    P.z = ((P.z + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+	P.z = ((P.z + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
-    P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
+	P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
 #endif
-    P.z = -P.z;
+	P.z = -P.z;
 
-    // Offset to pixel center
-    P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
-    return P;
+	// Offset to pixel center
+	P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
+	return P;
 }
 
 /** Reconstructs screen-space unit normal from screen-space position */
 vec3 reconstructCSFaceNormal(vec3 C) {
-    return normalize(cross(dFdy(C), dFdx(C)));
+	return normalize(cross(dFdy(C), dFdx(C)));
 }
 
-
-
 /** Returns a unit vector and a screen-space radius for the tap on a unit disk (the caller should scale by the actual disk radius) */
-vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR){
-    // Radius relative to ssR
-    float alpha = (float(sampleNumber) + 0.5) * (1.0 / float(NUM_SAMPLES));
-    float angle = alpha * (float(NUM_SPIRAL_TURNS) * 6.28) + spinAngle;
+vec2 tapLocation(int sampleNumber, float spinAngle, out float ssR) {
+	// Radius relative to ssR
+	float alpha = (float(sampleNumber) + 0.5) * (1.0 / float(NUM_SAMPLES));
+	float angle = alpha * (float(NUM_SPIRAL_TURNS) * 6.28) + spinAngle;
 
-    ssR = alpha;
-    return vec2(cos(angle), sin(angle));
+	ssR = alpha;
+	return vec2(cos(angle), sin(angle));
 }
 
-
 /** Read the camera-space position of the point at screen-space pixel ssP + unitOffset * ssR.  Assumes length(unitOffset) == 1 */
 vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
-    // Derivation:
-    //  mipLevel = floor(log(ssR / MAX_OFFSET));
+	// Derivation:
+	//  mipLevel = floor(log(ssR / MAX_OFFSET));
 	int mipLevel = clamp(int(floor(log2(ssR))) - LOG_MAX_OFFSET, 0, MAX_MIP_LEVEL);
 
 	ivec2 ssP = ivec2(ssR * unitOffset) + ssC;
@@ -138,13 +135,12 @@ vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
 	// Manually clamp to the texture size because texelFetch bypasses the texture unit
 	ivec2 mipP = clamp(ssP >> mipLevel, ivec2(0), (screen_size >> mipLevel) - ivec2(1));
 
-
 	if (mipLevel < 1) {
 		//read from depth buffer
 		P.z = texelFetch(source_depth, mipP, 0).r;
 		P.z = P.z * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-		P.z = ((P.z + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+		P.z = ((P.z + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 		P.z = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - P.z * (camera_z_far - camera_z_near));
 
@@ -153,78 +149,74 @@ vec3 getOffsetPosition(ivec2 ssC, vec2 unitOffset, float ssR) {
 
 	} else {
 		//read from mipmaps
-		uint d = texelFetch(source_depth_mipmaps, mipP, mipLevel-1).r;
-		P.z = -(float(d)/65535.0)*camera_z_far;
+		uint d = texelFetch(source_depth_mipmaps, mipP, mipLevel - 1).r;
+		P.z = -(float(d) / 65535.0) * camera_z_far;
 	}
 
-
 	// Offset to pixel center
 	P = reconstructCSPosition(vec2(ssP) + vec2(0.5), P.z);
 
 	return P;
 }
 
-
-
 /** Compute the occlusion due to sample with index \a i about the pixel at \a ssC that corresponds
-    to camera-space point \a C with unit normal \a n_C, using maximum screen-space sampling radius \a ssDiskRadius
+	to camera-space point \a C with unit normal \a n_C, using maximum screen-space sampling radius \a ssDiskRadius
 
-    Note that units of H() in the HPG12 paper are meters, not
-    unitless.  The whole falloff/sampling function is therefore
-    unitless.  In this implementation, we factor out (9 / radius).
+	Note that units of H() in the HPG12 paper are meters, not
+	unitless.  The whole falloff/sampling function is therefore
+	unitless.  In this implementation, we factor out (9 / radius).
 
-    Four versions of the falloff function are implemented below
+	Four versions of the falloff function are implemented below
 */
-float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius,in float p_radius, in int tapIndex, in float randomPatternRotationAngle) {
-    // Offset on the unit disk, spun for this pixel
-    float ssR;
-    vec2 unitOffset = tapLocation(tapIndex, randomPatternRotationAngle, ssR);
-    ssR *= ssDiskRadius;
+float sampleAO(in ivec2 ssC, in vec3 C, in vec3 n_C, in float ssDiskRadius, in float p_radius, in int tapIndex, in float randomPatternRotationAngle) {
+	// Offset on the unit disk, spun for this pixel
+	float ssR;
+	vec2 unitOffset = tapLocation(tapIndex, randomPatternRotationAngle, ssR);
+	ssR *= ssDiskRadius;
 
-    // The occluding point in camera space
-    vec3 Q = getOffsetPosition(ssC, unitOffset, ssR);
+	// The occluding point in camera space
+	vec3 Q = getOffsetPosition(ssC, unitOffset, ssR);
 
-    vec3 v = Q - C;
+	vec3 v = Q - C;
 
-    float vv = dot(v, v);
-    float vn = dot(v, n_C);
+	float vv = dot(v, v);
+	float vn = dot(v, n_C);
 
-    const float epsilon = 0.01;
-    float radius2 = p_radius*p_radius;
+	const float epsilon = 0.01;
+	float radius2 = p_radius * p_radius;
 
-    // A: From the HPG12 paper
-    // Note large epsilon to avoid overdarkening within cracks
-    //return float(vv < radius2) * max((vn - bias) / (epsilon + vv), 0.0) * radius2 * 0.6;
+	// A: From the HPG12 paper
+	// Note large epsilon to avoid overdarkening within cracks
+	//return float(vv < radius2) * max((vn - bias) / (epsilon + vv), 0.0) * radius2 * 0.6;
 
-    // B: Smoother transition to zero (lowers contrast, smoothing out corners). [Recommended]
-    float f=max(radius2 - vv, 0.0);
-    return f * f * f * max((vn - bias) / (epsilon + vv), 0.0);
+	// B: Smoother transition to zero (lowers contrast, smoothing out corners). [Recommended]
+	float f = max(radius2 - vv, 0.0);
+	return f * f * f * max((vn - bias) / (epsilon + vv), 0.0);
 
-    // C: Medium contrast (which looks better at high radii), no division.  Note that the
-    // contribution still falls off with radius^2, but we've adjusted the rate in a way that is
-    // more computationally efficient and happens to be aesthetically pleasing.
-    // return 4.0 * max(1.0 - vv * invRadius2, 0.0) * max(vn - bias, 0.0);
+	// C: Medium contrast (which looks better at high radii), no division.  Note that the
+	// contribution still falls off with radius^2, but we've adjusted the rate in a way that is
+	// more computationally efficient and happens to be aesthetically pleasing.
+	// return 4.0 * max(1.0 - vv * invRadius2, 0.0) * max(vn - bias, 0.0);
 
-    // D: Low contrast, no division operation
-    // return 2.0 * float(vv < radius * radius) * max(vn - bias, 0.0);
+	// D: Low contrast, no division operation
+	// return 2.0 * float(vv < radius * radius) * max(vn - bias, 0.0);
 }
 
-
-
 void main() {
 
-
 	// Pixel being shaded
 	ivec2 ssC = ivec2(gl_FragCoord.xy);
 
 	// World space point being shaded
 	vec3 C = getPosition(ssC);
 
-/*	if (C.z <= -camera_z_far*0.999) {
-	       // We're on the skybox
-	       visibility=1.0;
-	       return;
-	}*/
+	/*
+	if (C.z <= -camera_z_far*0.999) {
+		// We're on the skybox
+		visibility=1.0;
+		return;
+	}
+	*/
 
 	//visibility=-C.z/camera_z_far;
 	//return;
@@ -251,7 +243,7 @@ void main() {
 #endif
 	float sum = 0.0;
 	for (int i = 0; i < NUM_SAMPLES; ++i) {
-		sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius,i, randomPatternRotationAngle);
+		sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius, i, randomPatternRotationAngle);
 	}
 
 	float A = max(0.0, 1.0 - sum * intensity_div_r6 * (5.0 / float(NUM_SAMPLES)));
@@ -271,10 +263,10 @@ void main() {
 
 	sum = 0.0;
 	for (int i = 0; i < NUM_SAMPLES; ++i) {
-		sum += sampleAO(ssC, C, n_C, ssDiskRadius,radius2, i, randomPatternRotationAngle);
+		sum += sampleAO(ssC, C, n_C, ssDiskRadius, radius2, i, randomPatternRotationAngle);
 	}
 
-	A= min(A,max(0.0, 1.0 - sum * intensity_div_r62 * (5.0 / float(NUM_SAMPLES))));
+	A = min(A, max(0.0, 1.0 - sum * intensity_div_r62 * (5.0 / float(NUM_SAMPLES))));
 #endif
 	// Bilateral box-filter over a quad for free, respecting depth edges
 	// (the difference that this makes is subtle)
@@ -286,8 +278,4 @@ void main() {
 	}
 
 	visibility = A;
-
 }
-
-
-

drivers/gles2/shaders/ssao_blur.glsl

@@ -1,26 +1,21 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-
+layout(location = 0) in highp vec4 vertex_attrib;
 
 void main() {
 
 	gl_Position = vertex_attrib;
-	gl_Position.z=1.0;
+	gl_Position.z = 1.0;
 }
 
 [fragment]
 
-
 uniform sampler2D source_ssao; //texunit:0
 uniform sampler2D source_depth; //texunit:1
 uniform sampler2D source_normal; //texunit:3
 
-
 layout(location = 0) out float visibility;
 
-
 //////////////////////////////////////////////////////////////////////////////////////////////
 // Tunable Parameters:
 
@@ -28,32 +23,30 @@ layout(location = 0) out float visibility;
 uniform float edge_sharpness;
 
 /** Step in 2-pixel intervals since we already blurred against neighbors in the
-    first AO pass.  This constant can be increased while R decreases to improve
-    performance at the expense of some dithering artifacts.
+	first AO pass.  This constant can be increased while R decreases to improve
+	performance at the expense of some dithering artifacts.
 
-    Morgan found that a scale of 3 left a 1-pixel checkerboard grid that was
-    unobjectionable after shading was applied but eliminated most temporal incoherence
-    from using small numbers of sample taps.
-    */
+	Morgan found that a scale of 3 left a 1-pixel checkerboard grid that was
+	unobjectionable after shading was applied but eliminated most temporal incoherence
+	from using small numbers of sample taps.
+	*/
 
 uniform int filter_scale;
 
 /** Filter radius in pixels. This will be multiplied by SCALE. */
-#define R                   (4)
-
+#define R (4)
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
-
 // Gaussian coefficients
 const float gaussian[R + 1] =
-//    float[](0.356642, 0.239400, 0.072410, 0.009869);
-//    float[](0.398943, 0.241971, 0.053991, 0.004432, 0.000134);  // stddev = 1.0
-    float[](0.153170, 0.144893, 0.122649, 0.092902, 0.062970);  // stddev = 2.0
-//      float[](0.111220, 0.107798, 0.098151, 0.083953, 0.067458, 0.050920, 0.036108); // stddev = 3.0
+		//float[](0.356642, 0.239400, 0.072410, 0.009869);
+		//float[](0.398943, 0.241971, 0.053991, 0.004432, 0.000134);  // stddev = 1.0
+		float[](0.153170, 0.144893, 0.122649, 0.092902, 0.062970); // stddev = 2.0
+		//float[](0.111220, 0.107798, 0.098151, 0.083953, 0.067458, 0.050920, 0.036108); // stddev = 3.0
 
 /** (1, 0) or (0, 1)*/
-uniform ivec2       axis;
+uniform ivec2 axis;
 
 uniform float camera_z_far;
 uniform float camera_z_near;
@@ -72,11 +65,11 @@ void main() {
 
 	float depth_divide = 1.0 / camera_z_far;
 
-//	depth*=depth_divide;
+	//depth *= depth_divide;
 
 	/*
-	if (depth > camera_z_far*0.999) {
-		discard;//skybox
+	if (depth > camera_z_far * 0.999) {
+		discard; //skybox
 	}
 	*/
 
@@ -96,23 +89,21 @@ void main() {
 		if (r != 0) {
 
 			ivec2 ppos = ssC + axis * (r * filter_scale);
-			float value = texelFetch(source_ssao, clamp(ppos,ivec2(0),clamp_limit), 0).r;
-			ivec2 rpos = clamp(ppos,ivec2(0),clamp_limit);
+			float value = texelFetch(source_ssao, clamp(ppos, ivec2(0), clamp_limit), 0).r;
+			ivec2 rpos = clamp(ppos, ivec2(0), clamp_limit);
 			float temp_depth = texelFetch(source_depth, rpos, 0).r;
 			//vec3 temp_normal = texelFetch(source_normal, rpos, 0).rgb * 2.0 - 1.0;
 
 			temp_depth = temp_depth * 2.0 - 1.0;
 			temp_depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - temp_depth * (camera_z_far - camera_z_near));
-//			temp_depth *= depth_divide;
+			//			temp_depth *= depth_divide;
 
 			// spatial domain: offset gaussian tap
 			float weight = 0.3 + gaussian[abs(r)];
 			//weight *= max(0.0,dot(temp_normal,normal));
 
 			// range domain (the "bilateral" weight). As depth difference increases, decrease weight.
-			weight *= max(0.0, 1.0
-				      - edge_sharpness * abs(temp_depth - depth)
-				      );
+			weight *= max(0.0, 1.0 - edge_sharpness * abs(temp_depth - depth));
 
 			sum += value * weight;
 			totalWeight += weight;

drivers/gles2/shaders/ssao_minify.glsl

@@ -1,7 +1,6 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
+layout(location = 0) in highp vec4 vertex_attrib;
 
 void main() {
 
@@ -10,7 +9,6 @@ void main() {
 
 [fragment]
 
-
 #ifdef MINIFY_START
 
 #define SDEPTH_TYPE highp sampler2D
@@ -32,28 +30,23 @@ layout(location = 0) out mediump uint depth;
 
 void main() {
 
-
 	ivec2 ssP = ivec2(gl_FragCoord.xy);
 
-	  // Rotated grid subsampling to avoid XY directional bias or Z precision bias while downsampling.
-	  // On DX9, the bit-and can be implemented with floating-point modulo
+	// Rotated grid subsampling to avoid XY directional bias or Z precision bias while downsampling.
+	// On DX9, the bit-and can be implemented with floating-point modulo
 
 #ifdef MINIFY_START
 	float fdepth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
 	fdepth = fdepth * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-	fdepth = ((fdepth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+	fdepth = ((fdepth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 	fdepth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - fdepth * (camera_z_far - camera_z_near));
 #endif
 	fdepth /= camera_z_far;
-	depth = uint(clamp(fdepth*65535.0,0.0,65535.0));
+	depth = uint(clamp(fdepth * 65535.0, 0.0, 65535.0));
 
 #else
 	depth = texelFetch(source_depth, clamp(ssP * 2 + ivec2(ssP.y & 1, ssP.x & 1), ivec2(0), from_size - ivec2(1)), source_mipmap).r;
 #endif
-
-
 }
-
-

drivers/gles2/shaders/stdlib.glsl

@@ -1,6 +1,5 @@
 
-vec2 select2(vec2 a, vec2 b, bvec2 c)
-{
+vec2 select2(vec2 a, vec2 b, bvec2 c) {
 	vec2 ret;
 
 	ret.x = c.x ? b.x : a.x;
@@ -9,8 +8,7 @@ vec2 select2(vec2 a, vec2 b, bvec2 c)
 	return ret;
 }
 
-vec3 select3(vec3 a, vec3 b, bvec3 c)
-{
+vec3 select3(vec3 a, vec3 b, bvec3 c) {
 	vec3 ret;
 
 	ret.x = c.x ? b.x : a.x;
@@ -20,8 +18,7 @@ vec3 select3(vec3 a, vec3 b, bvec3 c)
 	return ret;
 }
 
-vec4 select4(vec4 a, vec4 b, bvec4 c)
-{
+vec4 select4(vec4 a, vec4 b, bvec4 c) {
 	vec4 ret;
 
 	ret.x = c.x ? b.x : a.x;
@@ -32,9 +29,7 @@ vec4 select4(vec4 a, vec4 b, bvec4 c)
 	return ret;
 }
 
-
-highp vec4 texel2DFetch(highp sampler2D tex, ivec2 size, ivec2 coord)
-{
+highp vec4 texel2DFetch(highp sampler2D tex, ivec2 size, ivec2 coord) {
 	float x_coord = float(2 * coord.x + 1) / float(size.x * 2);
 	float y_coord = float(2 * coord.y + 1) / float(size.y * 2);
 

drivers/gles2/shaders/subsurf_scattering.glsl

@@ -1,12 +1,10 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-layout(location=4) in vec2 uv_in;
+layout(location = 0) in highp vec4 vertex_attrib;
+layout(location = 4) in vec2 uv_in;
 
 out vec2 uv_interp;
 
-
 void main() {
 
 	uv_interp = uv_in;
@@ -19,87 +17,73 @@ void main() {
 #define QUALIFIER const
 
 #ifdef USE_25_SAMPLES
-
-const int kernel_size=25;
-QUALIFIER vec2 kernel[25] = vec2[] (
-    vec2(0.530605, 0.0),
-    vec2(0.000973794, -3.0),
-    vec2(0.00333804, -2.52083),
-    vec2(0.00500364, -2.08333),
-    vec2(0.00700976,  -1.6875),
-    vec2(0.0094389, -1.33333),
-    vec2(0.0128496,  -1.02083),
-    vec2(0.017924,  -0.75),
-    vec2(0.0263642,  -0.520833),
-    vec2(0.0410172, -0.333333),
-    vec2(0.0493588, -0.1875),
-    vec2(0.0402784, -0.0833333),
-    vec2(0.0211412,  -0.0208333),
-    vec2(0.0211412,  0.0208333),
-    vec2(0.0402784,  0.0833333),
-    vec2(0.0493588,  0.1875),
-    vec2(0.0410172,  0.333333),
-    vec2(0.0263642,  0.520833),
-    vec2(0.017924,  0.75),
-    vec2(0.0128496, 1.02083),
-    vec2(0.0094389,  1.33333),
-    vec2(0.00700976,  1.6875),
-    vec2(0.00500364,  2.08333),
-    vec2(0.00333804,  2.52083),
-    vec2(0.000973794,  3.0)
-);
-
+const int kernel_size = 25;
+QUALIFIER vec2 kernel[25] = vec2[](
+		vec2(0.530605, 0.0),
+		vec2(0.000973794, -3.0),
+		vec2(0.00333804, -2.52083),
+		vec2(0.00500364, -2.08333),
+		vec2(0.00700976, -1.6875),
+		vec2(0.0094389, -1.33333),
+		vec2(0.0128496, -1.02083),
+		vec2(0.017924, -0.75),
+		vec2(0.0263642, -0.520833),
+		vec2(0.0410172, -0.333333),
+		vec2(0.0493588, -0.1875),
+		vec2(0.0402784, -0.0833333),
+		vec2(0.0211412, -0.0208333),
+		vec2(0.0211412, 0.0208333),
+		vec2(0.0402784, 0.0833333),
+		vec2(0.0493588, 0.1875),
+		vec2(0.0410172, 0.333333),
+		vec2(0.0263642, 0.520833),
+		vec2(0.017924, 0.75),
+		vec2(0.0128496, 1.02083),
+		vec2(0.0094389, 1.33333),
+		vec2(0.00700976, 1.6875),
+		vec2(0.00500364, 2.08333),
+		vec2(0.00333804, 2.52083),
+		vec2(0.000973794, 3.0));
 #endif //USE_25_SAMPLES
 
 #ifdef USE_17_SAMPLES
-
-const int kernel_size=17;
-
+const int kernel_size = 17;
 QUALIFIER vec2 kernel[17] = vec2[](
-    vec2(0.536343,  0.0),
-    vec2(0.00317394,  -2.0),
-    vec2(0.0100386, -1.53125),
-    vec2(0.0144609, -1.125),
-    vec2(0.0216301,  -0.78125),
-    vec2(0.0347317, -0.5),
-    vec2(0.0571056,  -0.28125),
-    vec2(0.0582416,  -0.125),
-    vec2(0.0324462, -0.03125),
-    vec2(0.0324462, 0.03125),
-    vec2(0.0582416, 0.125),
-    vec2(0.0571056,  0.28125),
-    vec2(0.0347317, 0.5),
-    vec2(0.0216301, 0.78125),
-    vec2(0.0144609,  1.125),
-    vec2(0.0100386,  1.53125),
-    vec2(0.00317394,2.0)
-);
-
+		vec2(0.536343, 0.0),
+		vec2(0.00317394, -2.0),
+		vec2(0.0100386, -1.53125),
+		vec2(0.0144609, -1.125),
+		vec2(0.0216301, -0.78125),
+		vec2(0.0347317, -0.5),
+		vec2(0.0571056, -0.28125),
+		vec2(0.0582416, -0.125),
+		vec2(0.0324462, -0.03125),
+		vec2(0.0324462, 0.03125),
+		vec2(0.0582416, 0.125),
+		vec2(0.0571056, 0.28125),
+		vec2(0.0347317, 0.5),
+		vec2(0.0216301, 0.78125),
+		vec2(0.0144609, 1.125),
+		vec2(0.0100386, 1.53125),
+		vec2(0.00317394, 2.0));
 #endif //USE_17_SAMPLES
 
-
 #ifdef USE_11_SAMPLES
-
-const int kernel_size=11;
-
+const int kernel_size = 11;
 QUALIFIER vec2 kernel[11] = vec2[](
-    vec2(0.560479,  0.0),
-    vec2(0.00471691,  -2.0),
-    vec2(0.0192831, -1.28),
-    vec2(0.03639, -0.72),
-    vec2(0.0821904,  -0.32),
-    vec2(0.0771802, -0.08),
-    vec2(0.0771802,  0.08),
-    vec2(0.0821904, 0.32),
-    vec2(0.03639, 0.72),
-    vec2(0.0192831, 1.28),
-    vec2(0.00471691,2.0)
-);
-
+		vec2(0.560479, 0.0),
+		vec2(0.00471691, -2.0),
+		vec2(0.0192831, -1.28),
+		vec2(0.03639, -0.72),
+		vec2(0.0821904, -0.32),
+		vec2(0.0771802, -0.08),
+		vec2(0.0771802, 0.08),
+		vec2(0.0821904, 0.32),
+		vec2(0.03639, 0.72),
+		vec2(0.0192831, 1.28),
+		vec2(0.00471691, 2.0));
 #endif //USE_11_SAMPLES
 
-
-
 uniform float max_radius;
 uniform float camera_z_far;
 uniform float camera_z_near;
@@ -115,28 +99,24 @@ layout(location = 0) out vec4 frag_color;
 
 void main() {
 
-	float strength = texture(source_sss,uv_interp).r;
-	strength*=strength; //stored as sqrt
+	float strength = texture(source_sss, uv_interp).r;
+	strength *= strength; //stored as sqrt
 
 	// Fetch color of current pixel:
 	vec4 base_color = texture(source_diffuse, uv_interp);
 
-
-	if (strength>0.0) {
-
+	if (strength > 0.0) {
 
 		// Fetch linear depth of current pixel:
 		float depth = texture(source_depth, uv_interp).r * 2.0 - 1.0;
 #ifdef USE_ORTHOGONAL_PROJECTION
-		depth = ((depth + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+		depth = ((depth + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 		float scale = unit_size; //remember depth is negative by default in OpenGL
 #else
 		depth = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth * (camera_z_far - camera_z_near));
 		float scale = unit_size / depth; //remember depth is negative by default in OpenGL
 #endif
 
-
-
 		// Calculate the final step to fetch the surrounding pixels:
 		vec2 step = max_radius * scale * dir;
 		step *= strength; // Modulate it using the alpha channel.
@@ -157,35 +137,33 @@ void main() {
 
 #ifdef ENABLE_FOLLOW_SURFACE
 			// If the difference in depth is huge, we lerp color back to "colorM":
-			float depth_cmp = texture(source_depth, offset).r *2.0 - 1.0;
+			float depth_cmp = texture(source_depth, offset).r * 2.0 - 1.0;
 
 #ifdef USE_ORTHOGONAL_PROJECTION
-			depth_cmp = ((depth_cmp + (camera_z_far + camera_z_near)/(camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near))/2.0;
+			depth_cmp = ((depth_cmp + (camera_z_far + camera_z_near) / (camera_z_far - camera_z_near)) * (camera_z_far - camera_z_near)) / 2.0;
 #else
 			depth_cmp = 2.0 * camera_z_near * camera_z_far / (camera_z_far + camera_z_near - depth_cmp * (camera_z_far - camera_z_near));
 #endif
 
-			float s = clamp(300.0f * scale *
-					       max_radius * abs(depth - depth_cmp),0.0,1.0);
+			float s = clamp(300.0f * scale * max_radius * abs(depth - depth_cmp), 0.0, 1.0);
 			color = mix(color, base_color.rgb, s);
 #endif
 
 			// Accumulate:
-			color*=kernel[i].x;
+			color *= kernel[i].x;
 
 #ifdef ENABLE_STRENGTH_WEIGHTING
 			float color_s = texture(source_sss, offset).r;
-			color_weight+=color_s * kernel[i].x;
-			color*=color_s;
+			color_weight += color_s * kernel[i].x;
+			color *= color_s;
 #endif
 			color_accum += color;
-
 		}
 
 #ifdef ENABLE_STRENGTH_WEIGHTING
-		color_accum/=color_weight;
+		color_accum /= color_weight;
 #endif
-		frag_color = vec4(color_accum,base_color.a); //keep alpha (used for SSAO)
+		frag_color = vec4(color_accum, base_color.a); //keep alpha (used for SSAO)
 	} else {
 		frag_color = base_color;
 	}

drivers/gles2/shaders/tonemap.glsl

@@ -1,8 +1,7 @@
 [vertex]
 
-
-layout(location=0) in highp vec4 vertex_attrib;
-layout(location=4) in vec2 uv_in;
+layout(location = 0) in highp vec4 vertex_attrib;
+layout(location = 4) in vec2 uv_in;
 
 out vec2 uv_interp;
 
@@ -11,9 +10,8 @@ void main() {
 	gl_Position = vertex_attrib;
 	uv_interp = uv_in;
 #ifdef V_FLIP
-	uv_interp.y = 1.0-uv_interp.y;
+	uv_interp.y = 1.0 - uv_interp.y;
 #endif
-
 }
 
 [fragment]
@@ -22,7 +20,6 @@ void main() {
 precision mediump float;
 #endif
 
-
 in vec2 uv_interp;
 
 uniform highp sampler2D source; //texunit:0
@@ -56,64 +53,54 @@ uniform sampler2D color_correction; //texunit:3
 
 #endif
 
-
 layout(location = 0) out vec4 frag_color;
 
 #ifdef USE_GLOW_FILTER_BICUBIC
 
 // w0, w1, w2, and w3 are the four cubic B-spline basis functions
-float w0(float a)
-{
-    return (1.0/6.0)*(a*(a*(-a + 3.0) - 3.0) + 1.0);
+float w0(float a) {
+	return (1.0 / 6.0) * (a * (a * (-a + 3.0) - 3.0) + 1.0);
 }
 
-float w1(float a)
-{
-    return (1.0/6.0)*(a*a*(3.0*a - 6.0) + 4.0);
+float w1(float a) {
+	return (1.0 / 6.0) * (a * a * (3.0 * a - 6.0) + 4.0);
 }
 
-float w2(float a)
-{
-    return (1.0/6.0)*(a*(a*(-3.0*a + 3.0) + 3.0) + 1.0);
+float w2(float a) {
+	return (1.0 / 6.0) * (a * (a * (-3.0 * a + 3.0) + 3.0) + 1.0);
 }
 
-float w3(float a)
-{
-    return (1.0/6.0)*(a*a*a);
+float w3(float a) {
+	return (1.0 / 6.0) * (a * a * a);
 }
 
 // g0 and g1 are the two amplitude functions
-float g0(float a)
-{
-    return w0(a) + w1(a);
+float g0(float a) {
+	return w0(a) + w1(a);
 }
 
-float g1(float a)
-{
-    return w2(a) + w3(a);
+float g1(float a) {
+	return w2(a) + w3(a);
 }
 
 // h0 and h1 are the two offset functions
-float h0(float a)
-{
-    return -1.0 + w1(a) / (w0(a) + w1(a));
+float h0(float a) {
+	return -1.0 + w1(a) / (w0(a) + w1(a));
 }
 
-float h1(float a)
-{
-    return 1.0 + w3(a) / (w2(a) + w3(a));
+float h1(float a) {
+	return 1.0 + w3(a) / (w2(a) + w3(a));
 }
 
 uniform ivec2 glow_texture_size;
 
-vec4 texture2D_bicubic(sampler2D tex, vec2 uv,int p_lod)
-{
-	float lod=float(p_lod);
+vec4 texture2D_bicubic(sampler2D tex, vec2 uv, int p_lod) {
+	float lod = float(p_lod);
 	vec2 tex_size = vec2(glow_texture_size >> p_lod);
-	vec2 pixel_size =1.0/tex_size;
-	uv = uv*tex_size + 0.5;
-	vec2 iuv = floor( uv );
-	vec2 fuv = fract( uv );
+	vec2 pixel_size = 1.0 / tex_size;
+	uv = uv * tex_size + 0.5;
+	vec2 iuv = floor(uv);
+	vec2 fuv = fract(uv);
 
 	float g0x = g0(fuv.x);
 	float g1x = g1(fuv.x);
@@ -127,24 +114,19 @@ vec4 texture2D_bicubic(sampler2D tex, vec2 uv,int p_lod)
 	vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - 0.5) * pixel_size;
 	vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - 0.5) * pixel_size;
 
-	return g0(fuv.y) * (g0x * textureLod(tex, p0,lod)  +
-			    g1x * textureLod(tex, p1,lod)) +
-			g1(fuv.y) * (g0x * textureLod(tex, p2,lod)  +
-				     g1x * textureLod(tex, p3,lod));
+	return (g0(fuv.y) * (g0x * textureLod(tex, p0, lod) + g1x * textureLod(tex, p1, lod))) +
+			(g1(fuv.y) * (g0x * textureLod(tex, p2, lod) + g1x * textureLod(tex, p3, lod)));
 }
 
-
-
-#define GLOW_TEXTURE_SAMPLE(m_tex,m_uv,m_lod) texture2D_bicubic(m_tex,m_uv,m_lod)
+#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) texture2D_bicubic(m_tex, m_uv, m_lod)
 
 #else
 
-#define GLOW_TEXTURE_SAMPLE(m_tex,m_uv,m_lod) textureLod(m_tex,m_uv,float(m_lod))
+#define GLOW_TEXTURE_SAMPLE(m_tex, m_uv, m_lod) textureLod(m_tex, m_uv, float(m_lod))
 
 #endif
 
-
-vec3 tonemap_filmic(vec3 color,float white) {
+vec3 tonemap_filmic(vec3 color, float white) {
 
 	float A = 0.15;
 	float B = 0.50;
@@ -154,11 +136,10 @@ vec3 tonemap_filmic(vec3 color,float white) {
 	float F = 0.30;
 	float W = 11.2;
 
-	vec3 coltn = ((color*(A*color+C*B)+D*E)/(color*(A*color+B)+D*F))-E/F;
-	float whitetn = ((white*(A*white+C*B)+D*E)/(white*(A*white+B)+D*F))-E/F;
-
-	return coltn/whitetn;
+	vec3 coltn = ((color * (A * color + C * B) + D * E) / (color * (A * color + B) + D * F)) - E / F;
+	float whitetn = ((white * (A * white + C * B) + D * E) / (white * (A * white + B) + D * F)) - E / F;
 
+	return coltn / whitetn;
 }
 
 vec3 tonemap_aces(vec3 color) {
@@ -167,12 +148,12 @@ vec3 tonemap_aces(vec3 color) {
 	float c = 2.43f;
 	float d = 0.59f;
 	float e = 0.14f;
-	return color = clamp((color*(a*color+b))/(color*(c*color+d)+e),vec3(0.0),vec3(1.0));
+	return color = clamp((color * (a * color + b)) / (color * (c * color + d) + e), vec3(0.0), vec3(1.0));
 }
 
-vec3 tonemap_reindhart(vec3 color,float white) {
+vec3 tonemap_reindhart(vec3 color, float white) {
 
-	return ( color * ( 1.0 + ( color / ( white) ) ) ) / ( 1.0 + color );
+	return (color * (1.0 + (color / (white)))) / (1.0 + color);
 }
 
 void main() {
@@ -181,10 +162,10 @@ void main() {
 
 #ifdef USE_AUTO_EXPOSURE
 
-	color/=texelFetch(source_auto_exposure,ivec2(0,0),0).r/auto_exposure_grey;
+	color /= texelFetch(source_auto_exposure, ivec2(0, 0), 0).r / auto_exposure_grey;
 #endif
 
-	color*=exposure;
+	color *= exposure;
 
 #if defined(USE_GLOW_LEVEL1) || defined(USE_GLOW_LEVEL2) || defined(USE_GLOW_LEVEL3) || defined(USE_GLOW_LEVEL4) || defined(USE_GLOW_LEVEL5) || defined(USE_GLOW_LEVEL6) || defined(USE_GLOW_LEVEL7)
 #define USING_GLOW
@@ -195,56 +176,54 @@ void main() {
 
 #ifdef USE_GLOW_LEVEL1
 
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,1).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 1).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL2
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,2).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 2).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL3
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,3).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 3).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL4
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,4).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 4).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL5
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,5).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 5).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL6
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,6).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 6).rgb;
 #endif
 
 #ifdef USE_GLOW_LEVEL7
-	glow+=GLOW_TEXTURE_SAMPLE(source_glow,uv_interp,7).rgb;
+	glow += GLOW_TEXTURE_SAMPLE(source_glow, uv_interp, 7).rgb;
 #endif
 
-
 	glow *= glow_intensity;
 
 #endif
 
-
 #ifdef USE_REINDHART_TONEMAPPER
 
-	color.rgb = tonemap_reindhart(color.rgb,white);
+	color.rgb = tonemap_reindhart(color.rgb, white);
 
-# if defined(USING_GLOW)
-	glow = tonemap_reindhart(glow,white);
-# endif
+#if defined(USING_GLOW)
+	glow = tonemap_reindhart(glow, white);
+#endif
 
 #endif
 
 #ifdef USE_FILMIC_TONEMAPPER
 
-	color.rgb = tonemap_filmic(color.rgb,white);
+	color.rgb = tonemap_filmic(color.rgb, white);
 
-# if defined(USING_GLOW)
-	glow = tonemap_filmic(glow,white);
-# endif
+#if defined(USING_GLOW)
+	glow = tonemap_filmic(glow, white);
+#endif
 
 #endif
 
@@ -252,26 +231,26 @@ void main() {
 
 	color.rgb = tonemap_aces(color.rgb);
 
-# if defined(USING_GLOW)
+#if defined(USING_GLOW)
 	glow = tonemap_aces(glow);
-# endif
+#endif
 
 #endif
 
 	//regular Linear -> SRGB conversion
 	vec3 a = vec3(0.055);
-	color.rgb = mix( (vec3(1.0)+a)*pow(color.rgb,vec3(1.0/2.4))-a , 12.92*color.rgb , lessThan(color.rgb,vec3(0.0031308)));
+	color.rgb = mix((vec3(1.0) + a) * pow(color.rgb, vec3(1.0 / 2.4)) - a, 12.92 * color.rgb, lessThan(color.rgb, vec3(0.0031308)));
 
 #if defined(USING_GLOW)
-	glow = mix( (vec3(1.0)+a)*pow(glow,vec3(1.0/2.4))-a , 12.92*glow , lessThan(glow,vec3(0.0031308)));
+	glow = mix((vec3(1.0) + a) * pow(glow, vec3(1.0 / 2.4)) - a, 12.92 * glow, lessThan(glow, vec3(0.0031308)));
 #endif
 
-//glow needs to be added in SRGB space (together with image space effects)
+	//glow needs to be added in SRGB space (together with image space effects)
 
-	color.rgb = clamp(color.rgb,0.0,1.0);
+	color.rgb = clamp(color.rgb, 0.0, 1.0);
 
 #if defined(USING_GLOW)
-	glow = clamp(glow,0.0,1.0);
+	glow = clamp(glow, 0.0, 1.0);
 #endif
 
 #ifdef USE_GLOW_REPLACE
@@ -291,33 +270,32 @@ void main() {
 	{
 
 		glow = (glow * 0.5) + 0.5;
-		color.r =  (glow.r <= 0.5) ? (color.r - (1.0 - 2.0 * glow.r) * color.r * (1.0 - color.r)) : (((glow.r > 0.5) && (color.r <= 0.25)) ? (color.r + (2.0 * glow.r - 1.0) * (4.0 * color.r * (4.0 * color.r + 1.0) * (color.r - 1.0) + 7.0 * color.r)) : (color.r + (2.0 * glow.r - 1.0) * (sqrt(color.r) - color.r)));
-		color.g =  (glow.g <= 0.5) ? (color.g - (1.0 - 2.0 * glow.g) * color.g * (1.0 - color.g)) : (((glow.g > 0.5) && (color.g <= 0.25)) ? (color.g + (2.0 * glow.g - 1.0) * (4.0 * color.g * (4.0 * color.g + 1.0) * (color.g - 1.0) + 7.0 * color.g)) : (color.g + (2.0 * glow.g - 1.0) * (sqrt(color.g) - color.g)));
-		color.b =  (glow.b <= 0.5) ? (color.b - (1.0 - 2.0 * glow.b) * color.b * (1.0 - color.b)) : (((glow.b > 0.5) && (color.b <= 0.25)) ? (color.b + (2.0 * glow.b - 1.0) * (4.0 * color.b * (4.0 * color.b + 1.0) * (color.b - 1.0) + 7.0 * color.b)) : (color.b + (2.0 * glow.b - 1.0) * (sqrt(color.b) - color.b)));
+		color.r = (glow.r <= 0.5) ? (color.r - (1.0 - 2.0 * glow.r) * color.r * (1.0 - color.r)) : (((glow.r > 0.5) && (color.r <= 0.25)) ? (color.r + (2.0 * glow.r - 1.0) * (4.0 * color.r * (4.0 * color.r + 1.0) * (color.r - 1.0) + 7.0 * color.r)) : (color.r + (2.0 * glow.r - 1.0) * (sqrt(color.r) - color.r)));
+		color.g = (glow.g <= 0.5) ? (color.g - (1.0 - 2.0 * glow.g) * color.g * (1.0 - color.g)) : (((glow.g > 0.5) && (color.g <= 0.25)) ? (color.g + (2.0 * glow.g - 1.0) * (4.0 * color.g * (4.0 * color.g + 1.0) * (color.g - 1.0) + 7.0 * color.g)) : (color.g + (2.0 * glow.g - 1.0) * (sqrt(color.g) - color.g)));
+		color.b = (glow.b <= 0.5) ? (color.b - (1.0 - 2.0 * glow.b) * color.b * (1.0 - color.b)) : (((glow.b > 0.5) && (color.b <= 0.25)) ? (color.b + (2.0 * glow.b - 1.0) * (4.0 * color.b * (4.0 * color.b + 1.0) * (color.b - 1.0) + 7.0 * color.b)) : (color.b + (2.0 * glow.b - 1.0) * (sqrt(color.b) - color.b)));
 	}
 
 #endif
 
 #if defined(USING_GLOW) && !defined(USE_GLOW_SCREEN) && !defined(USE_GLOW_SOFTLIGHT) && !defined(USE_GLOW_REPLACE)
 	//additive
-	color.rgb+=glow;
+	color.rgb += glow;
 #endif
 
 #ifdef USE_BCS
 
-	color.rgb = mix(vec3(0.0),color.rgb,bcs.x);
-	color.rgb = mix(vec3(0.5),color.rgb,bcs.y);
-	color.rgb = mix(vec3(dot(vec3(1.0),color.rgb)*0.33333),color.rgb,bcs.z);
+	color.rgb = mix(vec3(0.0), color.rgb, bcs.x);
+	color.rgb = mix(vec3(0.5), color.rgb, bcs.y);
+	color.rgb = mix(vec3(dot(vec3(1.0), color.rgb) * 0.33333), color.rgb, bcs.z);
 
 #endif
 
 #ifdef USE_COLOR_CORRECTION
 
-	color.r = texture(color_correction,vec2(color.r,0.0)).r;
-	color.g = texture(color_correction,vec2(color.g,0.0)).g;
-	color.b = texture(color_correction,vec2(color.b,0.0)).b;
+	color.r = texture(color_correction, vec2(color.r, 0.0)).r;
+	color.g = texture(color_correction, vec2(color.g, 0.0)).g;
+	color.b = texture(color_correction, vec2(color.b, 0.0)).b;
 #endif
 
-
-	frag_color=vec4(color.rgb,1.0);
+	frag_color = vec4(color.rgb, 1.0);
 }