add support for linearToOutputTexel texture.encoding.

src/renderers/shaders/ShaderChunk/encodings.glsl

@@ -7,7 +7,7 @@ vec4 LinearToLinear( in vec4 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 ) {
+vec4 LinearToGamma( in vec4 value, in float gammaFactor ) {
   return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );
 }
 

src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl

 
-	outgoingLight = linearToOutput( outgoingLight );
+	outgoingLight = linearToOutputTexel( outgoingLight );

src/renderers/webgl/WebGLProgram.js

@@ -7,40 +7,42 @@ THREE.WebGLProgram = ( function () {
 	var arrayStructRe = /^([\w\d_]+)\[(\d+)\]\.([\w\d_]+)$/;
 	var arrayRe = /^([\w\d_]+)\[0\]$/;
 
-	function getTexelDecodingFunction( functionName, encoding ) {
-
-		var code = "vec4 " + functionName + "( vec4 value ) { return ";
+	function getEncodingComponents( encoding ) {
 
 		switch ( encoding ) {
 
 			case THREE.LinearEncoding:
-				code += "value";
-				break;
+				return ['Linear','( value )'];
 			case THREE.sRGBEncoding:
-				code += "sRGBToLinear( value )";
-				break;
+				return ['sRGB','( value )'];
 			case THREE.RGBEEncoding:
-				code += "RGBEToLinear( value )";
-				break;
+				return ['RGBE','( value )'];
 			case THREE.RGBM7Encoding:
-				code += "RGBMToLinear( value, 7.0 )";
-				break;
+				return ['RGBM','( value, 7.0 )'];
 			case THREE.RGBM16Encoding:
-				code += "RGBMToLinear( value, 16.0 )";
-				break;
+				return ['RGBM','( value, 16.0 )'];
 			case THREE.RGBDEncoding:
-				code += "RGBDToLinear( value, 256.0 )";
-				break;
+				return ['RGBD','( value, 256.0 )'];
 			case THREE.GammaEncoding:
-				code += "GammaToLinear( value, float( GAMMA_FACTOR ) )";
-				break;
+				return ['Gamma','( value, float( GAMMA_FACTOR ) )'];
 			default:
 				throw new Error( 'unsupported encoding: ' + encoding );
 
 		}
 
-		code += "; }";
-		return code;
+	}
+
+	function getTexelDecodingFunction( functionName, encoding ) {
+
+		var components = getEncodingComponents( encoding );
+		return "vec4 " + functionName + "( vec4 value ) { return " + components[0] + "ToLinear" + components[1] + "; }";
+
+	}
+
+	function getTexelEncodingFunction( functionName, encoding ) {
+
+		var components = getEncodingComponents( encoding );
+		return "vec4 " + functionName + "( vec4 value ) { return LinearTo" + components[0] + components[1] + "; }";
 
 	}
 
@@ -496,8 +498,9 @@ THREE.WebGLProgram = ( function () {
 				'uniform mat4 viewMatrix;',
 				'uniform vec3 cameraPosition;',
 
-				( parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? THREE.ShaderChunk[ 'encodings' ] : '',
+				( parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? THREE.ShaderChunk[ 'encodings' ] : '',
 
+				parameters.outputEncoding ? getTexelEncodingFunction( "linearToOutputTexel", parameters.outputEncoding ) : '',
 				parameters.mapEncoding ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '',
 				parameters.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',
 				parameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',

src/renderers/webgl/WebGLPrograms.js

@@ -68,7 +68,6 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 	}
 
 	this.getParameters = function ( material, lights, fog, object ) {
-
 		var shaderID = shaderIDs[ material.type ];
 		// heuristics to create shader parameters according to lights in the scene
 		// (not to blow over maxLights budget)
@@ -88,21 +87,13 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 
 		}
 
-		var getTextureEncodingFromMap = function( map ) {
-			if( ! map ) { // no texture
-				return false;
-			}
+		var getTextureEncodingFromMap = function( map, gammaOverrideLinear ) {
 			var encoding;
-			if( map.encoding !== undefined ) { // standard texture
-				encoding = map.encoding;
-			}
-			else if( map.texture !== undefined ) {  // render target pretending to be a texture, get the texture inside it.
-				encoding = map.texture.encoding;
+			if( ! map ) {
+				encoding = THREE.LinearEncoding;
 			}
-			else {
-				throw new Error( "can not determine texture encoding from map: " + map );
-			}
-			// add backwards compatibility for WebGLRenderer.gammaInput parameter, should probably be removed at some point. 
+			else if( map instanceof THREE.Texture ) {
+			// add backwards compatibility for WebGLRenderer.gammaInput parameter, should probably be removed at some point.
 			if( encoding === THREE.LinearEncoding && renderer.gammaInput ) {
 				encoding = THREE.GammaEncoding;
 			}
@@ -115,16 +106,16 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) {
 
 			precision: precision,
 			supportsVertexTextures: capabilities.vertexTextures,
-
+			outputEncoding: getTextureEncodingFromMap( renderer._currentRenderTarget, renderer.gammaOutput ),
 			map: !! material.map,
-			mapEncoding: getTextureEncodingFromMap( material.map ),
+			mapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ),
 			envMap: !! material.envMap,
 			envMapMode: material.envMap && material.envMap.mapping,
-			envMapEncoding: getTextureEncodingFromMap( material.envMap ),
+			envMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ),
 			lightMap: !! material.lightMap,
 			aoMap: !! material.aoMap,
 			emissiveMap: !! material.emissiveMap,
-			emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap ),
+			emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ),
 			bumpMap: !! material.bumpMap,
 			normalMap: !! material.normalMap,
 			displacementMap: !! material.displacementMap,