From 52a0262c2ab7ba7baaf1a569118e9a2b6537c398 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 12 Feb 2016 11:42:00 -0500
Subject: [PATCH 01/30] add ability to have texel encodings (RGBE,RGBM,etc.) on
 envMap and emissiveMap that can contain unbounded intensities.

---
 src/Three.js                                  | 10 +++
 src/renderers/WebGLRenderer.js                |  4 +
 .../ShaderChunk/emissivemap_fragment.glsl     |  2 +-
 .../emissivemap_pars_fragment.glsl            |  1 +
 .../shaders/ShaderChunk/encodings.glsl        | 85 +++++++++++++++++++
 .../shaders/ShaderChunk/envmap_fragment.glsl  |  2 +-
 .../ShaderChunk/envmap_pars_fragment.glsl     |  1 +
 .../shaders/ShaderChunk/lights_pars.glsl      |  4 +-
 src/renderers/shaders/ShaderLib.js            |  5 ++
 src/renderers/shaders/UniformsLib.js          |  4 +-
 src/textures/Texture.js                       |  4 +-
 11 files changed, 116 insertions(+), 6 deletions(-)
 create mode 100644 src/renderers/shaders/ShaderChunk/encodings.glsl

diff --git a/src/Three.js b/src/Three.js
index 13ad4071792e8f..146fb915b82da4 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -305,3 +305,13 @@ THREE.WrapAroundEnding = 2402;
 THREE.TrianglesDrawMode = 0;
 THREE.TriangleStripDrawMode = 1;
 THREE.TriangleFanDrawMode = 2;
+
+// Texture Encodings
+
+THREE.Linear = 3000; // No encoding at all.
+THREE.sRGB = 3001; // AKA gamma 2.2.
+THREE.RGBE = 3002; // AKA Radiance
+//THREE.LogLuv = 3003; TODO
+THREE.RGBM7 = 3004;
+THREE.RGBM16 = 3005;
+//THREE.RGBD = 3006; TODO
diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index 2da2de0a3901c2..a956aefa413a6a 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1962,6 +1962,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.envMap.value = material.envMap;
+		uniforms.envMapEncoding.value = material.envMap.encoding;
 		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
 
 		uniforms.reflectivity.value = material.reflectivity;
@@ -2033,6 +2034,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
+			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
 
 		}
 
@@ -2053,6 +2055,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
+			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
 
 		}
 
@@ -2107,6 +2110,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
+			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
 
 		}
 
diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
index 62cee1ce0894d8..ac346ad781e3ac 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
@@ -2,7 +2,7 @@
 
 	vec4 emissiveColor = texture2D( emissiveMap, vUv );
 
-	emissiveColor.rgb = inputToLinear( emissiveColor.rgb );
+	emissiveColor.rgb = texelDecode( emissiveColor, emissiveMapEncoding ).rgb;
 
 	totalEmissiveLight *= emissiveColor.rgb;
 
diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
index c05bb7f55180a0..cb51a1118fff13 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
@@ -1,5 +1,6 @@
 #ifdef USE_EMISSIVEMAP
 
 	uniform sampler2D emissiveMap;
+	uniform int emissiveMapEncoding;
 
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
new file mode 100644
index 00000000000000..26e3eb42819513
--- /dev/null
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -0,0 +1,85 @@
+// These encodings should have the same integer values as THREE.Linear, THREE.sRGB, etc...
+#define ENCODING_Linear 3000
+#define ENCODING_sRGB   3001  // AKA gamma 2.2.
+#define ENCODING_RGBE   3002  // Radiance
+//#define ENCODING_LogLuv 3003
+#define ENCODING_RGBM7  3004
+#define ENCODING_RGBM16 3005
+//#define ENCODING_RGBM16 3007
+
+vec4 texelDecode( in vec4 encodedTexel, in int encoding ) {
+
+  // Q: should we use a switch statement here instead of a set of ifs?
+
+  if( encoding == ENCODING_Linear ) {
+    return encodedTexel;
+  }
+
+  if( encoding == ENCODING_sRGB ) {
+    return vec4( pow( encodedTexel.xyz, vec3( 2.2 ) ), encodedTexel.w );
+  }
+
+  if( encoding == ENCODING_RGBE ) {
+    return vec4( encodedTexel.xyz * exp2( encodedTexel.w*256.0 - 128.0 ), 1.0 );
+  }
+
+  // TODO
+  //if( encoding == ENCODING_LogLuv ) {
+  //}
+
+  if( encoding == ENCODING_RGBM7 ) {
+    return vec4( encodedTexel.xyz * encodedTexel.w * 7.0, 1.0 );
+  }
+
+  if( encoding == ENCODING_RGBM16 ) {
+    return vec4( encodedTexel.xyz * encodedTexel.w * 16.0, 1.0 );
+  }
+
+  // TODO
+  //if( encoding == ENCODING_RGBD ) {
+  //}
+
+  // return red when encoding not supported
+  return vec4( 1.0, 0.0, 0.0, 1.0 );
+
+}
+
+vec4 texelEncode( in vec4 linearRgba, in int encoding )
+{
+
+  // Q: should we use a switch statement here instead of a set of ifs?
+
+  if( encoding == ENCODING_Linear ) {
+    return linearRgba;
+  }
+
+  if( encoding == ENCODING_sRGB ) {
+    return vec4( pow( linearRgba.xyz, vec3( 0.4545 ) ), encodedTexel.w );
+  }
+
+  if( encoding == ENCODING_RGBE ) {
+    float maxComponent = max(max(linearRgba.r, linearRgba.g), linearRgba.b );
+    float fExp = ceil( log2(maxComponent) );
+    return vec4( linearRgba.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
+  }
+
+  // TODO
+  //if( encoding == ENCODING_LogLuv ) {
+  //}
+
+  // TODO
+  //if( encoding == ENCODING_RGBM7 ) {
+  //}
+
+  // TODO
+  //if( encoding == ENCODING_RGBM16 ) {
+  //}
+
+  // TODO
+  //if( encoding == ENCODING_RGBD ) {
+  //}
+
+  // return red when encoding not supported
+  return vec4( 1.0, 0.0, 0.0, 1.0 );
+
+}
diff --git a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
index 1d125de494f377..89c5565d2da0cb 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
@@ -43,7 +43,7 @@
 		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );
 	#endif
 
-	envColor.xyz = inputToLinear( envColor.xyz );
+	envColor = texelDecode( envColor, envMapEncoding );
 
 	#ifdef ENVMAP_BLENDING_MULTIPLY
 
diff --git a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
index 8b060c651f1ca1..ce777c5b5a1ffd 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
@@ -10,6 +10,7 @@
 		uniform sampler2D envMap;
 	#endif
 	uniform float flipEnvMap;
+	uniform int envMapEncoding;
 
 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( STANDARD )
 
diff --git a/src/renderers/shaders/ShaderChunk/lights_pars.glsl b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
index 6c0fadde9b41c5..8bef5850c53598 100644
--- a/src/renderers/shaders/ShaderChunk/lights_pars.glsl
+++ b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
@@ -186,7 +186,7 @@
 
 		#endif
 
-		envMapColor.rgb = inputToLinear( envMapColor.rgb );
+		envMapColor.rgb = texelDecode( envMapColor.rgb, envMapEncoding );
 
 		return PI * envMapColor.rgb * envMapIntensity;
 
@@ -278,7 +278,7 @@
 
 		#endif
 
-		envMapColor.rgb = inputToLinear( envMapColor.rgb );
+		envMapColor.rgb = texelDecode( envMapColor.rgb, envMapEncoding );
 
 		return envMapColor.rgb * envMapIntensity;
 
diff --git a/src/renderers/shaders/ShaderLib.js b/src/renderers/shaders/ShaderLib.js
index e61fabe6246252..44e85262a286a7 100644
--- a/src/renderers/shaders/ShaderLib.js
+++ b/src/renderers/shaders/ShaderLib.js
@@ -73,6 +73,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],
 			THREE.ShaderChunk[ "uv2_pars_fragment" ],
@@ -153,6 +154,7 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "uv2_pars_vertex" ],
 			THREE.ShaderChunk[ "envmap_pars_vertex" ],
 			THREE.ShaderChunk[ "bsdfs" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "color_pars_vertex" ],
 			THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
@@ -212,6 +214,7 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "emissivemap_pars_fragment" ],
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
@@ -377,6 +380,7 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "lights_phong_pars_fragment" ],
@@ -540,6 +544,7 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "lights_standard_pars_fragment" ],
diff --git a/src/renderers/shaders/UniformsLib.js b/src/renderers/shaders/UniformsLib.js
index e7ab4baeb5a6fc..ca68688577c955 100644
--- a/src/renderers/shaders/UniformsLib.js
+++ b/src/renderers/shaders/UniformsLib.js
@@ -16,6 +16,7 @@ THREE.UniformsLib = {
 		"alphaMap": { type: "t", value: null },
 
 		"envMap": { type: "t", value: null },
+		"envMapEncoding" : { type: "i", value: THREE.Linear },
 		"flipEnvMap": { type: "f", value: - 1 },
 		"reflectivity": { type: "f", value: 1.0 },
 		"refractionRatio": { type: "f", value: 0.98 }
@@ -38,7 +39,8 @@ THREE.UniformsLib = {
 
 	emissivemap: {
 
-		"emissiveMap": { type: "t", value: null }
+		"emissiveMap": { type: "t", value: null },
+		"emissiveMapEncoding": { type: "i", value: THREE.Linear }
 
 	},
 
diff --git a/src/textures/Texture.js b/src/textures/Texture.js
index 44a57efc569a85..acd67435bf9d29 100644
--- a/src/textures/Texture.js
+++ b/src/textures/Texture.js
@@ -35,7 +35,8 @@ THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, f
 	this.generateMipmaps = true;
 	this.premultiplyAlpha = false;
 	this.flipY = true;
-	this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
+	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
+	this.encoding = THREE.Linear;	// Values !== THREE.Linear only supported on envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
 
 	this.version = 0;
 	this.onUpdate = null;
@@ -86,6 +87,7 @@ THREE.Texture.prototype = {
 		this.premultiplyAlpha = source.premultiplyAlpha;
 		this.flipY = source.flipY;
 		this.unpackAlignment = source.unpackAlignment;
+		this.encoding = source.encoding;
 
 		return this;
 

From edf8e03fea94efbdff10fa19252fcd4e78c9ecce Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 12 Feb 2016 11:52:21 -0500
Subject: [PATCH 02/30] bug fixes.

---
 src/renderers/WebGLRenderer.js                     | 2 +-
 src/renderers/shaders/ShaderChunk/encodings.glsl   | 6 +++---
 src/renderers/shaders/ShaderChunk/lights_pars.glsl | 4 ++--
 utils/build/includes/common.json                   | 1 +
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index a956aefa413a6a..31b49aeec189ab 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1962,7 +1962,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.envMap.value = material.envMap;
-		uniforms.envMapEncoding.value = material.envMap.encoding;
+		uniforms.envMapEncoding.value = ( material.envMap ? material.envMap.encoding : THREE.Linear );
 		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
 
 		uniforms.reflectivity.value = material.reflectivity;
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 26e3eb42819513..61809f2354e618 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -1,7 +1,7 @@
 // These encodings should have the same integer values as THREE.Linear, THREE.sRGB, etc...
 #define ENCODING_Linear 3000
-#define ENCODING_sRGB   3001  // AKA gamma 2.2.
-#define ENCODING_RGBE   3002  // Radiance
+#define ENCODING_sRGB   3001
+#define ENCODING_RGBE   3002
 //#define ENCODING_LogLuv 3003
 #define ENCODING_RGBM7  3004
 #define ENCODING_RGBM16 3005
@@ -54,7 +54,7 @@ vec4 texelEncode( in vec4 linearRgba, in int encoding )
   }
 
   if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( linearRgba.xyz, vec3( 0.4545 ) ), encodedTexel.w );
+    return vec4( pow( linearRgba.xyz, vec3( 0.4545 ) ), linearRgba.w );
   }
 
   if( encoding == ENCODING_RGBE ) {
diff --git a/src/renderers/shaders/ShaderChunk/lights_pars.glsl b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
index 8bef5850c53598..c144ba0f5d919d 100644
--- a/src/renderers/shaders/ShaderChunk/lights_pars.glsl
+++ b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
@@ -186,7 +186,7 @@
 
 		#endif
 
-		envMapColor.rgb = texelDecode( envMapColor.rgb, envMapEncoding );
+		envMapColor.rgb = texelDecode( envMapColor, envMapEncoding ).rgb;
 
 		return PI * envMapColor.rgb * envMapIntensity;
 
@@ -278,7 +278,7 @@
 
 		#endif
 
-		envMapColor.rgb = texelDecode( envMapColor.rgb, envMapEncoding );
+		envMapColor.rgb = texelDecode( envMapColor, envMapEncoding ).rgb;
 
 		return envMapColor.rgb * envMapIntensity;
 
diff --git a/utils/build/includes/common.json b/utils/build/includes/common.json
index 6112f3ce401627..cb01a361b75bb2 100644
--- a/utils/build/includes/common.json
+++ b/utils/build/includes/common.json
@@ -137,6 +137,7 @@
 	"src/renderers/shaders/ShaderChunk/displacementmap_pars_vertex.glsl",
 	"src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl",
+	"src/renderers/shaders/ShaderChunk/encodings.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl",

From 1b5eeee7ec2b3ada3783ef3977cb8a5a50638809 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 12 Feb 2016 12:04:15 -0500
Subject: [PATCH 03/30] add links to helpful websites.

---
 src/renderers/shaders/ShaderChunk/encodings.glsl | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 61809f2354e618..eac8300d13517b 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -1,3 +1,5 @@
+// For a discussion of what this is, please read this: http://lousodrome.net/blog/light/2013/05/26/gamma-correct-and-hdr-rendering-in-a-32-bits-buffer/
+
 // These encodings should have the same integer values as THREE.Linear, THREE.sRGB, etc...
 #define ENCODING_Linear 3000
 #define ENCODING_sRGB   3001
@@ -23,7 +25,7 @@ vec4 texelDecode( in vec4 encodedTexel, in int encoding ) {
     return vec4( encodedTexel.xyz * exp2( encodedTexel.w*256.0 - 128.0 ), 1.0 );
   }
 
-  // TODO
+  // TODO, see here http://graphicrants.blogspot.ca/2009/04/rgbm-color-encoding.html
   //if( encoding == ENCODING_LogLuv ) {
   //}
 
@@ -63,7 +65,7 @@ vec4 texelEncode( in vec4 linearRgba, in int encoding )
     return vec4( linearRgba.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
   }
 
-  // TODO
+  // TODO, see here http://graphicrants.blogspot.ca/2009/04/rgbm-color-encoding.html
   //if( encoding == ENCODING_LogLuv ) {
   //}
 

From 47aa1bebd0e7c27c2355d0217ad7c2084d20eb56 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 12 Feb 2016 14:51:22 -0500
Subject: [PATCH 04/30] use standard GAMMA_FACTOR define.

---
 src/renderers/shaders/ShaderChunk/encodings.glsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index eac8300d13517b..10e9cf715e083f 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -18,7 +18,7 @@ vec4 texelDecode( in vec4 encodedTexel, in int encoding ) {
   }
 
   if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( encodedTexel.xyz, vec3( 2.2 ) ), encodedTexel.w );
+    return vec4( pow( encodedTexel.xyz, vec3( GAMMA_FACTOR ) ), encodedTexel.w );
   }
 
   if( encoding == ENCODING_RGBE ) {
@@ -56,7 +56,7 @@ vec4 texelEncode( in vec4 linearRgba, in int encoding )
   }
 
   if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( linearRgba.xyz, vec3( 0.4545 ) ), linearRgba.w );
+    return vec4( pow( linearRgba.xyz, vec3( 1.0 / GAMMA_FACTOR ) ), linearRgba.w );
   }
 
   if( encoding == ENCODING_RGBE ) {

From 94eca51d6dd5cf70f2735c80ab7829986fbb4d9d Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 19 Feb 2016 22:07:41 -0500
Subject: [PATCH 05/30] adopt new naming scheme per @mrdoob's recommendation.

---
 src/Three.js                                     | 14 +++++++-------
 src/renderers/WebGLRenderer.js                   |  2 +-
 src/renderers/shaders/ShaderChunk/encodings.glsl |  2 +-
 src/renderers/shaders/UniformsLib.js             |  4 ++--
 src/textures/Texture.js                          |  2 +-
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Three.js b/src/Three.js
index 146fb915b82da4..298592f562faaf 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -308,10 +308,10 @@ THREE.TriangleFanDrawMode = 2;
 
 // Texture Encodings
 
-THREE.Linear = 3000; // No encoding at all.
-THREE.sRGB = 3001; // AKA gamma 2.2.
-THREE.RGBE = 3002; // AKA Radiance
-//THREE.LogLuv = 3003; TODO
-THREE.RGBM7 = 3004;
-THREE.RGBM16 = 3005;
-//THREE.RGBD = 3006; TODO
+THREE.LinearEncoding = 3000; // No encoding at all.
+THREE.sRGBEncoding = 3001; // AKA gamma 2.2.
+THREE.RGBEEncoding = 3002; // AKA Radiance
+//THREE.LogLuvEncoding = 3003; TODO
+THREE.RGBM7Encoding = 3004;
+THREE.RGBM16Encoding = 3005;
+//THREE.RGBDEncoding = 3006; TODO
diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index 31b49aeec189ab..181d15832b341e 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1962,7 +1962,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.envMap.value = material.envMap;
-		uniforms.envMapEncoding.value = ( material.envMap ? material.envMap.encoding : THREE.Linear );
+		uniforms.envMapEncoding.value = ( material.envMap ? material.envMap.encoding : THREE.LinearEncoding );
 		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
 
 		uniforms.reflectivity.value = material.reflectivity;
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 10e9cf715e083f..45b3c29c75a3e0 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -1,6 +1,6 @@
 // For a discussion of what this is, please read this: http://lousodrome.net/blog/light/2013/05/26/gamma-correct-and-hdr-rendering-in-a-32-bits-buffer/
 
-// These encodings should have the same integer values as THREE.Linear, THREE.sRGB, etc...
+// These encodings should have the same integer values as THREE.LinearEncoding, THREE.sRGBEncoding, etc...
 #define ENCODING_Linear 3000
 #define ENCODING_sRGB   3001
 #define ENCODING_RGBE   3002
diff --git a/src/renderers/shaders/UniformsLib.js b/src/renderers/shaders/UniformsLib.js
index ca68688577c955..22f90896816ac1 100644
--- a/src/renderers/shaders/UniformsLib.js
+++ b/src/renderers/shaders/UniformsLib.js
@@ -16,7 +16,7 @@ THREE.UniformsLib = {
 		"alphaMap": { type: "t", value: null },
 
 		"envMap": { type: "t", value: null },
-		"envMapEncoding" : { type: "i", value: THREE.Linear },
+		"envMapEncoding" : { type: "i", value: THREE.LinearEncoding },
 		"flipEnvMap": { type: "f", value: - 1 },
 		"reflectivity": { type: "f", value: 1.0 },
 		"refractionRatio": { type: "f", value: 0.98 }
@@ -40,7 +40,7 @@ THREE.UniformsLib = {
 	emissivemap: {
 
 		"emissiveMap": { type: "t", value: null },
-		"emissiveMapEncoding": { type: "i", value: THREE.Linear }
+		"emissiveMapEncoding": { type: "i", value: THREE.LinearEncoding }
 
 	},
 
diff --git a/src/textures/Texture.js b/src/textures/Texture.js
index acd67435bf9d29..ad862ebf105d67 100644
--- a/src/textures/Texture.js
+++ b/src/textures/Texture.js
@@ -36,7 +36,7 @@ THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, f
 	this.premultiplyAlpha = false;
 	this.flipY = true;
 	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
-	this.encoding = THREE.Linear;	// Values !== THREE.Linear only supported on envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
+	this.encoding = THREE.LinearEncoding;	// Values !== THREE.LinearEncoding only supported on envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
 
 	this.version = 0;
 	this.onUpdate = null;

From 15e08c1327f439b397c4f074da3f17ff10e13568 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 19 Feb 2016 23:10:03 -0500
Subject: [PATCH 06/30] add support for Texture.encoding to Material.map

---
 src/Three.js                                             | 1 +
 src/renderers/WebGLRenderer.js                           | 9 +++++----
 src/renderers/shaders/ShaderChunk/encodings.glsl         | 4 ++--
 src/renderers/shaders/ShaderChunk/map_fragment.glsl      | 3 +--
 src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl | 3 ++-
 src/renderers/shaders/UniformsLib.js                     | 1 +
 src/textures/Texture.js                                  | 2 +-
 7 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/Three.js b/src/Three.js
index 298592f562faaf..39dd6277e3b426 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -315,3 +315,4 @@ THREE.RGBEEncoding = 3002; // AKA Radiance
 THREE.RGBM7Encoding = 3004;
 THREE.RGBM16Encoding = 3005;
 //THREE.RGBDEncoding = 3006; TODO
+THREE.DefaultEncoding = 3007; // Use sRGB or Linear as appropriate.
diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index 181d15832b341e..500159c0a61d0c 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1888,6 +1888,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.map.value = material.map;
+		uniforms.mapEncoding.value = (( material.map && material.map.encoding !== THREE.DefaultEncoding ) ? material.map.encoding : THREE.sRGBEncoding );
 		uniforms.specularMap.value = material.specularMap;
 		uniforms.alphaMap.value = material.alphaMap;
 
@@ -1962,7 +1963,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.envMap.value = material.envMap;
-		uniforms.envMapEncoding.value = ( material.envMap ? material.envMap.encoding : THREE.LinearEncoding );
+		uniforms.envMapEncoding.value = (( material.envMap  && material.envMap.encoding !== THREE.DefaultEncoding )? material.envMap.encoding : THREE.LinearEncoding );
 		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
 
 		uniforms.reflectivity.value = material.reflectivity;
@@ -2034,7 +2035,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
+			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
@@ -2055,7 +2056,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
+			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
@@ -2110,7 +2111,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = material.emissiveMap.encoding;
+			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 45b3c29c75a3e0..419d1cc122c9c3 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -18,7 +18,7 @@ vec4 texelDecode( in vec4 encodedTexel, in int encoding ) {
   }
 
   if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( encodedTexel.xyz, vec3( GAMMA_FACTOR ) ), encodedTexel.w );
+    return vec4( pow( encodedTexel.xyz, vec3( float( GAMMA_FACTOR ) ) ), encodedTexel.w );
   }
 
   if( encoding == ENCODING_RGBE ) {
@@ -56,7 +56,7 @@ vec4 texelEncode( in vec4 linearRgba, in int encoding )
   }
 
   if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( linearRgba.xyz, vec3( 1.0 / GAMMA_FACTOR ) ), linearRgba.w );
+    return vec4( pow( linearRgba.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), linearRgba.w );
   }
 
   if( encoding == ENCODING_RGBE ) {
diff --git a/src/renderers/shaders/ShaderChunk/map_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
index 8620c75239937c..f749db300ead06 100644
--- a/src/renderers/shaders/ShaderChunk/map_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
@@ -2,8 +2,7 @@
 
 	vec4 texelColor = texture2D( map, vUv );
 
-	texelColor.xyz = inputToLinear( texelColor.xyz );
-
+	texelColor = texelDecode( texelColor, mapEncoding );
 	diffuseColor *= texelColor;
 
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
index 754690cc63ce82..c3ecdae9fb20a3 100644
--- a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
@@ -1,5 +1,6 @@
 #ifdef USE_MAP
 
 	uniform sampler2D map;
+	uniform int mapEncoding;
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/renderers/shaders/UniformsLib.js b/src/renderers/shaders/UniformsLib.js
index 22f90896816ac1..e0e925bc1a8093 100644
--- a/src/renderers/shaders/UniformsLib.js
+++ b/src/renderers/shaders/UniformsLib.js
@@ -10,6 +10,7 @@ THREE.UniformsLib = {
 		"opacity": { type: "f", value: 1.0 },
 
 		"map": { type: "t", value: null },
+		"mapEncoding" : { type: "i", value: THREE.sRGBEncoding },
 		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
 
 		"specularMap": { type: "t", value: null },
diff --git a/src/textures/Texture.js b/src/textures/Texture.js
index ad862ebf105d67..fe0fa4944b5283 100644
--- a/src/textures/Texture.js
+++ b/src/textures/Texture.js
@@ -36,7 +36,7 @@ THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, f
 	this.premultiplyAlpha = false;
 	this.flipY = true;
 	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
-	this.encoding = THREE.LinearEncoding;	// Values !== THREE.LinearEncoding only supported on envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
+	this.encoding = THREE.DefaultEncoding;	// Values !== THREE.LinearEncoding only supported on map, envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
 
 	this.version = 0;
 	this.onUpdate = null;

From 7c2ffd14b1ad241607a85de60270c5b10773d77a Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Fri, 19 Feb 2016 23:23:07 -0500
Subject: [PATCH 07/30] set backwards compatible default.

---
 src/renderers/WebGLRenderer.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index 500159c0a61d0c..e86a5686c5f683 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1888,7 +1888,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.map.value = material.map;
-		uniforms.mapEncoding.value = (( material.map && material.map.encoding !== THREE.DefaultEncoding ) ? material.map.encoding : THREE.sRGBEncoding );
+		uniforms.mapEncoding.value = (( material.map && material.map.encoding !== THREE.DefaultEncoding ) ? material.map.encoding : THREE.LinearEncoding );
 		uniforms.specularMap.value = material.specularMap;
 		uniforms.alphaMap.value = material.alphaMap;
 

From 3ca76ecd4c2a784a1b7b38795f6f40d1c8b7d148 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 13:57:11 -0500
Subject: [PATCH 08/30] make encodings.glsl more reusable.

---
 .../ShaderChunk/emissivemap_fragment.glsl     |   2 +-
 .../shaders/ShaderChunk/encodings.glsl        | 121 ++++++++++--------
 .../shaders/ShaderChunk/envmap_fragment.glsl  |   2 +-
 .../shaders/ShaderChunk/lights_pars.glsl      |   4 +-
 .../shaders/ShaderChunk/map_fragment.glsl     |   2 +-
 5 files changed, 74 insertions(+), 57 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
index ac346ad781e3ac..25dc6d0dedd260 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
@@ -2,7 +2,7 @@
 
 	vec4 emissiveColor = texture2D( emissiveMap, vUv );
 
-	emissiveColor.rgb = texelDecode( emissiveColor, emissiveMapEncoding ).rgb;
+	emissiveColor.rgb = EncodingToLinear( emissiveColor, emissiveMapEncoding ).rgb;
 
 	totalEmissiveLight *= emissiveColor.rgb;
 
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 419d1cc122c9c3..e74e1b80d18ac7 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -9,79 +9,96 @@
 #define ENCODING_RGBM16 3005
 //#define ENCODING_RGBM16 3007
 
-vec4 texelDecode( in vec4 encodedTexel, in int encoding ) {
+vec4 LinearToLinear( in vec4 value ) {
+  return value;
+}
 
-  // Q: should we use a switch statement here instead of a set of ifs?
+vec4 sRGBToLinear( in vec4 value ) {
+  return vec4( pow( value.xyz, vec3( float( GAMMA_FACTOR ) ) ), value.w );
+}
 
-  if( encoding == ENCODING_Linear ) {
-    return encodedTexel;
-  }
+vec4 RGBEToLinear( in vec4 value ) {
+  return vec4( value.xyz * exp2( value.w*256.0 - 128.0 ), 1.0 );
+}
 
-  if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( encodedTexel.xyz, vec3( float( GAMMA_FACTOR ) ) ), encodedTexel.w );
-  }
+vec4 RGBM7ToLinear( in vec4 value ) {
+  return vec4( value.xyz * value.w * 7.0, 1.0 );
+}
 
-  if( encoding == ENCODING_RGBE ) {
-    return vec4( encodedTexel.xyz * exp2( encodedTexel.w*256.0 - 128.0 ), 1.0 );
-  }
+vec4 RGBM16ToLinear( in vec4 value ) {
+  return vec4( value.xyz * value.w * 16.0, 1.0 );
+}
 
-  // TODO, see here http://graphicrants.blogspot.ca/2009/04/rgbm-color-encoding.html
-  //if( encoding == ENCODING_LogLuv ) {
-  //}
+vec4 LinearTosRGB( in vec4 value ) {
+  return vec4( pow( value.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), value.w );
+}
 
-  if( encoding == ENCODING_RGBM7 ) {
-    return vec4( encodedTexel.xyz * encodedTexel.w * 7.0, 1.0 );
-  }
+vec4 LinearToRGBE( in vec4 value ) {
+  float maxComponent = max(max(value.r, value.g), value.b );
+  float fExp = ceil( log2(maxComponent) );
+  return vec4( value.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
+}
 
-  if( encoding == ENCODING_RGBM16 ) {
-    return vec4( encodedTexel.xyz * encodedTexel.w * 16.0, 1.0 );
-  }
+vec4 EncodingToLinear( in vec4 value, in int fromEncoding ) {
+
+  switch( fromEncoding ) {
 
-  // TODO
-  //if( encoding == ENCODING_RGBD ) {
-  //}
+    case ENCODING_Linear:
+      return value;
 
-  // return red when encoding not supported
-  return vec4( 1.0, 0.0, 0.0, 1.0 );
+    case ENCODING_sRGB:
+      return LinearTosRGB( value );
+
+    //case ENCODING_LogLuv:
+    //  return LinearToLogLuv( value );
+
+    case ENCODING_RGBE:
+      return LinearToRGBE( value );
+
+    case ENCODING_RGBM7:
+      return LinearToRGBM7( value );
+
+    case ENCODING_RGBM16:
+      return LinearToRGBM16( value );
+
+    //case ENCODING_RGBD:
+    //  return LinearToRGBD( value );
+
+    default:
+      return vec4( 1.0, 0.0, 0.0, 1.0 );
+
+  }
 
 }
 
-vec4 texelEncode( in vec4 linearRgba, in int encoding )
+vec4 LinearToEncoding( in vec4 value, in int toEncoding )
 {
+  switch( toEncoding ) {
 
-  // Q: should we use a switch statement here instead of a set of ifs?
+    case ENCODING_Linear:
+      return value;
 
-  if( encoding == ENCODING_Linear ) {
-    return linearRgba;
-  }
+    case ENCODING_sRGB:
+      return sRGBToLinear( value );
 
-  if( encoding == ENCODING_sRGB ) {
-    return vec4( pow( linearRgba.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), linearRgba.w );
-  }
+    //case ENCODING_LogLuv:
+    //  return LogLuvToLinear( value );
 
-  if( encoding == ENCODING_RGBE ) {
-    float maxComponent = max(max(linearRgba.r, linearRgba.g), linearRgba.b );
-    float fExp = ceil( log2(maxComponent) );
-    return vec4( linearRgba.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
-  }
+    case ENCODING_RGBE:
+      return RGBEToLinear( value );
 
-  // TODO, see here http://graphicrants.blogspot.ca/2009/04/rgbm-color-encoding.html
-  //if( encoding == ENCODING_LogLuv ) {
-  //}
+    //case ENCODING_RGBM7:
+    //  return RGBM7ToLinear( value );
 
-  // TODO
-  //if( encoding == ENCODING_RGBM7 ) {
-  //}
+    //case ENCODING_RGBM16:
+    //  return RGBM16ToLinear( value );
 
-  // TODO
-  //if( encoding == ENCODING_RGBM16 ) {
-  //}
+    //case ENCODING_RGBD:
+    //  return RGBDToLinear( value );
 
-  // TODO
-  //if( encoding == ENCODING_RGBD ) {
-  //}
+    default:
+      return vec4( 1.0, 0.0, 0.0, 1.0 );
 
-  // return red when encoding not supported
-  return vec4( 1.0, 0.0, 0.0, 1.0 );
+  }
 
 }
diff --git a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
index 89c5565d2da0cb..47619a82000911 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
@@ -43,7 +43,7 @@
 		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );
 	#endif
 
-	envColor = texelDecode( envColor, envMapEncoding );
+	envColor = EncodingToLinear( envColor, envMapEncoding );
 
 	#ifdef ENVMAP_BLENDING_MULTIPLY
 
diff --git a/src/renderers/shaders/ShaderChunk/lights_pars.glsl b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
index c144ba0f5d919d..239633efce7c7f 100644
--- a/src/renderers/shaders/ShaderChunk/lights_pars.glsl
+++ b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
@@ -186,7 +186,7 @@
 
 		#endif
 
-		envMapColor.rgb = texelDecode( envMapColor, envMapEncoding ).rgb;
+		envMapColor.rgb = EncodingToLinear( envMapColor, envMapEncoding ).rgb;
 
 		return PI * envMapColor.rgb * envMapIntensity;
 
@@ -278,7 +278,7 @@
 
 		#endif
 
-		envMapColor.rgb = texelDecode( envMapColor, envMapEncoding ).rgb;
+		envMapColor.rgb = EncodingToLinear( envMapColor, envMapEncoding ).rgb;
 
 		return envMapColor.rgb * envMapIntensity;
 
diff --git a/src/renderers/shaders/ShaderChunk/map_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
index f749db300ead06..e70f2cd9a1adb5 100644
--- a/src/renderers/shaders/ShaderChunk/map_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
@@ -2,7 +2,7 @@
 
 	vec4 texelColor = texture2D( map, vUv );
 
-	texelColor = texelDecode( texelColor, mapEncoding );
+	texelColor = EncodingToLinear( texelColor, mapEncoding );
 	diffuseColor *= texelColor;
 
 #endif

From b057fed455d6e5712cd51966d8f5e627568dc43f Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 13:58:05 -0500
Subject: [PATCH 09/30] begin on swithcing texture encodings from uniforms to
 macros.

---
 .../ShaderChunk/encoding_template.glsl        | 44 +++++++++++++++++++
 utils/build/includes/common.json              |  1 +
 2 files changed, 45 insertions(+)
 create mode 100644 src/renderers/shaders/ShaderChunk/encoding_template.glsl

diff --git a/src/renderers/shaders/ShaderChunk/encoding_template.glsl b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
new file mode 100644
index 00000000000000..c2e6a9e1749ee2
--- /dev/null
+++ b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
@@ -0,0 +1,44 @@
+// this is intended to be the body of a macro.  Define the name of the function,
+// set the defines and then include this glsl snippet to define its body.
+
+#if defined( MACRO_DECODE )
+
+  #if ( MACRO_ENCODING_TYPE == ENCODING_Linear )
+    return value;
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_sRGB )
+    return sRGBToLinear( value );
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBE )
+    return RGBEToLinear( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_LogLuv )  TODO
+  //  return LogLuvToLinear( value );
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM7 )
+    return RGBM7ToLinear( value );
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM16 )
+    return RGBM16ToLinear( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBD )  TODO
+  //  return RGBMDToLinear( value );
+  #else
+    return vec4( 1.0, 0.0, 0.0, 1.0 );
+  #endif
+
+#elif defined( MACRO_ENCODE )
+
+  #if ( MACRO_ENCODING_TYPE == ENCODING_Linear )
+    return value;
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_sRGB )
+    return LinearTosRGB( value );
+  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBE )
+    return LinearToRGBE( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_LogLuv )  TODO
+  //  return LinearToLogLuv( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM7 )  TODO
+  //  return LinearToRGBM7( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM16 )  TODO
+  //  return LinearToRGBM16( value );
+  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBD )  TODO
+  //  return LinearToRGBMD( value );
+  #else
+    return vec4( 1.0, 0.0, 0.0, 1.0 );
+  #endif
+
+#endif
diff --git a/utils/build/includes/common.json b/utils/build/includes/common.json
index cb01a361b75bb2..2faa2f00b6c5ab 100644
--- a/utils/build/includes/common.json
+++ b/utils/build/includes/common.json
@@ -138,6 +138,7 @@
 	"src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/encodings.glsl",
+	"src/renderers/shaders/ShaderChunk/encoding_template.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl",

From e2c86dae12287b6127e1af162943d437d26b6ab5 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 14:09:08 -0500
Subject: [PATCH 10/30] adopt macro-defined encodings, remove uniform defined
 encodings.

---
 .../ShaderChunk/emissivemap_fragment.glsl     |  2 +-
 .../emissivemap_pars_fragment.glsl            |  7 ++++-
 .../ShaderChunk/encoding_template.glsl        | 28 +++++++++----------
 .../shaders/ShaderChunk/envmap_fragment.glsl  |  2 +-
 .../ShaderChunk/envmap_pars_fragment.glsl     |  7 ++++-
 .../shaders/ShaderChunk/lights_pars.glsl      |  2 +-
 .../shaders/ShaderChunk/map_fragment.glsl     |  2 +-
 .../ShaderChunk/map_pars_fragment.glsl        |  7 ++++-
 src/renderers/webgl/WebGLProgram.js           |  3 ++
 src/renderers/webgl/WebGLPrograms.js          |  7 +++--
 10 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
index 25dc6d0dedd260..c0951b050bda16 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
@@ -2,7 +2,7 @@
 
 	vec4 emissiveColor = texture2D( emissiveMap, vUv );
 
-	emissiveColor.rgb = EncodingToLinear( emissiveColor, emissiveMapEncoding ).rgb;
+	emissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;
 
 	totalEmissiveLight *= emissiveColor.rgb;
 
diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
index cb51a1118fff13..6c60f2f140414a 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
@@ -1,6 +1,11 @@
 #ifdef USE_EMISSIVEMAP
 
 	uniform sampler2D emissiveMap;
-	uniform int emissiveMapEncoding;
+
+	vec4 emissiveMapTexelToLinear( vec4 texel ) {
+		#define DECODE_MACRO EMISSIVEMAP_ENCODING
+			#include "encoding_template.glsl"
+		#undef DECODE_MACRO
+	}
 
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/encoding_template.glsl b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
index c2e6a9e1749ee2..553c117122f2f7 100644
--- a/src/renderers/shaders/ShaderChunk/encoding_template.glsl
+++ b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
@@ -3,19 +3,19 @@
 
 #if defined( MACRO_DECODE )
 
-  #if ( MACRO_ENCODING_TYPE == ENCODING_Linear )
+  #if ( MACRO_DECODE == ENCODING_Linear )
     return value;
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_sRGB )
+  #elif ( MACRO_DECODE == ENCODING_sRGB )
     return sRGBToLinear( value );
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBE )
+  #elif ( MACRO_DECODE == ENCODING_RGBE )
     return RGBEToLinear( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_LogLuv )  TODO
+  //#elif ( MACRO_DECODE == ENCODING_LogLuv )  TODO
   //  return LogLuvToLinear( value );
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM7 )
+  #elif ( MACRO_DECODE == ENCODING_RGBM7 )
     return RGBM7ToLinear( value );
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM16 )
+  #elif ( MACRO_DECODE == ENCODING_RGBM16 )
     return RGBM16ToLinear( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBD )  TODO
+  //#elif ( MACRO_DECODE == ENCODING_RGBD )  TODO
   //  return RGBMDToLinear( value );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
@@ -23,19 +23,19 @@
 
 #elif defined( MACRO_ENCODE )
 
-  #if ( MACRO_ENCODING_TYPE == ENCODING_Linear )
+  #if ( MACRO_ENCODE == ENCODING_Linear )
     return value;
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_sRGB )
+  #elif ( MACRO_ENCODE == ENCODING_sRGB )
     return LinearTosRGB( value );
-  #elif ( MACRO_ENCODING_TYPE == ENCODING_RGBE )
+  #elif ( MACRO_ENCODE == ENCODING_RGBE )
     return LinearToRGBE( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_LogLuv )  TODO
+  //#elif ( MACRO_ENCODE == ENCODING_LogLuv )  TODO
   //  return LinearToLogLuv( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM7 )  TODO
+  //#elif ( MACRO_ENCODE == ENCODING_RGBM7 )  TODO
   //  return LinearToRGBM7( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBM16 )  TODO
+  //#elif ( MACRO_ENCODE == ENCODING_RGBM16 )  TODO
   //  return LinearToRGBM16( value );
-  //#elif ( MACRO_ENCODING_TYPE == ENCODING_RGBD )  TODO
+  //#elif ( MACRO_ENCODE == ENCODING_RGBD )  TODO
   //  return LinearToRGBMD( value );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
diff --git a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
index 47619a82000911..bb24b40d9f1fb4 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
@@ -43,7 +43,7 @@
 		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );
 	#endif
 
-	envColor = EncodingToLinear( envColor, envMapEncoding );
+	envColor = envMapTexelToLinear( envColor );
 
 	#ifdef ENVMAP_BLENDING_MULTIPLY
 
diff --git a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
index ce777c5b5a1ffd..407b7c62edbf3a 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
@@ -10,7 +10,12 @@
 		uniform sampler2D envMap;
 	#endif
 	uniform float flipEnvMap;
-	uniform int envMapEncoding;
+
+	vec4 envMapTexelToLinear( vec4 texel ) {
+		#define DECODE_MACRO ENVMAP_ENCODING
+			#include "encoding_template.glsl"
+		#undef DECODE_MACRO
+	}
 
 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( STANDARD )
 
diff --git a/src/renderers/shaders/ShaderChunk/lights_pars.glsl b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
index 239633efce7c7f..cfd49e85110e96 100644
--- a/src/renderers/shaders/ShaderChunk/lights_pars.glsl
+++ b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
@@ -278,7 +278,7 @@
 
 		#endif
 
-		envMapColor.rgb = EncodingToLinear( envMapColor, envMapEncoding ).rgb;
+		envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
 
 		return envMapColor.rgb * envMapIntensity;
 
diff --git a/src/renderers/shaders/ShaderChunk/map_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
index e70f2cd9a1adb5..b5fb51b16c7ecf 100644
--- a/src/renderers/shaders/ShaderChunk/map_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_fragment.glsl
@@ -2,7 +2,7 @@
 
 	vec4 texelColor = texture2D( map, vUv );
 
-	texelColor = EncodingToLinear( texelColor, mapEncoding );
+	texelColor = mapTexelToLinear( texelColor );
 	diffuseColor *= texelColor;
 
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
index c3ecdae9fb20a3..ebe3153e65878f 100644
--- a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
@@ -1,6 +1,11 @@
 #ifdef USE_MAP
 
 	uniform sampler2D map;
-	uniform int mapEncoding;
+
+	vec4 mapTexelToLinear( vec4 texel ) {
+		#define DECODE_MACRO MAP_ENCODING
+			#include "encoding_template.glsl"
+		#undef DECODE_MACRO
+	}
 
 #endif
diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js
index a0fdd5b32b02e4..62fdcbf70dadf4 100644
--- a/src/renderers/webgl/WebGLProgram.js
+++ b/src/renderers/webgl/WebGLProgram.js
@@ -406,13 +406,16 @@ THREE.WebGLProgram = ( function () {
 				( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',
 
 				parameters.map ? '#define USE_MAP' : '',
+				parameters.mapEncoding ? '#define MAP_ENCODING ' + material.map.encoding : '',
 				parameters.envMap ? '#define USE_ENVMAP' : '',
 				parameters.envMap ? '#define ' + envMapTypeDefine : '',
 				parameters.envMap ? '#define ' + envMapModeDefine : '',
 				parameters.envMap ? '#define ' + envMapBlendingDefine : '',
+				parameters.envMapEncoding ? '#define ENVMAP_ENCODING ' + material.envMap.encoding : '',
 				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
 				parameters.aoMap ? '#define USE_AOMAP' : '',
 				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
+				parameters.emissiveMapEncoding ? '#define EMISSIVEMAP_ENCODING ' + material.emissiveMap.encoding : '',
 				parameters.bumpMap ? '#define USE_BUMPMAP' : '',
 				parameters.normalMap ? '#define USE_NORMALMAP' : '',
 				parameters.specularMap ? '#define USE_SPECULARMAP' : '',
diff --git a/src/renderers/webgl/WebGLPrograms.js b/src/renderers/webgl/WebGLPrograms.js
index ca8dfee78788ac..3b8443f2dfa387 100644
--- a/src/renderers/webgl/WebGLPrograms.js
+++ b/src/renderers/webgl/WebGLPrograms.js
@@ -15,8 +15,8 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 	};
 
 	var parameterNames = [
-		"precision", "supportsVertexTextures", "map", "envMap", "envMapMode",
-		"lightMap", "aoMap", "emissiveMap", "bumpMap", "normalMap", "displacementMap", "specularMap",
+		"precision", "supportsVertexTextures", "map", "mapEncoding", "envMap", "envMapMode", "envMapEncoding",
+		"lightMap", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "displacementMap", "specularMap",
 		"roughnessMap", "metalnessMap",
 		"alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp",
 		"flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning",
@@ -96,11 +96,14 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 			supportsVertexTextures: capabilities.vertexTextures,
 
 			map: !! material.map,
+			mapEncoding: ( !! material.map ) ? material.map.encoding : false,
 			envMap: !! material.envMap,
 			envMapMode: material.envMap && material.envMap.mapping,
+			envMapEncoding: ( !! material.envMap ) ? material.envMap.encoding : false,
 			lightMap: !! material.lightMap,
 			aoMap: !! material.aoMap,
 			emissiveMap: !! material.emissiveMap,
+			emissiveMapEncoding: ( !! material.emissiveMap ) ? material.emissiveMap.encoding : false,
 			bumpMap: !! material.bumpMap,
 			normalMap: !! material.normalMap,
 			displacementMap: !! material.displacementMap,

From 17d1b908f3243fd2ad6284233eeb8e9199e141b7 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 14:56:59 -0500
Subject: [PATCH 11/30] add preprocessor that by default uses the ShaderChunk
 library.

---
 src/renderers/webgl/WebGLProgram.js           |  2 +
 .../webgl/WebGLShaderPreProcessor.js          | 44 +++++++++++++++++++
 utils/build/includes/common.json              |  1 +
 3 files changed, 47 insertions(+)
 create mode 100644 src/renderers/webgl/WebGLShaderPreProcessor.js

diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js
index 62fdcbf70dadf4..946f0b0e2cfd41 100644
--- a/src/renderers/webgl/WebGLProgram.js
+++ b/src/renderers/webgl/WebGLProgram.js
@@ -460,6 +460,8 @@ THREE.WebGLProgram = ( function () {
 		var vertexGlsl = prefixVertex + vertexShader;
 		var fragmentGlsl = prefixFragment + fragmentShader;
 
+		vertexGlsl = THREE.WebGLShaderPreProcessor.compile( vertexGlsl );
+		fragmentGlsl = THREE.WebGLShaderPreProcessor.compile( fragmentGlsl );
 		// console.log( '*VERTEX*', vertexGlsl );
 		// console.log( '*FRAGMENT*', fragmentGlsl );
 
diff --git a/src/renderers/webgl/WebGLShaderPreProcessor.js b/src/renderers/webgl/WebGLShaderPreProcessor.js
new file mode 100644
index 00000000000000..0cc05e71d2a8bc
--- /dev/null
+++ b/src/renderers/webgl/WebGLShaderPreProcessor.js
@@ -0,0 +1,44 @@
+/**
+* @author bhouston / http://clara.io
+*/
+
+THREE.WebGLShaderPreProcessor = {};
+
+THREE.WebGLShaderPreProcessor.compile = function() {
+
+  var regexInclude = /[ ]*#include[ ]+["<]([\w\d.]*)[">]/;
+
+  return function( code, includeResolver ) {
+
+    includeResolver = includeResolver || THREE.WebGLShaderPreProcessor.defaultIncludeResolver;
+
+    var lines = code.split( '\n' );
+    var newLines = [];
+    while( lines.length > 0 ) {
+      var line = lines.shift();
+
+      var matcheInclude = regexInclude.exec(line);
+      if( matcheInclude ) {
+        var includeFileName = matcheInclude[1];
+        var includeChunk = includeResolver( includeFileName );
+        if( ! includeChunk ) throw new Error( "can not find include file for line: " + line );
+        var includeLines = includeChunk.split( '\n' ).reverse();
+        console.log( "#including " + includeFileName );
+        while( includeLines.length > 0 ) {
+          lines.unshift( includeLines.shift() );
+        }
+      }
+      else {
+        newLines.push( line );
+      }
+    }
+    return newLines.join( '\n' );
+  };
+
+}();
+
+THREE.WebGLShaderPreProcessor.defaultIncludeResolver = function( fileName ) {
+
+  return THREE.ShaderChunk[ fileName ];
+
+};
diff --git a/utils/build/includes/common.json b/utils/build/includes/common.json
index 2faa2f00b6c5ab..3fb1dea11b5c1b 100644
--- a/utils/build/includes/common.json
+++ b/utils/build/includes/common.json
@@ -209,6 +209,7 @@
 	"src/renderers/webgl/WebGLPrograms.js",
 	"src/renderers/webgl/WebGLProperties.js",
 	"src/renderers/webgl/WebGLShader.js",
+	"src/renderers/webgl/WebGLShaderPreProcessor.js",
 	"src/renderers/webgl/WebGLShadowMap.js",
 	"src/renderers/webgl/WebGLState.js",
 	"src/renderers/webgl/plugins/LensFlarePlugin.js",

From e3840079155113fe733739f1d8a4433c95d35ab8 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 15:01:53 -0500
Subject: [PATCH 12/30] remove THREE.DefaultEncoding and also old uniforms for
 encoding.

---
 src/Three.js                         | 1 -
 src/renderers/WebGLRenderer.js       | 5 -----
 src/renderers/shaders/UniformsLib.js | 3 ---
 src/textures/Texture.js              | 2 +-
 4 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/Three.js b/src/Three.js
index 39dd6277e3b426..298592f562faaf 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -315,4 +315,3 @@ THREE.RGBEEncoding = 3002; // AKA Radiance
 THREE.RGBM7Encoding = 3004;
 THREE.RGBM16Encoding = 3005;
 //THREE.RGBDEncoding = 3006; TODO
-THREE.DefaultEncoding = 3007; // Use sRGB or Linear as appropriate.
diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index e86a5686c5f683..2da2de0a3901c2 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -1888,7 +1888,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.map.value = material.map;
-		uniforms.mapEncoding.value = (( material.map && material.map.encoding !== THREE.DefaultEncoding ) ? material.map.encoding : THREE.LinearEncoding );
 		uniforms.specularMap.value = material.specularMap;
 		uniforms.alphaMap.value = material.alphaMap;
 
@@ -1963,7 +1962,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 		}
 
 		uniforms.envMap.value = material.envMap;
-		uniforms.envMapEncoding.value = (( material.envMap  && material.envMap.encoding !== THREE.DefaultEncoding )? material.envMap.encoding : THREE.LinearEncoding );
 		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
 
 		uniforms.reflectivity.value = material.reflectivity;
@@ -2035,7 +2033,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
@@ -2056,7 +2053,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
@@ -2111,7 +2107,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 		if ( material.emissiveMap ) {
 
 			uniforms.emissiveMap.value = material.emissiveMap;
-			uniforms.emissiveMapEncoding.value = ( material.emissiveMap.encoding !== THREE.DefaultEncoding ) ? material.emissiveMap.encoding : THREE.LinearEncoding;
 
 		}
 
diff --git a/src/renderers/shaders/UniformsLib.js b/src/renderers/shaders/UniformsLib.js
index e0e925bc1a8093..7109bf13ec4e15 100644
--- a/src/renderers/shaders/UniformsLib.js
+++ b/src/renderers/shaders/UniformsLib.js
@@ -10,14 +10,12 @@ THREE.UniformsLib = {
 		"opacity": { type: "f", value: 1.0 },
 
 		"map": { type: "t", value: null },
-		"mapEncoding" : { type: "i", value: THREE.sRGBEncoding },
 		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
 
 		"specularMap": { type: "t", value: null },
 		"alphaMap": { type: "t", value: null },
 
 		"envMap": { type: "t", value: null },
-		"envMapEncoding" : { type: "i", value: THREE.LinearEncoding },
 		"flipEnvMap": { type: "f", value: - 1 },
 		"reflectivity": { type: "f", value: 1.0 },
 		"refractionRatio": { type: "f", value: 0.98 }
@@ -41,7 +39,6 @@ THREE.UniformsLib = {
 	emissivemap: {
 
 		"emissiveMap": { type: "t", value: null },
-		"emissiveMapEncoding": { type: "i", value: THREE.LinearEncoding }
 
 	},
 
diff --git a/src/textures/Texture.js b/src/textures/Texture.js
index fe0fa4944b5283..e619fad8ed6c6e 100644
--- a/src/textures/Texture.js
+++ b/src/textures/Texture.js
@@ -36,7 +36,7 @@ THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, f
 	this.premultiplyAlpha = false;
 	this.flipY = true;
 	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
-	this.encoding = THREE.DefaultEncoding;	// Values !== THREE.LinearEncoding only supported on map, envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
+	this.encoding = THREE.LinearEncoding;	// Values !== THREE.LinearEncoding only supported on map, envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
 
 	this.version = 0;
 	this.onUpdate = null;

From 57432f03de3c8de2fb55784f5d3074ade34d6266 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 15:02:04 -0500
Subject: [PATCH 13/30] get macros for encodings working.

---
 .../shaders/ShaderChunk/emissivemap_pars_fragment.glsl    | 6 +++---
 src/renderers/shaders/ShaderChunk/encodings.glsl          | 3 ++-
 .../shaders/ShaderChunk/envmap_pars_fragment.glsl         | 8 ++++----
 src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl  | 8 ++++----
 src/renderers/shaders/ShaderLib.js                        | 6 +++---
 5 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
index 6c60f2f140414a..8a47f2fe7ed71d 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
@@ -2,10 +2,10 @@
 
 	uniform sampler2D emissiveMap;
 
-	vec4 emissiveMapTexelToLinear( vec4 texel ) {
+	vec4 emissiveMapTexelToLinear( vec4 value ) {
 		#define DECODE_MACRO EMISSIVEMAP_ENCODING
-			#include "encoding_template.glsl"
-		#undef DECODE_MACRO
+			#include <encoding_template>
+		#undef MACRO_DECODE
 	}
 
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index e74e1b80d18ac7..49bef8cd40b11e 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -38,7 +38,7 @@ vec4 LinearToRGBE( in vec4 value ) {
   float fExp = ceil( log2(maxComponent) );
   return vec4( value.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
 }
-
+/*
 vec4 EncodingToLinear( in vec4 value, in int fromEncoding ) {
 
   switch( fromEncoding ) {
@@ -102,3 +102,4 @@ vec4 LinearToEncoding( in vec4 value, in int toEncoding )
   }
 
 }
+*/
diff --git a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
index 407b7c62edbf3a..cbfa4548ea4463 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
@@ -11,10 +11,10 @@
 	#endif
 	uniform float flipEnvMap;
 
-	vec4 envMapTexelToLinear( vec4 texel ) {
-		#define DECODE_MACRO ENVMAP_ENCODING
-			#include "encoding_template.glsl"
-		#undef DECODE_MACRO
+	vec4 envMapTexelToLinear( vec4 value ) {
+		#define MACRO_DECODE ENVMAP_ENCODING
+			#include <encoding_template>
+		#undef MACRO_DECODE
 	}
 
 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( STANDARD )
diff --git a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
index ebe3153e65878f..5705d3b8f5043b 100644
--- a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
@@ -2,10 +2,10 @@
 
 	uniform sampler2D map;
 
-	vec4 mapTexelToLinear( vec4 texel ) {
-		#define DECODE_MACRO MAP_ENCODING
-			#include "encoding_template.glsl"
-		#undef DECODE_MACRO
+	vec4 mapTexelToLinear( vec4 value ) {
+		#define MACRO_DECODE MAP_ENCODING
+			#include <encoding_template>
+		#undef MACRO_DECODE
 	}
 
 #endif
diff --git a/src/renderers/shaders/ShaderLib.js b/src/renderers/shaders/ShaderLib.js
index 44e85262a286a7..9ba1139e8e77d6 100644
--- a/src/renderers/shaders/ShaderLib.js
+++ b/src/renderers/shaders/ShaderLib.js
@@ -204,6 +204,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],
 			THREE.ShaderChunk[ "uv2_pars_fragment" ],
@@ -214,7 +215,6 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "emissivemap_pars_fragment" ],
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
-			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
@@ -369,6 +369,7 @@ THREE.ShaderLib = {
 			"uniform float opacity;",
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],
 			THREE.ShaderChunk[ "uv2_pars_fragment" ],
@@ -380,7 +381,6 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
-			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "lights_phong_pars_fragment" ],
@@ -533,6 +533,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],
 			THREE.ShaderChunk[ "uv2_pars_fragment" ],
@@ -544,7 +545,6 @@ THREE.ShaderLib = {
 			THREE.ShaderChunk[ "envmap_pars_fragment" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],
 			THREE.ShaderChunk[ "bsdfs" ],
-			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "ambient_pars" ],
 			THREE.ShaderChunk[ "lights_pars" ],
 			THREE.ShaderChunk[ "lights_standard_pars_fragment" ],

From 84b70fd4ed28e935ed07d67b69096261458cc9d8 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 15:04:32 -0500
Subject: [PATCH 14/30] cleanup PR.

---
 src/renderers/shaders/ShaderChunk/lights_pars.glsl | 2 +-
 src/renderers/webgl/WebGLShaderPreProcessor.js     | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/lights_pars.glsl b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
index cfd49e85110e96..cf706afad60e07 100644
--- a/src/renderers/shaders/ShaderChunk/lights_pars.glsl
+++ b/src/renderers/shaders/ShaderChunk/lights_pars.glsl
@@ -186,7 +186,7 @@
 
 		#endif
 
-		envMapColor.rgb = EncodingToLinear( envMapColor, envMapEncoding ).rgb;
+		envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
 
 		return PI * envMapColor.rgb * envMapIntensity;
 
diff --git a/src/renderers/webgl/WebGLShaderPreProcessor.js b/src/renderers/webgl/WebGLShaderPreProcessor.js
index 0cc05e71d2a8bc..4588ccb0a79ece 100644
--- a/src/renderers/webgl/WebGLShaderPreProcessor.js
+++ b/src/renderers/webgl/WebGLShaderPreProcessor.js
@@ -23,7 +23,6 @@ THREE.WebGLShaderPreProcessor.compile = function() {
         var includeChunk = includeResolver( includeFileName );
         if( ! includeChunk ) throw new Error( "can not find include file for line: " + line );
         var includeLines = includeChunk.split( '\n' ).reverse();
-        console.log( "#including " + includeFileName );
         while( includeLines.length > 0 ) {
           lines.unshift( includeLines.shift() );
         }

From a4c5926c3454790826dcd2a6f815523ca2f5e958 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 15:13:46 -0500
Subject: [PATCH 15/30] remove unused encoding functions.

---
 .../shaders/ShaderChunk/encodings.glsl        | 65 -------------------
 1 file changed, 65 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 49bef8cd40b11e..ae1cef4249333c 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -38,68 +38,3 @@ vec4 LinearToRGBE( in vec4 value ) {
   float fExp = ceil( log2(maxComponent) );
   return vec4( value.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
 }
-/*
-vec4 EncodingToLinear( in vec4 value, in int fromEncoding ) {
-
-  switch( fromEncoding ) {
-
-    case ENCODING_Linear:
-      return value;
-
-    case ENCODING_sRGB:
-      return LinearTosRGB( value );
-
-    //case ENCODING_LogLuv:
-    //  return LinearToLogLuv( value );
-
-    case ENCODING_RGBE:
-      return LinearToRGBE( value );
-
-    case ENCODING_RGBM7:
-      return LinearToRGBM7( value );
-
-    case ENCODING_RGBM16:
-      return LinearToRGBM16( value );
-
-    //case ENCODING_RGBD:
-    //  return LinearToRGBD( value );
-
-    default:
-      return vec4( 1.0, 0.0, 0.0, 1.0 );
-
-  }
-
-}
-
-vec4 LinearToEncoding( in vec4 value, in int toEncoding )
-{
-  switch( toEncoding ) {
-
-    case ENCODING_Linear:
-      return value;
-
-    case ENCODING_sRGB:
-      return sRGBToLinear( value );
-
-    //case ENCODING_LogLuv:
-    //  return LogLuvToLinear( value );
-
-    case ENCODING_RGBE:
-      return RGBEToLinear( value );
-
-    //case ENCODING_RGBM7:
-    //  return RGBM7ToLinear( value );
-
-    //case ENCODING_RGBM16:
-    //  return RGBM16ToLinear( value );
-
-    //case ENCODING_RGBD:
-    //  return RGBDToLinear( value );
-
-    default:
-      return vec4( 1.0, 0.0, 0.0, 1.0 );
-
-  }
-
-}
-*/

From 0951f9615303ddd7c1fdab4bebec35d0104df9c5 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 15:18:32 -0500
Subject: [PATCH 16/30] simplify preprocessor, no need for reserve if I use
 pop.

---
 src/renderers/webgl/WebGLShaderPreProcessor.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderers/webgl/WebGLShaderPreProcessor.js b/src/renderers/webgl/WebGLShaderPreProcessor.js
index 4588ccb0a79ece..1a25ef4302654e 100644
--- a/src/renderers/webgl/WebGLShaderPreProcessor.js
+++ b/src/renderers/webgl/WebGLShaderPreProcessor.js
@@ -22,9 +22,9 @@ THREE.WebGLShaderPreProcessor.compile = function() {
         var includeFileName = matcheInclude[1];
         var includeChunk = includeResolver( includeFileName );
         if( ! includeChunk ) throw new Error( "can not find include file for line: " + line );
-        var includeLines = includeChunk.split( '\n' ).reverse();
+        var includeLines = includeChunk.split( '\n' );
         while( includeLines.length > 0 ) {
-          lines.unshift( includeLines.shift() );
+          lines.unshift( includeLines.pop() );
         }
       }
       else {

From 7ea1c679b30ff6b4117ae62e938121382b462d86 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 21:49:06 -0500
Subject: [PATCH 17/30] fix bug with regards to emissiveMapTexelToLinear...

---
 .../shaders/ShaderChunk/emissivemap_pars_fragment.glsl          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
index 8a47f2fe7ed71d..1abf5f2ffef78f 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
@@ -3,7 +3,7 @@
 	uniform sampler2D emissiveMap;
 
 	vec4 emissiveMapTexelToLinear( vec4 value ) {
-		#define DECODE_MACRO EMISSIVEMAP_ENCODING
+		#define MACRO_DECODE EMISSIVEMAP_ENCODING
 			#include <encoding_template>
 		#undef MACRO_DECODE
 	}

From af4929ea089b72e0b96dd8a677b44ce377714620 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 22:21:41 -0500
Subject: [PATCH 18/30] fill in the LogLuv, RGBM, and RGBD decoders/encoders.

---
 src/Three.js                                  |  4 +-
 .../ShaderChunk/encoding_template.glsl        | 28 ++++----
 .../shaders/ShaderChunk/encodings.glsl        | 69 +++++++++++++++----
 3 files changed, 73 insertions(+), 28 deletions(-)

diff --git a/src/Three.js b/src/Three.js
index 298592f562faaf..1725e60449a01c 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -311,7 +311,7 @@ THREE.TriangleFanDrawMode = 2;
 THREE.LinearEncoding = 3000; // No encoding at all.
 THREE.sRGBEncoding = 3001; // AKA gamma 2.2.
 THREE.RGBEEncoding = 3002; // AKA Radiance
-//THREE.LogLuvEncoding = 3003; TODO
+THREE.LogLuvEncoding = 3003;
 THREE.RGBM7Encoding = 3004;
 THREE.RGBM16Encoding = 3005;
-//THREE.RGBDEncoding = 3006; TODO
+THREE.RGBDEncoding = 3006; // MaxRange is 256
diff --git a/src/renderers/shaders/ShaderChunk/encoding_template.glsl b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
index 553c117122f2f7..5c05fa65fd5a41 100644
--- a/src/renderers/shaders/ShaderChunk/encoding_template.glsl
+++ b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
@@ -9,14 +9,14 @@
     return sRGBToLinear( value );
   #elif ( MACRO_DECODE == ENCODING_RGBE )
     return RGBEToLinear( value );
-  //#elif ( MACRO_DECODE == ENCODING_LogLuv )  TODO
-  //  return LogLuvToLinear( value );
+  #elif ( MACRO_DECODE == ENCODING_LogLuv )
+    return LogLuvToLinear( value );
   #elif ( MACRO_DECODE == ENCODING_RGBM7 )
-    return RGBM7ToLinear( value );
+    return RGBMToLinear( value, 7.0 );
   #elif ( MACRO_DECODE == ENCODING_RGBM16 )
-    return RGBM16ToLinear( value );
-  //#elif ( MACRO_DECODE == ENCODING_RGBD )  TODO
-  //  return RGBMDToLinear( value );
+    return RGBMToLinear( value, 16.0 );
+  #elif ( MACRO_DECODE == ENCODING_RGBD )
+    return RGBDToLinear( value, 256.0 );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
   #endif
@@ -29,14 +29,14 @@
     return LinearTosRGB( value );
   #elif ( MACRO_ENCODE == ENCODING_RGBE )
     return LinearToRGBE( value );
-  //#elif ( MACRO_ENCODE == ENCODING_LogLuv )  TODO
-  //  return LinearToLogLuv( value );
-  //#elif ( MACRO_ENCODE == ENCODING_RGBM7 )  TODO
-  //  return LinearToRGBM7( value );
-  //#elif ( MACRO_ENCODE == ENCODING_RGBM16 )  TODO
-  //  return LinearToRGBM16( value );
-  //#elif ( MACRO_ENCODE == ENCODING_RGBD )  TODO
-  //  return LinearToRGBMD( value );
+  #elif ( MACRO_ENCODE == ENCODING_LogLuv )
+    return LinearToLogLuv( value );
+  #elif ( MACRO_ENCODE == ENCODING_RGBM7 )
+    return LinearToRGBM( value, 7.0 );
+  #elif ( MACRO_ENCODE == ENCODING_RGBM16 )
+    return LinearToRGBM( value, 16.0 );
+  #elif ( MACRO_ENCODE == ENCODING_RGBD )
+    return LinearToRGBD( value, 256.0 );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
   #endif
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index ae1cef4249333c..677edf3c0a6cf9 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -4,10 +4,10 @@
 #define ENCODING_Linear 3000
 #define ENCODING_sRGB   3001
 #define ENCODING_RGBE   3002
-//#define ENCODING_LogLuv 3003
+#define ENCODING_LogLuv 3003
 #define ENCODING_RGBM7  3004
 #define ENCODING_RGBM16 3005
-//#define ENCODING_RGBM16 3007
+#define ENCODING_RGBD   3006
 
 vec4 LinearToLinear( in vec4 value ) {
   return value;
@@ -16,25 +16,70 @@ vec4 LinearToLinear( in vec4 value ) {
 vec4 sRGBToLinear( in vec4 value ) {
   return vec4( pow( value.xyz, vec3( float( GAMMA_FACTOR ) ) ), value.w );
 }
+vec4 LinearTosRGB( in vec4 value ) {
+  return vec4( pow( value.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), value.w );
+}
 
 vec4 RGBEToLinear( in vec4 value ) {
   return vec4( value.xyz * exp2( value.w*256.0 - 128.0 ), 1.0 );
 }
+vec4 LinearToRGBE( in vec4 value ) {
+  float maxComponent = max(max(value.r, value.g), value.b );
+  float fExp = ceil( log2(maxComponent) );
+  return vec4( value.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
+}
 
-vec4 RGBM7ToLinear( in vec4 value ) {
-  return vec4( value.xyz * value.w * 7.0, 1.0 );
+// reference: http://iwasbeingirony.blogspot.ca/2010/06/difference-between-rgbm-and-rgbd.html
+vec4 RGBMToLinear( in vec4 value, in float maxRange ) {
+  return vec4( value.xyz * value.w * maxRange, 1.0 );
+}
+vec4 LinearToRGBM( in vec4 value, in float maxRange ) {
+  float maxRGB = max( value.x, max( value.g, value.b ) );
+  float M      = maxRGB / maxRange;
+  M            = ceil( M * 255.0 ) / 255.0;
+  return vec4( value.rgb / ( M * maxRange ), M );
 }
 
-vec4 RGBM16ToLinear( in vec4 value ) {
-  return vec4( value.xyz * value.w * 16.0, 1.0 );
+// reference: http://iwasbeingirony.blogspot.ca/2010/06/difference-between-rgbm-and-rgbd.html
+vec4 RGBDToLinear( in vec4 value, in float maxRange ) {
+    return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );
+}
+vec4 LinearToRGBD( in vec4 value, in float maxRange ) {
+    float maxRGB = max( value.x, max( value.g, value.b ) );
+    float D      = max( maxRange / maxRGB, 1.0 );
+    D            = saturate( floor( D ) / 255.0 );
+    return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );
 }
 
-vec4 LinearTosRGB( in vec4 value ) {
-  return vec4( pow( value.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), value.w );
+// LogLuv reference: http://graphicrants.blogspot.ca/2009/04/rgbm-color-encoding.html
+
+// M matrix, for encoding
+const mat3 cLogLuvM = mat3(
+  0.2209, 0.3390, 0.4184,
+  0.1138, 0.6780, 0.7319,
+  0.0102, 0.1130, 0.2969);
+vec4 LinearToLogLuv( in vec4 value )  {
+  vec3 Xp_Y_XYZp = value.rgb * cLogLuvM;
+  Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));
+  vec4 vResult;
+  vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;
+  float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;
+  vResult.w = fract(Le);
+  vResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;
+  return vResult;
 }
 
-vec4 LinearToRGBE( in vec4 value ) {
-  float maxComponent = max(max(value.r, value.g), value.b );
-  float fExp = ceil( log2(maxComponent) );
-  return vec4( value.rgb / exp2(fExp), (fExp + 128.0) / 255.0 );
+// Inverse M matrix, for decoding
+const mat3 cLogLuvInverseM = mat3(
+  6.0014, -2.7008, -1.7996,
+  -1.3320,  3.1029, -5.7721,
+  0.3008, -1.0882,  5.6268);
+vec4 LogLuvToLinear( in vec4 value ) {
+  float Le = value.z * 255.0 + value.w;
+  vec3 Xp_Y_XYZp;
+  Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);
+  Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;
+  Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;
+  vec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;
+  return vec4( max(vRGB, 0.0), 1.0 );
 }

From 52bf6c6e970ec3f6a01e602bae46bb82354ec8a1 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sat, 20 Feb 2016 22:34:05 -0500
Subject: [PATCH 19/30] ensure that particles also use map encodings.

---
 .../shaders/ShaderChunk/map_particle_fragment.glsl          | 5 +++--
 .../shaders/ShaderChunk/map_particle_pars_fragment.glsl     | 6 ++++++
 src/renderers/shaders/ShaderLib.js                          | 2 ++
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl
index 1bc3cbe59852ef..166b5ec30d4b41 100644
--- a/src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl
@@ -1,5 +1,6 @@
 #ifdef USE_MAP
 
-	diffuseColor *= texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );
-
+	vec4 mapTexel= texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );
+	diffuseColor *= mapTexelToLinear( mapTexel );
+	
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
index cc3c236659a05a..cc507c3e064409 100644
--- a/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
@@ -2,5 +2,11 @@
 
 	uniform vec4 offsetRepeat;
 	uniform sampler2D map;
+	
+	vec4 mapTexelToLinear( vec4 value ) {
+		#define MACRO_DECODE MAP_ENCODING
+			#include <encoding_template>
+		#undef MACRO_DECODE
+	}
 
 #endif
diff --git a/src/renderers/shaders/ShaderLib.js b/src/renderers/shaders/ShaderLib.js
index e88ca680249c2f..c9eb5686c5dd05 100644
--- a/src/renderers/shaders/ShaderLib.js
+++ b/src/renderers/shaders/ShaderLib.js
@@ -22,6 +22,7 @@ THREE.ShaderLib = {
 		vertexShader: [
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "uv_pars_vertex" ],
 			THREE.ShaderChunk[ "uv2_pars_vertex" ],
 			THREE.ShaderChunk[ "envmap_pars_vertex" ],
@@ -635,6 +636,7 @@ THREE.ShaderLib = {
 			"uniform float opacity;",
 
 			THREE.ShaderChunk[ "common" ],
+			THREE.ShaderChunk[ "encodings" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "map_particle_pars_fragment" ],
 			THREE.ShaderChunk[ "fog_pars_fragment" ],

From 15311e6b8f67ae37f5e5edd98be7506a7049b82a Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sun, 21 Feb 2016 21:33:59 -0500
Subject: [PATCH 20/30] add true sRGB support for texture.encodings.

---
 src/Three.js                                  |  3 ++-
 .../ShaderChunk/encoding_template.glsl        |  4 ++++
 .../shaders/ShaderChunk/encodings.glsl        | 19 +++++++++++++++++--
 3 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/src/Three.js b/src/Three.js
index 1725e60449a01c..1345fa28922125 100644
--- a/src/Three.js
+++ b/src/Three.js
@@ -309,9 +309,10 @@ THREE.TriangleFanDrawMode = 2;
 // Texture Encodings
 
 THREE.LinearEncoding = 3000; // No encoding at all.
-THREE.sRGBEncoding = 3001; // AKA gamma 2.2.
+THREE.sRGBEncoding = 3001;
 THREE.RGBEEncoding = 3002; // AKA Radiance
 THREE.LogLuvEncoding = 3003;
 THREE.RGBM7Encoding = 3004;
 THREE.RGBM16Encoding = 3005;
 THREE.RGBDEncoding = 3006; // MaxRange is 256
+THREE.GammaEncoding = 3007; // uses GAMMA_FACTOR
diff --git a/src/renderers/shaders/ShaderChunk/encoding_template.glsl b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
index 5c05fa65fd5a41..095d04188eb410 100644
--- a/src/renderers/shaders/ShaderChunk/encoding_template.glsl
+++ b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
@@ -17,6 +17,8 @@
     return RGBMToLinear( value, 16.0 );
   #elif ( MACRO_DECODE == ENCODING_RGBD )
     return RGBDToLinear( value, 256.0 );
+  #elif ( MACRO_DECODE == ENCODING_Gamma )
+      return GammaToLinear( value, float( GAMMA_FACTOR ) );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
   #endif
@@ -37,6 +39,8 @@
     return LinearToRGBM( value, 16.0 );
   #elif ( MACRO_ENCODE == ENCODING_RGBD )
     return LinearToRGBD( value, 256.0 );
+  #elif ( MACRO_ENCODE == ENCODING_Gamma )
+    return LinearToGamma( value, float( GAMMA_FACTOR ) );
   #else
     return vec4( 1.0, 0.0, 0.0, 1.0 );
   #endif
diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 677edf3c0a6cf9..853f5f40c701a1 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -8,16 +8,31 @@
 #define ENCODING_RGBM7  3004
 #define ENCODING_RGBM16 3005
 #define ENCODING_RGBD   3006
+#define ENCODING_Gamma  3007
 
 vec4 LinearToLinear( in vec4 value ) {
   return value;
 }
 
+vec4 GammaToLinear( in vec4 value, in float gammaFactor ) {
+  return vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );
+}
+vec4 LinearTosGamma( in vec4 value, in float gammaFactor ) {
+  return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );
+}
+
+float sRGBToLinear_Component( float c ) {
+    return ( c <= 0.04045 ) ? ( c * 0.0773993808 ) : pow( c * 0.9478672986 + 0.0521327014, 2.4 );
+}
+float LinearTosRGB_Component( float c ) {
+    return ( c <= 0.0031308 ) ? ( c * 12.92 ) : ( pow( c, 0.41666 ) - 0.055 );
+}
+
 vec4 sRGBToLinear( in vec4 value ) {
-  return vec4( pow( value.xyz, vec3( float( GAMMA_FACTOR ) ) ), value.w );
+  return vec4( sRGBToLinear_Component( value.r ), sRGBToLinear_Component( value.g ), sRGBToLinear_Component( value.b ), value.w );
 }
 vec4 LinearTosRGB( in vec4 value ) {
-  return vec4( pow( value.xyz, vec3( 1.0 / float( GAMMA_FACTOR ) ) ), value.w );
+  return vec4( LinearTosRGB_Component( value.r ), LinearTosRGB_Component( value.g ), LinearTosRGB_Component( value.b ), value.w );
 }
 
 vec4 RGBEToLinear( in vec4 value ) {

From bdcb83ab28b8eecb443d71144ebe13e5d19a03c2 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sun, 21 Feb 2016 21:41:17 -0500
Subject: [PATCH 21/30] try hand at using bvec3 with mix for optimizing sRGB
 linearization.

---
 src/renderers/shaders/ShaderChunk/encodings.glsl | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index 853f5f40c701a1..e06120dc1cb981 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -21,18 +21,11 @@ vec4 LinearTosGamma( in vec4 value, in float gammaFactor ) {
   return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );
 }
 
-float sRGBToLinear_Component( float c ) {
-    return ( c <= 0.04045 ) ? ( c * 0.0773993808 ) : pow( c * 0.9478672986 + 0.0521327014, 2.4 );
-}
-float LinearTosRGB_Component( float c ) {
-    return ( c <= 0.0031308 ) ? ( c * 12.92 ) : ( pow( c, 0.41666 ) - 0.055 );
-}
-
 vec4 sRGBToLinear( in vec4 value ) {
-  return vec4( sRGBToLinear_Component( value.r ), sRGBToLinear_Component( value.g ), sRGBToLinear_Component( value.b ), value.w );
+  return vec4( mix( value.rgb * 0.0773993808, pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), lessThanEqual( value.rgb, vec3( 0.04045 ) ) ), value.w );
 }
 vec4 LinearTosRGB( in vec4 value ) {
-  return vec4( LinearTosRGB_Component( value.r ), LinearTosRGB_Component( value.g ), LinearTosRGB_Component( value.b ), value.w );
+  return vec4( mix( value.rgb * 12.92, pow( value.rgb, vec3( 0.41666 ) ) - vec3( 0.055 ), lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ), value.w );
 }
 
 vec4 RGBEToLinear( in vec4 value ) {

From b34070b0318ea577c0f09eb0164ff1ae4ebf01de Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Sun, 21 Feb 2016 21:48:36 -0500
Subject: [PATCH 22/30] fix order bug with mix-bvec3

---
 src/renderers/shaders/ShaderChunk/encodings.glsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index e06120dc1cb981..bada7e39649b5d 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -22,10 +22,10 @@ vec4 LinearTosGamma( in vec4 value, in float gammaFactor ) {
 }
 
 vec4 sRGBToLinear( in vec4 value ) {
-  return vec4( mix( value.rgb * 0.0773993808, pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), lessThanEqual( value.rgb, vec3( 0.04045 ) ) ), value.w );
+  return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, lessThanEqual( value.rgb, vec3( 0.04045 ) ) ), value.w );
 }
 vec4 LinearTosRGB( in vec4 value ) {
-  return vec4( mix( value.rgb * 12.92, pow( value.rgb, vec3( 0.41666 ) ) - vec3( 0.055 ), lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ), value.w );
+  return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) - vec3( 0.055 ), value.rgb * 12.92, lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ), value.w );
 }
 
 vec4 RGBEToLinear( in vec4 value ) {

From e204686e9d6e428c340deab12338495537cfb64f Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Mon, 22 Feb 2016 13:07:56 -0500
Subject: [PATCH 23/30] cast bvec3 to vec3 so that mix works.

---
 src/renderers/shaders/ShaderChunk/encodings.glsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl
index bada7e39649b5d..3a4ef0471e0d3f 100644
--- a/src/renderers/shaders/ShaderChunk/encodings.glsl
+++ b/src/renderers/shaders/ShaderChunk/encodings.glsl
@@ -22,10 +22,10 @@ vec4 LinearTosGamma( in vec4 value, in float gammaFactor ) {
 }
 
 vec4 sRGBToLinear( in vec4 value ) {
-  return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, lessThanEqual( value.rgb, vec3( 0.04045 ) ) ), value.w );
+  return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );
 }
 vec4 LinearTosRGB( in vec4 value ) {
-  return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) - vec3( 0.055 ), value.rgb * 12.92, lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ), value.w );
+  return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );
 }
 
 vec4 RGBEToLinear( in vec4 value ) {

From bc0d71431e9a979926bd01d57cfee8ec28c6b59f Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Tue, 23 Feb 2016 11:03:48 -0500
Subject: [PATCH 24/30] add better documentation that MAterial.needsUpdate
 needs to be set if one changes Texture.encoding.

---
 src/textures/Texture.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/textures/Texture.js b/src/textures/Texture.js
index e619fad8ed6c6e..e99e97c0f98f85 100644
--- a/src/textures/Texture.js
+++ b/src/textures/Texture.js
@@ -36,7 +36,13 @@ THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, f
 	this.premultiplyAlpha = false;
 	this.flipY = true;
 	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
-	this.encoding = THREE.LinearEncoding;	// Values !== THREE.LinearEncoding only supported on map, envMap and emissiveMap (as these maps regularly have unbounded intensity values, i.e. via an *.hdr or *.exr image.)
+
+
+	// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
+	//
+	// Also changing the encoding after already used by a Material will not automatically make the Material
+	// update.  You need to explicitly call Material.needsUpdate to trigger it to recompile.
+	this.encoding = THREE.LinearEncoding;
 
 	this.version = 0;
 	this.onUpdate = null;

From f52454cd75246c0cfed5616ef6dd72d95438dd7f Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Tue, 23 Feb 2016 11:10:10 -0500
Subject: [PATCH 25/30] add comment in docs.

---
 docs/api/textures/Texture.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/docs/api/textures/Texture.html b/docs/api/textures/Texture.html
index 2cb7f85963ead9..1ec2e2c791f416 100644
--- a/docs/api/textures/Texture.html
+++ b/docs/api/textures/Texture.html
@@ -128,6 +128,11 @@ <h3>[property:boolean premultiplyAlpha]</h3>
 		False by default, which is the norm for PNG images. Set to true if the RGB values have been stored premultiplied by alpha.
 		</div>
 
+		<h3>[property:number encoding]</h3>
+		<div>
+		Set to THREE.LinearEncoding by default, but supports sRGB, RGBE, RGBM, RGBD, LogLuv and Gamma corrected encodings.  IMPORTANT: If this value is changed on a texture after the material has been used, it is necessary to trigger a Material.needsUpdate for this value to be realized in the shader.
+		</div>
+
 		<h3>[property:object onUpdate]</h3>
 		<div>
 		A callback function, called when the texture is updated (e.g., when needsUpdate has been set to true and then the texture is used).

From 4cc3052dec31c51f0475cc12ba9cd740a4c91387 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Wed, 24 Feb 2016 07:47:10 -0500
Subject: [PATCH 26/30] start addressing @mrdoob's feedback here:
 https://github.com/mrdoob/three.js/pull/8117/files#r53900857

---
 src/renderers/webgl/WebGLProgram.js | 42 +++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js
index 946f0b0e2cfd41..ba73dd38294ed0 100644
--- a/src/renderers/webgl/WebGLProgram.js
+++ b/src/renderers/webgl/WebGLProgram.js
@@ -7,6 +7,48 @@ THREE.WebGLProgram = ( function () {
 	var arrayStructRe = /^([\w\d_]+)\[(\d+)\]\.([\w\d_]+)$/;
 	var arrayRe = /^([\w\d_]+)\[0\]$/;
 
+	function getTexelDecodingMacro( encoding ) {
+		switch( encoding ) {
+			case THREE.LinearEncoding:
+				return "(value)";
+			case THREE.sRGBEncoding:
+				return "sRGBToLinear( value )";
+			case THREE.RGBEEncoding:
+				return "RGBEToLinear( value )";
+			case THREE.RGBM7Encoding:
+				return "RGBMToLinear( value, 7.0 )";
+			case THREE.RGBM16Encoding:
+				return "RGBMToLinear( value, 16.0 )";
+			case THREE.RGBDEncoding:
+				return "RGBDToLinear( value, 256.0 )";
+			case THREE.GammaEncoding:
+				return "GammaToLinear( value, float( GAMMA_FACTOR ) )";
+			default:
+			 throw new Error( "unsupported encoding: " + encoding );
+		}
+	}
+
+	function getTexelEncodingMacro( encoding ) {
+		switch( encoding ) {
+			case THREE.LinearEncoding:
+				return "(value)";
+			case THREE.sRGBEncoding:
+				return "LinearTosRGB( value )";
+			case THREE.RGBEEncoding:
+				return "LinearToRGBE( value )";
+			case THREE.RGBM7Encoding:
+				return "LinearToRGBM( value, 7.0 )";
+			case THREE.RGBM16Encoding:
+				return "LinearToRGBM( value, 16.0 )";
+			case THREE.RGBDEncoding:
+				return "LinearToRGBD( value, 256.0 )";
+			case THREE.GammaEncoding:
+				return "LinearToGamma( value, float( GAMMA_FACTOR ) )";
+			default:
+			 throw new Error( "unsupported encoding: " + encoding );
+		}
+	}
+
 	function generateExtensions( extensions, parameters, rendererExtensions ) {
 
 		extensions = extensions || {};

From 653a2787ce99ac450f1641d0016a13255571f399 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Wed, 24 Feb 2016 08:05:36 -0500
Subject: [PATCH 27/30] remove encoding_template and WebGLShaderPrePRocessor as
 mrdoob has rewritten it.

---
 .../emissivemap_pars_fragment.glsl            |  6 ---
 .../ShaderChunk/encoding_template.glsl        | 48 -----------------
 .../ShaderChunk/map_pars_fragment.glsl        |  6 ---
 .../map_particle_pars_fragment.glsl           |  6 ---
 src/renderers/webgl/WebGLProgram.js           | 54 ++++++++-----------
 .../webgl/WebGLShaderPreProcessor.js          | 43 ---------------
 utils/build/includes/common.json              |  2 -
 7 files changed, 21 insertions(+), 144 deletions(-)
 delete mode 100644 src/renderers/shaders/ShaderChunk/encoding_template.glsl
 delete mode 100644 src/renderers/webgl/WebGLShaderPreProcessor.js

diff --git a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
index 1abf5f2ffef78f..c05bb7f55180a0 100644
--- a/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
@@ -2,10 +2,4 @@
 
 	uniform sampler2D emissiveMap;
 
-	vec4 emissiveMapTexelToLinear( vec4 value ) {
-		#define MACRO_DECODE EMISSIVEMAP_ENCODING
-			#include <encoding_template>
-		#undef MACRO_DECODE
-	}
-
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/encoding_template.glsl b/src/renderers/shaders/ShaderChunk/encoding_template.glsl
deleted file mode 100644
index 095d04188eb410..00000000000000
--- a/src/renderers/shaders/ShaderChunk/encoding_template.glsl
+++ /dev/null
@@ -1,48 +0,0 @@
-// this is intended to be the body of a macro.  Define the name of the function,
-// set the defines and then include this glsl snippet to define its body.
-
-#if defined( MACRO_DECODE )
-
-  #if ( MACRO_DECODE == ENCODING_Linear )
-    return value;
-  #elif ( MACRO_DECODE == ENCODING_sRGB )
-    return sRGBToLinear( value );
-  #elif ( MACRO_DECODE == ENCODING_RGBE )
-    return RGBEToLinear( value );
-  #elif ( MACRO_DECODE == ENCODING_LogLuv )
-    return LogLuvToLinear( value );
-  #elif ( MACRO_DECODE == ENCODING_RGBM7 )
-    return RGBMToLinear( value, 7.0 );
-  #elif ( MACRO_DECODE == ENCODING_RGBM16 )
-    return RGBMToLinear( value, 16.0 );
-  #elif ( MACRO_DECODE == ENCODING_RGBD )
-    return RGBDToLinear( value, 256.0 );
-  #elif ( MACRO_DECODE == ENCODING_Gamma )
-      return GammaToLinear( value, float( GAMMA_FACTOR ) );
-  #else
-    return vec4( 1.0, 0.0, 0.0, 1.0 );
-  #endif
-
-#elif defined( MACRO_ENCODE )
-
-  #if ( MACRO_ENCODE == ENCODING_Linear )
-    return value;
-  #elif ( MACRO_ENCODE == ENCODING_sRGB )
-    return LinearTosRGB( value );
-  #elif ( MACRO_ENCODE == ENCODING_RGBE )
-    return LinearToRGBE( value );
-  #elif ( MACRO_ENCODE == ENCODING_LogLuv )
-    return LinearToLogLuv( value );
-  #elif ( MACRO_ENCODE == ENCODING_RGBM7 )
-    return LinearToRGBM( value, 7.0 );
-  #elif ( MACRO_ENCODE == ENCODING_RGBM16 )
-    return LinearToRGBM( value, 16.0 );
-  #elif ( MACRO_ENCODE == ENCODING_RGBD )
-    return LinearToRGBD( value, 256.0 );
-  #elif ( MACRO_ENCODE == ENCODING_Gamma )
-    return LinearToGamma( value, float( GAMMA_FACTOR ) );
-  #else
-    return vec4( 1.0, 0.0, 0.0, 1.0 );
-  #endif
-
-#endif
diff --git a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
index 5705d3b8f5043b..d9a03464ba71ec 100644
--- a/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
@@ -2,10 +2,4 @@
 
 	uniform sampler2D map;
 
-	vec4 mapTexelToLinear( vec4 value ) {
-		#define MACRO_DECODE MAP_ENCODING
-			#include <encoding_template>
-		#undef MACRO_DECODE
-	}
-
 #endif
diff --git a/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
index cc507c3e064409..cc3c236659a05a 100644
--- a/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
@@ -2,11 +2,5 @@
 
 	uniform vec4 offsetRepeat;
 	uniform sampler2D map;
-	
-	vec4 mapTexelToLinear( vec4 value ) {
-		#define MACRO_DECODE MAP_ENCODING
-			#include <encoding_template>
-		#undef MACRO_DECODE
-	}
 
 #endif
diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js
index ba73dd38294ed0..dca7e562328430 100644
--- a/src/renderers/webgl/WebGLProgram.js
+++ b/src/renderers/webgl/WebGLProgram.js
@@ -7,46 +7,35 @@ THREE.WebGLProgram = ( function () {
 	var arrayStructRe = /^([\w\d_]+)\[(\d+)\]\.([\w\d_]+)$/;
 	var arrayRe = /^([\w\d_]+)\[0\]$/;
 
-	function getTexelDecodingMacro( encoding ) {
+	function getTexelDecodingFunction( functionName, encoding ) {
+		var code = "vec4 " + functionName + "( vec4 value ) { return ";
 		switch( encoding ) {
 			case THREE.LinearEncoding:
-				return "(value)";
+				code += "value";
+				break;
 			case THREE.sRGBEncoding:
-				return "sRGBToLinear( value )";
+				code += "sRGBToLinear( value )";
+				break;
 			case THREE.RGBEEncoding:
-				return "RGBEToLinear( value )";
+				code += "RGBEToLinear( value )";
+				break;
 			case THREE.RGBM7Encoding:
-				return "RGBMToLinear( value, 7.0 )";
+				code += "RGBMToLinear( value, 7.0 )";
+				break;
 			case THREE.RGBM16Encoding:
-				return "RGBMToLinear( value, 16.0 )";
+				code += "RGBMToLinear( value, 16.0 )";
+				break;
 			case THREE.RGBDEncoding:
-				return "RGBDToLinear( value, 256.0 )";
+				code += "RGBDToLinear( value, 256.0 )";
+				break;
 			case THREE.GammaEncoding:
-				return "GammaToLinear( value, float( GAMMA_FACTOR ) )";
-			default:
-			 throw new Error( "unsupported encoding: " + encoding );
-		}
-	}
-
-	function getTexelEncodingMacro( encoding ) {
-		switch( encoding ) {
-			case THREE.LinearEncoding:
-				return "(value)";
-			case THREE.sRGBEncoding:
-				return "LinearTosRGB( value )";
-			case THREE.RGBEEncoding:
-				return "LinearToRGBE( value )";
-			case THREE.RGBM7Encoding:
-				return "LinearToRGBM( value, 7.0 )";
-			case THREE.RGBM16Encoding:
-				return "LinearToRGBM( value, 16.0 )";
-			case THREE.RGBDEncoding:
-				return "LinearToRGBD( value, 256.0 )";
-			case THREE.GammaEncoding:
-				return "LinearToGamma( value, float( GAMMA_FACTOR ) )";
+				code += "GammaToLinear( value, float( GAMMA_FACTOR ) )";
+				break;
 			default:
 			 throw new Error( "unsupported encoding: " + encoding );
 		}
+		code += "; }";
+		return code;
 	}
 
 	function generateExtensions( extensions, parameters, rendererExtensions ) {
@@ -340,7 +329,6 @@ THREE.WebGLProgram = ( function () {
 
 				parameters.map ? '#define USE_MAP' : '',
 				parameters.envMap ? '#define USE_ENVMAP' : '',
-				parameters.envMap ? '#define ' + envMapModeDefine : '',
 				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
 				parameters.aoMap ? '#define USE_AOMAP' : '',
 				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
@@ -448,16 +436,16 @@ THREE.WebGLProgram = ( function () {
 				( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',
 
 				parameters.map ? '#define USE_MAP' : '',
-				parameters.mapEncoding ? '#define MAP_ENCODING ' + material.map.encoding : '',
+				parameters.mapEncoding ? getTexelDecodingFunction( "mapTexelToLinear", material.map.encoding ) : '',
 				parameters.envMap ? '#define USE_ENVMAP' : '',
 				parameters.envMap ? '#define ' + envMapTypeDefine : '',
 				parameters.envMap ? '#define ' + envMapModeDefine : '',
 				parameters.envMap ? '#define ' + envMapBlendingDefine : '',
-				parameters.envMapEncoding ? '#define ENVMAP_ENCODING ' + material.envMap.encoding : '',
 				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
+				parameters.envMapEncoding ? getTexelDecodingFunction( "envMapTexelToLinear", material.envMap.encoding ) : '',
 				parameters.aoMap ? '#define USE_AOMAP' : '',
 				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
-				parameters.emissiveMapEncoding ? '#define EMISSIVEMAP_ENCODING ' + material.emissiveMap.encoding : '',
+				parameters.emissiveMapEncoding ? getTexelDecodingFunction( "emissiveMapTexelToLinear", material.emissiveMap.encoding ) : '',
 				parameters.bumpMap ? '#define USE_BUMPMAP' : '',
 				parameters.normalMap ? '#define USE_NORMALMAP' : '',
 				parameters.specularMap ? '#define USE_SPECULARMAP' : '',
diff --git a/src/renderers/webgl/WebGLShaderPreProcessor.js b/src/renderers/webgl/WebGLShaderPreProcessor.js
deleted file mode 100644
index 1a25ef4302654e..00000000000000
--- a/src/renderers/webgl/WebGLShaderPreProcessor.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
-* @author bhouston / http://clara.io
-*/
-
-THREE.WebGLShaderPreProcessor = {};
-
-THREE.WebGLShaderPreProcessor.compile = function() {
-
-  var regexInclude = /[ ]*#include[ ]+["<]([\w\d.]*)[">]/;
-
-  return function( code, includeResolver ) {
-
-    includeResolver = includeResolver || THREE.WebGLShaderPreProcessor.defaultIncludeResolver;
-
-    var lines = code.split( '\n' );
-    var newLines = [];
-    while( lines.length > 0 ) {
-      var line = lines.shift();
-
-      var matcheInclude = regexInclude.exec(line);
-      if( matcheInclude ) {
-        var includeFileName = matcheInclude[1];
-        var includeChunk = includeResolver( includeFileName );
-        if( ! includeChunk ) throw new Error( "can not find include file for line: " + line );
-        var includeLines = includeChunk.split( '\n' );
-        while( includeLines.length > 0 ) {
-          lines.unshift( includeLines.pop() );
-        }
-      }
-      else {
-        newLines.push( line );
-      }
-    }
-    return newLines.join( '\n' );
-  };
-
-}();
-
-THREE.WebGLShaderPreProcessor.defaultIncludeResolver = function( fileName ) {
-
-  return THREE.ShaderChunk[ fileName ];
-
-};
diff --git a/utils/build/includes/common.json b/utils/build/includes/common.json
index 3fb1dea11b5c1b..cb01a361b75bb2 100644
--- a/utils/build/includes/common.json
+++ b/utils/build/includes/common.json
@@ -138,7 +138,6 @@
 	"src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/encodings.glsl",
-	"src/renderers/shaders/ShaderChunk/encoding_template.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl",
 	"src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl",
@@ -209,7 +208,6 @@
 	"src/renderers/webgl/WebGLPrograms.js",
 	"src/renderers/webgl/WebGLProperties.js",
 	"src/renderers/webgl/WebGLShader.js",
-	"src/renderers/webgl/WebGLShaderPreProcessor.js",
 	"src/renderers/webgl/WebGLShadowMap.js",
 	"src/renderers/webgl/WebGLState.js",
 	"src/renderers/webgl/plugins/LensFlarePlugin.js",

From c134418bcb70ceedbb94532b720e09e7e28dd34f Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Wed, 24 Feb 2016 08:10:28 -0500
Subject: [PATCH 28/30] add encodings to includes for primary frag shaders.

---
 src/renderers/shaders/ShaderLib.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/renderers/shaders/ShaderLib.js b/src/renderers/shaders/ShaderLib.js
index fa27a57805cabb..f22b73fd41306d 100644
--- a/src/renderers/shaders/ShaderLib.js
+++ b/src/renderers/shaders/ShaderLib.js
@@ -71,6 +71,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			'#include <common>',
+			'#include <encodings>',
 			'#include <color_pars_fragment>',
 			'#include <uv_pars_fragment>',
 			'#include <uv2_pars_fragment>',
@@ -199,6 +200,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			'#include <common>',
+			'#include <encodings>',
 			'#include <color_pars_fragment>',
 			'#include <uv_pars_fragment>',
 			'#include <uv2_pars_fragment>',
@@ -363,6 +365,7 @@ THREE.ShaderLib = {
 			"uniform float opacity;",
 
 			'#include <common>',
+			'#include <encodings>',
 			'#include <color_pars_fragment>',
 			'#include <uv_pars_fragment>',
 			'#include <uv2_pars_fragment>',
@@ -526,6 +529,7 @@ THREE.ShaderLib = {
 			"#endif",
 
 			'#include <common>',
+			'#include <encodings>',
 			'#include <color_pars_fragment>',
 			'#include <uv_pars_fragment>',
 			'#include <uv2_pars_fragment>',
@@ -630,6 +634,7 @@ THREE.ShaderLib = {
 			"uniform float opacity;",
 
 			'#include <common>',
+			'#include <encodings>',
 			'#include <color_pars_fragment>',
 			'#include <map_particle_pars_fragment>',
 			'#include <fog_pars_fragment>',

From 7fb2830beb15f6d52b81f37a512f7b4276b5f2f4 Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Wed, 24 Feb 2016 08:17:16 -0500
Subject: [PATCH 29/30] remove envMap encoding macro.

---
 src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
index cbfa4548ea4463..8b060c651f1ca1 100644
--- a/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
+++ b/src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
@@ -11,12 +11,6 @@
 	#endif
 	uniform float flipEnvMap;
 
-	vec4 envMapTexelToLinear( vec4 value ) {
-		#define MACRO_DECODE ENVMAP_ENCODING
-			#include <encoding_template>
-		#undef MACRO_DECODE
-	}
-
 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( STANDARD )
 
 		uniform float refractionRatio;

From 0d45254a0f3ba3bde7fd071ed8d20c33272116bb Mon Sep 17 00:00:00 2001
From: Ben Houston <ben@exocortex.com>
Date: Wed, 24 Feb 2016 08:27:06 -0500
Subject: [PATCH 30/30] remove remnants of WebGLShaderPreProcessor, re-add
 mistakenly removed line.

---
 src/renderers/webgl/WebGLProgram.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js
index b14f1c9857a830..25db38731ad5a8 100644
--- a/src/renderers/webgl/WebGLProgram.js
+++ b/src/renderers/webgl/WebGLProgram.js
@@ -343,6 +343,7 @@ THREE.WebGLProgram = ( function () {
 
 				parameters.map ? '#define USE_MAP' : '',
 				parameters.envMap ? '#define USE_ENVMAP' : '',
+				parameters.envMap ? '#define ' + envMapModeDefine : '',
 				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
 				parameters.aoMap ? '#define USE_AOMAP' : '',
 				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
@@ -507,8 +508,6 @@ THREE.WebGLProgram = ( function () {
 		var vertexGlsl = prefixVertex + vertexShader;
 		var fragmentGlsl = prefixFragment + fragmentShader;
 
-		vertexGlsl = THREE.WebGLShaderPreProcessor.compile( vertexGlsl );
-		fragmentGlsl = THREE.WebGLShaderPreProcessor.compile( fragmentGlsl );
 		// console.log( '*VERTEX*', vertexGlsl );
 		// console.log( '*FRAGMENT*', fragmentGlsl );