last conversions

examples/js/shaders/SobelOperatorShader.js

@@ -22,9 +22,9 @@ THREE.SobelOperatorShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
+		"	vUv = uv;",
 
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -38,50 +38,50 @@ THREE.SobelOperatorShader = {
 
 		"void main() {",
 
-			"vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );",
+		"	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );",
 
 			// kernel definition (in glsl matrices are filled in column-major order)
 
-			"const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );", // x direction kernel
-			"const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );", // y direction kernel
+		"	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );", // x direction kernel
+		"	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );", // y direction kernel
 
 			// fetch the 3x3 neighbourhood of a fragment
 
 			// first column
 
-			"float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;",
-			"float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;",
-			"float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;",
+		"	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;",
+		"	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;",
+		"	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;",
 
 			// second column
 
-			"float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;",
-			"float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;",
-			"float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;",
+		"	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;",
+		"	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;",
+		"	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;",
 
 			// third column
 
-			"float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;",
-			"float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;",
-			"float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;",
+		"	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;",
+		"	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;",
+		"	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;",
 
 			// gradient value in x direction
 
-			"float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ",
-				"Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ",
-				"Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ",
+		"	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ",
+		"		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ",
+		"		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ",
 
 			// gradient value in y direction
 
-			"float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ",
-				"Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ",
-				"Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ",
+		"	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ",
+		"		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ",
+		"		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ",
 
 			// magnitute of the total gradient
 
-			"float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );",
+		"	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );",
 
-			"gl_FragColor = vec4( vec3( G ), 1 );",
+		"	gl_FragColor = vec4( vec3( G ), 1 );",
 
 		"}"
 

examples/js/shaders/TechnicolorShader.js

@@ -21,8 +21,8 @@ THREE.TechnicolorShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -35,10 +35,10 @@ THREE.TechnicolorShader = {
 
 		"void main() {",
 
-			"vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );",
-			"vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);",
+		"	vec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );",
+		"	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);",
 
-			"gl_FragColor = newTex;",
+		"	gl_FragColor = newTex;",
 
 		"}"
 

examples/js/shaders/TerrainShader.js

@@ -90,151 +90,151 @@ THREE.TerrainShader = {
 		THREE.ShaderChunk[ "fog_pars_fragment" ],
 
 		"float calcLightAttenuation( float lightDistance, float cutoffDistance, float decayExponent ) {",
-				"if ( decayExponent > 0.0 ) {",
-					"return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );",
-				"}",
-				"return 1.0;",
-			"}",
+		"		if ( decayExponent > 0.0 ) {",
+		"			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );",
+		"		}",
+		"		return 1.0;",
+		"	}",
 
 		"void main() {",
 
-			"vec3 outgoingLight = vec3( 0.0 );",	// outgoing light does not have an alpha, the surface does
-			"vec4 diffuseColor = vec4( diffuse, opacity );",
+		"	vec3 outgoingLight = vec3( 0.0 );",	// outgoing light does not have an alpha, the surface does
+		"	vec4 diffuseColor = vec4( diffuse, opacity );",
 
-			"vec3 specularTex = vec3( 1.0 );",
+		"	vec3 specularTex = vec3( 1.0 );",
 
-			"vec2 uvOverlay = uRepeatOverlay * vUv + uOffset;",
-			"vec2 uvBase = uRepeatBase * vUv;",
+		"	vec2 uvOverlay = uRepeatOverlay * vUv + uOffset;",
+		"	vec2 uvBase = uRepeatBase * vUv;",
 
-			"vec3 normalTex = texture2D( tDetail, uvOverlay ).xyz * 2.0 - 1.0;",
-			"normalTex.xy *= uNormalScale;",
-			"normalTex = normalize( normalTex );",
+		"	vec3 normalTex = texture2D( tDetail, uvOverlay ).xyz * 2.0 - 1.0;",
+		"	normalTex.xy *= uNormalScale;",
+		"	normalTex = normalize( normalTex );",
 
-			"if( enableDiffuse1 && enableDiffuse2 ) {",
+		"	if( enableDiffuse1 && enableDiffuse2 ) {",
 
-				"vec4 colDiffuse1 = texture2D( tDiffuse1, uvOverlay );",
-				"vec4 colDiffuse2 = texture2D( tDiffuse2, uvOverlay );",
+		"		vec4 colDiffuse1 = texture2D( tDiffuse1, uvOverlay );",
+		"		vec4 colDiffuse2 = texture2D( tDiffuse2, uvOverlay );",
 
-				"colDiffuse1 = GammaToLinear( colDiffuse1, float( GAMMA_FACTOR ) );",
-				"colDiffuse2 = GammaToLinear( colDiffuse2, float( GAMMA_FACTOR ) );",
+		"		colDiffuse1 = GammaToLinear( colDiffuse1, float( GAMMA_FACTOR ) );",
+		"		colDiffuse2 = GammaToLinear( colDiffuse2, float( GAMMA_FACTOR ) );",
 
-				"diffuseColor *= mix ( colDiffuse1, colDiffuse2, 1.0 - texture2D( tDisplacement, uvBase ) );",
+		"		diffuseColor *= mix ( colDiffuse1, colDiffuse2, 1.0 - texture2D( tDisplacement, uvBase ) );",
 
-			" } else if( enableDiffuse1 ) {",
+		"	 } else if( enableDiffuse1 ) {",
 
-				"diffuseColor *= texture2D( tDiffuse1, uvOverlay );",
+		"		diffuseColor *= texture2D( tDiffuse1, uvOverlay );",
 
-			"} else if( enableDiffuse2 ) {",
+		"	} else if( enableDiffuse2 ) {",
 
-				"diffuseColor *= texture2D( tDiffuse2, uvOverlay );",
+		"		diffuseColor *= texture2D( tDiffuse2, uvOverlay );",
 
-			"}",
+		"	}",
 
-			"if( enableSpecular )",
-				"specularTex = texture2D( tSpecular, uvOverlay ).xyz;",
+		"	if( enableSpecular )",
+		"		specularTex = texture2D( tSpecular, uvOverlay ).xyz;",
 
-			"mat3 tsb = mat3( vTangent, vBinormal, vNormal );",
-			"vec3 finalNormal = tsb * normalTex;",
+		"	mat3 tsb = mat3( vTangent, vBinormal, vNormal );",
+		"	vec3 finalNormal = tsb * normalTex;",
 
-			"vec3 normal = normalize( finalNormal );",
-			"vec3 viewPosition = normalize( vViewPosition );",
+		"	vec3 normal = normalize( finalNormal );",
+		"	vec3 viewPosition = normalize( vViewPosition );",
 
-			"vec3 totalDiffuseLight = vec3( 0.0 );",
-			"vec3 totalSpecularLight = vec3( 0.0 );",
+		"	vec3 totalDiffuseLight = vec3( 0.0 );",
+		"	vec3 totalSpecularLight = vec3( 0.0 );",
 
 			// point lights
 
-			"#if NUM_POINT_LIGHTS > 0",
+		"	#if NUM_POINT_LIGHTS > 0",
 
-				"for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
+		"		for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
 
-					"vec3 lVector = pointLights[ i ].position + vViewPosition.xyz;",
+		"			vec3 lVector = pointLights[ i ].position + vViewPosition.xyz;",
 
-					"float attenuation = calcLightAttenuation( length( lVector ), pointLights[ i ].distance, pointLights[ i ].decay );",
+		"			float attenuation = calcLightAttenuation( length( lVector ), pointLights[ i ].distance, pointLights[ i ].decay );",
 
-					"lVector = normalize( lVector );",
+		"			lVector = normalize( lVector );",
 
-					"vec3 pointHalfVector = normalize( lVector + viewPosition );",
+		"			vec3 pointHalfVector = normalize( lVector + viewPosition );",
 
-					"float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
-					"float pointDiffuseWeight = max( dot( normal, lVector ), 0.0 );",
+		"			float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
+		"			float pointDiffuseWeight = max( dot( normal, lVector ), 0.0 );",
 
-					"float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, shininess ), 0.0 );",
+		"			float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, shininess ), 0.0 );",
 
-					"totalDiffuseLight += attenuation * pointLights[ i ].color * pointDiffuseWeight;",
-					"totalSpecularLight += attenuation * pointLights[ i ].color * specular * pointSpecularWeight * pointDiffuseWeight;",
+		"			totalDiffuseLight += attenuation * pointLights[ i ].color * pointDiffuseWeight;",
+		"			totalSpecularLight += attenuation * pointLights[ i ].color * specular * pointSpecularWeight * pointDiffuseWeight;",
 
-				"}",
+		"		}",
 
-			"#endif",
+		"	#endif",
 
 			// directional lights
 
-			"#if NUM_DIR_LIGHTS > 0",
+		"	#if NUM_DIR_LIGHTS > 0",
 
-				"vec3 dirDiffuse = vec3( 0.0 );",
-				"vec3 dirSpecular = vec3( 0.0 );",
+		"		vec3 dirDiffuse = vec3( 0.0 );",
+		"		vec3 dirSpecular = vec3( 0.0 );",
 
-				"for( int i = 0; i < NUM_DIR_LIGHTS; i++ ) {",
+		"		for( int i = 0; i < NUM_DIR_LIGHTS; i++ ) {",
 
-					"vec3 dirVector = directionalLights[ i ].direction;",
-					"vec3 dirHalfVector = normalize( dirVector + viewPosition );",
+		"			vec3 dirVector = directionalLights[ i ].direction;",
+		"			vec3 dirHalfVector = normalize( dirVector + viewPosition );",
 
-					"float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
-					"float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
+		"			float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
+		"			float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
 
-					"float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, shininess ), 0.0 );",
+		"			float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, shininess ), 0.0 );",
 
-					"totalDiffuseLight += directionalLights[ i ].color * dirDiffuseWeight;",
-					"totalSpecularLight += directionalLights[ i ].color * specular * dirSpecularWeight * dirDiffuseWeight;",
+		"			totalDiffuseLight += directionalLights[ i ].color * dirDiffuseWeight;",
+		"			totalSpecularLight += directionalLights[ i ].color * specular * dirSpecularWeight * dirDiffuseWeight;",
 
-				"}",
+		"		}",
 
-			"#endif",
+		"	#endif",
 
 			// hemisphere lights
 
-			"#if NUM_HEMI_LIGHTS > 0",
+		"	#if NUM_HEMI_LIGHTS > 0",
 
-				"vec3 hemiDiffuse  = vec3( 0.0 );",
-				"vec3 hemiSpecular = vec3( 0.0 );",
+		"		vec3 hemiDiffuse  = vec3( 0.0 );",
+		"		vec3 hemiSpecular = vec3( 0.0 );",
 
-				"for( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
+		"		for( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
 
-					"vec3 lVector = hemisphereLightDirection[ i ];",
+		"			vec3 lVector = hemisphereLightDirection[ i ];",
 
 					// diffuse
 
-					"float dotProduct = dot( normal, lVector );",
-					"float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
+		"			float dotProduct = dot( normal, lVector );",
+		"			float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
 
-					"totalDiffuseLight += mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight );",
+		"			totalDiffuseLight += mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight );",
 
 					// specular (sky light)
 
-					"float hemiSpecularWeight = 0.0;",
+		"			float hemiSpecularWeight = 0.0;",
 
-					"vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
-					"float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
-					"hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfSky, shininess ), 0.0 );",
+		"			vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
+		"			float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
+		"			hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfSky, shininess ), 0.0 );",
 
 					// specular (ground light)
 
-					"vec3 lVectorGround = -lVector;",
+		"			vec3 lVectorGround = -lVector;",
 
-					"vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
-					"float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
-					"hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfGround, shininess ), 0.0 );",
+		"			vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
+		"			float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
+		"			hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfGround, shininess ), 0.0 );",
 
-					"totalSpecularLight += specular * mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight ) * hemiSpecularWeight * hemiDiffuseWeight;",
+		"			totalSpecularLight += specular * mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight ) * hemiSpecularWeight * hemiDiffuseWeight;",
 
-				"}",
+		"		}",
 
-			"#endif",
+		"	#endif",
 
-			"outgoingLight += diffuseColor.xyz * ( totalDiffuseLight + ambientLightColor + totalSpecularLight );",
+		"	outgoingLight += diffuseColor.xyz * ( totalDiffuseLight + ambientLightColor + totalSpecularLight );",
 
-			"gl_FragColor = vec4( outgoingLight, diffuseColor.a );",	// TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+		"	gl_FragColor = vec4( outgoingLight, diffuseColor.a );",	// TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
 
 			THREE.ShaderChunk[ "fog_fragment" ],
 
@@ -252,9 +252,9 @@ THREE.TerrainShader = {
 
 		"#ifdef VERTEX_TEXTURES",
 
-			"uniform sampler2D tDisplacement;",
-			"uniform float uDisplacementScale;",
-			"uniform float uDisplacementBias;",
+		"	uniform sampler2D tDisplacement;",
+		"	uniform float uDisplacementScale;",
+		"	uniform float uDisplacementBias;",
 
 		"#endif",
 
@@ -270,45 +270,45 @@ THREE.TerrainShader = {
 
 		"void main() {",
 
-			"vNormal = normalize( normalMatrix * normal );",
+		"	vNormal = normalize( normalMatrix * normal );",
 
 			// tangent and binormal vectors
 
-			"vTangent = normalize( normalMatrix * tangent.xyz );",
+		"	vTangent = normalize( normalMatrix * tangent.xyz );",
 
-			"vBinormal = cross( vNormal, vTangent ) * tangent.w;",
-			"vBinormal = normalize( vBinormal );",
+		"	vBinormal = cross( vNormal, vTangent ) * tangent.w;",
+		"	vBinormal = normalize( vBinormal );",
 
 			// texture coordinates
 
-			"vUv = uv;",
+		"	vUv = uv;",
 
-			"vec2 uvBase = uv * uRepeatBase;",
+		"	vec2 uvBase = uv * uRepeatBase;",
 
 			// displacement mapping
 
-			"#ifdef VERTEX_TEXTURES",
+		"	#ifdef VERTEX_TEXTURES",
 
-				"vec3 dv = texture2D( tDisplacement, uvBase ).xyz;",
-				"float df = uDisplacementScale * dv.x + uDisplacementBias;",
-				"vec3 displacedPosition = normal * df + position;",
+		"		vec3 dv = texture2D( tDisplacement, uvBase ).xyz;",
+		"		float df = uDisplacementScale * dv.x + uDisplacementBias;",
+		"		vec3 displacedPosition = normal * df + position;",
 
-				"vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
-				"vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
+		"		vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
+		"		vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
 
-			"#else",
+		"	#else",
 
-				"vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-				"vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+		"		vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+		"		vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
 
-			"#endif",
+		"	#endif",
 
-			"gl_Position = projectionMatrix * mvPosition;",
+		"	gl_Position = projectionMatrix * mvPosition;",
 
-			"vViewPosition = -mvPosition.xyz;",
+		"	vViewPosition = -mvPosition.xyz;",
 
-			"vec3 normalTex = texture2D( tNormal, uvBase ).xyz * 2.0 - 1.0;",
-			"vNormal = normalMatrix * normalTex;",
+		"	vec3 normalTex = texture2D( tNormal, uvBase ).xyz * 2.0 - 1.0;",
+		"	vNormal = normalMatrix * normalTex;",
 
 			THREE.ShaderChunk[ "shadowmap_vertex" ],
 			THREE.ShaderChunk[ "fog_vertex" ],

examples/js/shaders/ToneMapShader.js

@@ -22,8 +22,8 @@ THREE.ToneMapShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -41,34 +41,34 @@ THREE.ToneMapShader = {
 		"uniform float minLuminance;",
 		"uniform float maxLuminance;",
 		"#ifdef ADAPTED_LUMINANCE",
-			"uniform sampler2D luminanceMap;",
+		"	uniform sampler2D luminanceMap;",
 		"#else",
-			"uniform float averageLuminance;",
+		"	uniform float averageLuminance;",
 		"#endif",
 
 		"vec3 ToneMap( vec3 vColor ) {",
-			"#ifdef ADAPTED_LUMINANCE",
+		"	#ifdef ADAPTED_LUMINANCE",
 				// Get the calculated average luminance
-				"float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-			"#else",
-				"float fLumAvg = averageLuminance;",
-			"#endif",
+		"		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
+		"	#else",
+		"		float fLumAvg = averageLuminance;",
+		"	#endif",
 
 			// Calculate the luminance of the current pixel
-			"float fLumPixel = linearToRelativeLuminance( vColor );",
+		"	float fLumPixel = linearToRelativeLuminance( vColor );",
 
 			// Apply the modified operator (Eq. 4)
-			"float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );",
+		"	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );",
 
-			"float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
-			"return fLumCompressed * vColor;",
+		"	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
+		"	return fLumCompressed * vColor;",
 		"}",
 
 		"void main() {",
 
-			"vec4 texel = texture2D( tDiffuse, vUv );",
+		"	vec4 texel = texture2D( tDiffuse, vUv );",
 
-			"gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
+		"	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
 
 		"}"
 

examples/js/shaders/TriangleBlurShader.js

@@ -25,8 +25,8 @@ THREE.TriangleBlurShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -45,25 +45,25 @@ THREE.TriangleBlurShader = {
 
 		"void main() {",
 
-			"vec4 color = vec4( 0.0 );",
+		"	vec4 color = vec4( 0.0 );",
 
-			"float total = 0.0;",
+		"	float total = 0.0;",
 
 			// randomize the lookup values to hide the fixed number of samples
 
-			"float offset = rand( vUv );",
+		"	float offset = rand( vUv );",
 
-			"for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {",
+		"	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {",
 
-				"float percent = ( t + offset - 0.5 ) / ITERATIONS;",
-				"float weight = 1.0 - abs( percent );",
+		"		float percent = ( t + offset - 0.5 ) / ITERATIONS;",
+		"		float weight = 1.0 - abs( percent );",
 
-				"color += texture2D( texture, vUv + delta * percent ) * weight;",
-				"total += weight;",
+		"		color += texture2D( texture, vUv + delta * percent ) * weight;",
+		"		total += weight;",
 
-			"}",
+		"	}",
 
-			"gl_FragColor = color / total;",
+		"	gl_FragColor = color / total;",
 
 		"}"
 

examples/js/shaders/UnpackDepthRGBAShader.js

@@ -20,8 +20,8 @@ THREE.UnpackDepthRGBAShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -39,8 +39,8 @@ THREE.UnpackDepthRGBAShader = {
 
 		"void main() {",
 
-			"float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );",
-			"gl_FragColor = vec4( vec3( depth ), opacity );",
+		"	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );",
+		"	gl_FragColor = vec4( vec3( depth ), opacity );",
 
 		"}"
 

examples/js/shaders/VerticalBlurShader.js

@@ -25,8 +25,8 @@ THREE.VerticalBlurShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -41,19 +41,19 @@ THREE.VerticalBlurShader = {
 
 		"void main() {",
 
-			"vec4 sum = vec4( 0.0 );",
+		"	vec4 sum = vec4( 0.0 );",
 
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;",
 
-			"gl_FragColor = sum;",
+		"	gl_FragColor = sum;",
 
 		"}"
 

examples/js/shaders/VerticalTiltShiftShader.js

@@ -25,8 +25,8 @@ THREE.VerticalTiltShiftShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -42,21 +42,21 @@ THREE.VerticalTiltShiftShader = {
 
 		"void main() {",
 
-			"vec4 sum = vec4( 0.0 );",
+		"	vec4 sum = vec4( 0.0 );",
 
-			"float vv = v * abs( r - vUv.y );",
+		"	float vv = v * abs( r - vUv.y );",
 
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;",
-			"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;",
+		"	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;",
 
-			"gl_FragColor = sum;",
+		"	gl_FragColor = sum;",
 
 		"}"
 

examples/js/shaders/VignetteShader.js

@@ -22,8 +22,8 @@ THREE.VignetteShader = {
 
 		"void main() {",
 
-			"vUv = uv;",
-			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+		"	vUv = uv;",
+		"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 
 		"}"
 
@@ -42,19 +42,19 @@ THREE.VignetteShader = {
 
 			// Eskil's vignette
 
-			"vec4 texel = texture2D( tDiffuse, vUv );",
-			"vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );",
-			"gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );",
+		"	vec4 texel = texture2D( tDiffuse, vUv );",
+		"	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );",
+		"	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );",
 
-			/*
-			// alternative version from glfx.js
-			// this one makes more "dusty" look (as opposed to "burned")
+		/*
+		// alternative version from glfx.js
+		// this one makes more "dusty" look (as opposed to "burned")
 
-			"vec4 color = texture2D( tDiffuse, vUv );",
-			"float dist = distance( vUv, vec2( 0.5 ) );",
-			"color.rgb *= smoothstep( 0.8, offset * 0.799, dist *( darkness + offset ) );",
-			"gl_FragColor = color;",
-			*/
+		"	vec4 color = texture2D( tDiffuse, vUv );",
+		"	float dist = distance( vUv, vec2( 0.5 ) );",
+		"	color.rgb *= smoothstep( 0.8, offset * 0.799, dist *( darkness + offset ) );",
+		"	gl_FragColor = color;",
+		*/
 
 		"}"