From a763534c7013bf157997873223fb8ca388bb35a2 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Thu, 25 Feb 2016 16:49:01 -0500 Subject: [PATCH 1/9] add support for linearToOutputTexel texture.encoding. --- .../shaders/ShaderChunk/encodings.glsl | 2 +- .../ShaderChunk/linear_to_gamma_fragment.glsl | 2 +- src/renderers/webgl/WebGLProgram.js | 43 ++++++++++--------- src/renderers/webgl/WebGLPrograms.js | 27 ++++-------- 4 files changed, 34 insertions(+), 40 deletions(-) diff --git a/src/renderers/shaders/ShaderChunk/encodings.glsl b/src/renderers/shaders/ShaderChunk/encodings.glsl index ad24d153486c1b..2533fa7f37a3de 100644 --- a/src/renderers/shaders/ShaderChunk/encodings.glsl +++ b/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 ); } diff --git a/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl b/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl index 365c6dd0a2aacd..abfeb29f5cc187 100644 --- a/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl +++ b/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl @@ -1,2 +1,2 @@ - outgoingLight = linearToOutput( outgoingLight ); + outgoingLight = linearToOutputTexel( outgoingLight ); diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js index ac8c98d042d9cd..57b9b388ab341c 100644 --- a/src/renderers/webgl/WebGLProgram.js +++ b/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 ) : '', diff --git a/src/renderers/webgl/WebGLPrograms.js b/src/renderers/webgl/WebGLPrograms.js index 2d4b453f6a9612..e1079827d4d09e 100644 --- a/src/renderers/webgl/WebGLPrograms.js +++ b/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, From 052254b194fdecf4fe01b04d778f6d3e824a9070 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Thu, 25 Feb 2016 17:01:57 -0500 Subject: [PATCH 2/9] further adoption of linearToOutputTexel in primary materials. --- src/renderers/shaders/ShaderLib/linedashed_frag.glsl | 2 +- src/renderers/shaders/ShaderLib/meshbasic_frag.glsl | 3 +-- src/renderers/shaders/ShaderLib/meshlambert_frag.glsl | 3 +-- src/renderers/shaders/ShaderLib/meshphong_frag.glsl | 3 +-- src/renderers/shaders/ShaderLib/meshstandard_frag.glsl | 4 +--- src/renderers/shaders/ShaderLib/points_frag.glsl | 2 +- 6 files changed, 6 insertions(+), 11 deletions(-) diff --git a/src/renderers/shaders/ShaderLib/linedashed_frag.glsl b/src/renderers/shaders/ShaderLib/linedashed_frag.glsl index 3fb6319d903e26..c4ecfe86a04867 100644 --- a/src/renderers/shaders/ShaderLib/linedashed_frag.glsl +++ b/src/renderers/shaders/ShaderLib/linedashed_frag.glsl @@ -29,6 +29,6 @@ void main() { #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } diff --git a/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl b/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl index 432fc4aa5eb3a4..09face8ec57407 100644 --- a/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl @@ -41,9 +41,8 @@ void main() { vec3 outgoingLight = reflectedLight.indirectDiffuse; #include - #include #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } diff --git a/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl b/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl index afb30116205f86..7d3f8ebea66a4f 100644 --- a/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl @@ -68,9 +68,8 @@ void main() { vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveLight; #include - #include #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } diff --git a/src/renderers/shaders/ShaderLib/meshphong_frag.glsl b/src/renderers/shaders/ShaderLib/meshphong_frag.glsl index 87d22e4356a55d..a3a4022ebe452e 100644 --- a/src/renderers/shaders/ShaderLib/meshphong_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshphong_frag.glsl @@ -52,10 +52,9 @@ void main() { vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight; #include - #include #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } diff --git a/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl b/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl index f9d9e7fd3e5192..28563904d1ef74 100644 --- a/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl @@ -64,10 +64,8 @@ void main() { vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight; - #include - #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } diff --git a/src/renderers/shaders/ShaderLib/points_frag.glsl b/src/renderers/shaders/ShaderLib/points_frag.glsl index f4accc1fe90da5..8742573a35b8a2 100644 --- a/src/renderers/shaders/ShaderLib/points_frag.glsl +++ b/src/renderers/shaders/ShaderLib/points_frag.glsl @@ -22,6 +22,6 @@ void main() { #include - gl_FragColor = vec4( outgoingLight, diffuseColor.a ); + gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); } From 9ae10fc91f3d10eb6cf031b40c0807c9e596a60e Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Thu, 25 Feb 2016 17:05:18 -0500 Subject: [PATCH 3/9] remove linear_to_gamma_fragment, replaced by new output encoding support. --- src/renderers/shaders/ShaderChunk/common.glsl | 28 ------------------- .../ShaderChunk/linear_to_gamma_fragment.glsl | 2 -- utils/build/includes/common.json | 1 - 3 files changed, 31 deletions(-) delete mode 100644 src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl diff --git a/src/renderers/shaders/ShaderChunk/common.glsl b/src/renderers/shaders/ShaderChunk/common.glsl index ada652c54f8e0c..1652ceccd7a23c 100644 --- a/src/renderers/shaders/ShaderChunk/common.glsl +++ b/src/renderers/shaders/ShaderChunk/common.glsl @@ -64,31 +64,3 @@ vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 poi return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine; } - -vec3 inputToLinear( in vec3 a ) { - - #ifdef GAMMA_INPUT - - return pow( a, vec3( float( GAMMA_FACTOR ) ) ); - - #else - - return a; - - #endif - -} - -vec3 linearToOutput( in vec3 a ) { - - #ifdef GAMMA_OUTPUT - - return pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) ); - - #else - - return a; - - #endif - -} diff --git a/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl b/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl deleted file mode 100644 index abfeb29f5cc187..00000000000000 --- a/src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl +++ /dev/null @@ -1,2 +0,0 @@ - - outgoingLight = linearToOutputTexel( outgoingLight ); diff --git a/utils/build/includes/common.json b/utils/build/includes/common.json index 6f75beb7603c0b..db065a79cc67c9 100644 --- a/utils/build/includes/common.json +++ b/utils/build/includes/common.json @@ -155,7 +155,6 @@ "src/renderers/shaders/ShaderChunk/lights_standard_fragment.glsl", "src/renderers/shaders/ShaderChunk/lights_standard_pars_fragment.glsl", "src/renderers/shaders/ShaderChunk/lights_template.glsl", - "src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl", "src/renderers/shaders/ShaderChunk/logdepthbuf_fragment.glsl", "src/renderers/shaders/ShaderChunk/logdepthbuf_pars_fragment.glsl", "src/renderers/shaders/ShaderChunk/logdepthbuf_pars_vertex.glsl", From c47accd046053ab077d0fa5b92bb578ff35f9f87 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 09:33:20 -0500 Subject: [PATCH 4/9] move fog_fragment after encoding, the reason is the background/fog colors are not encoded and we need to get perfect blends. --- src/renderers/shaders/ShaderChunk/fog_fragment.glsl | 6 +++--- src/renderers/shaders/ShaderLib/linedashed_frag.glsl | 4 ++-- src/renderers/shaders/ShaderLib/meshbasic_frag.glsl | 3 ++- src/renderers/shaders/ShaderLib/meshlambert_frag.glsl | 3 ++- src/renderers/shaders/ShaderLib/meshphong_frag.glsl | 4 ++-- src/renderers/shaders/ShaderLib/meshstandard_frag.glsl | 4 ++-- src/renderers/shaders/ShaderLib/points_frag.glsl | 4 ++-- 7 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/renderers/shaders/ShaderChunk/fog_fragment.glsl b/src/renderers/shaders/ShaderChunk/fog_fragment.glsl index 6e8814bfa34cb1..38309ad7a28f3e 100644 --- a/src/renderers/shaders/ShaderChunk/fog_fragment.glsl +++ b/src/renderers/shaders/ShaderChunk/fog_fragment.glsl @@ -19,7 +19,7 @@ float fogFactor = smoothstep( fogNear, fogFar, depth ); #endif - - outgoingLight = mix( outgoingLight, fogColor, fogFactor ); -#endif \ No newline at end of file + gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor ); + +#endif diff --git a/src/renderers/shaders/ShaderLib/linedashed_frag.glsl b/src/renderers/shaders/ShaderLib/linedashed_frag.glsl index c4ecfe86a04867..b155e8633413b7 100644 --- a/src/renderers/shaders/ShaderLib/linedashed_frag.glsl +++ b/src/renderers/shaders/ShaderLib/linedashed_frag.glsl @@ -27,8 +27,8 @@ void main() { outgoingLight = diffuseColor.rgb; // simple shader - #include - gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } diff --git a/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl b/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl index 09face8ec57407..08cf1d3965ba81 100644 --- a/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshbasic_frag.glsl @@ -41,8 +41,9 @@ void main() { vec3 outgoingLight = reflectedLight.indirectDiffuse; #include - #include gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } diff --git a/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl b/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl index 7d3f8ebea66a4f..648b42aa39ebd9 100644 --- a/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshlambert_frag.glsl @@ -68,8 +68,9 @@ void main() { vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveLight; #include - #include gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } diff --git a/src/renderers/shaders/ShaderLib/meshphong_frag.glsl b/src/renderers/shaders/ShaderLib/meshphong_frag.glsl index a3a4022ebe452e..f9f91e83aef99a 100644 --- a/src/renderers/shaders/ShaderLib/meshphong_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshphong_frag.glsl @@ -53,8 +53,8 @@ void main() { #include - #include - gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } diff --git a/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl b/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl index 28563904d1ef74..4c13ebfc731821 100644 --- a/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl +++ b/src/renderers/shaders/ShaderLib/meshstandard_frag.glsl @@ -64,8 +64,8 @@ void main() { vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight; - #include - gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } diff --git a/src/renderers/shaders/ShaderLib/points_frag.glsl b/src/renderers/shaders/ShaderLib/points_frag.glsl index 8742573a35b8a2..2dbdcadb0060d2 100644 --- a/src/renderers/shaders/ShaderLib/points_frag.glsl +++ b/src/renderers/shaders/ShaderLib/points_frag.glsl @@ -20,8 +20,8 @@ void main() { outgoingLight = diffuseColor.rgb; - #include - gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) ); + #include + } From 10d75a14fc06959aa0e881e097a81104adbbe1e4 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 09:34:36 -0500 Subject: [PATCH 5/9] move getTextureEncodingFromMap to WebGLPrograms enclosure. --- src/renderers/webgl/WebGLPrograms.js | 35 +++++++++++++++++----------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/src/renderers/webgl/WebGLPrograms.js b/src/renderers/webgl/WebGLPrograms.js index e1079827d4d09e..b44abb66778ff6 100644 --- a/src/renderers/webgl/WebGLPrograms.js +++ b/src/renderers/webgl/WebGLPrograms.js @@ -67,6 +67,28 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) { } + + function getTextureEncodingFromMap ( map, gammaOverrideLinear ) { + + var encoding; + if( ! map ) { + encoding = THREE.LinearEncoding; + } + else if( map instanceof THREE.Texture ) { + encoding = map.encoding; + } + else if( map instanceof THREE.WebGLRenderTarget ) { + encoding = map.texture.encoding; + } + + // add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point. + if( encoding === THREE.LinearEncoding && gammaOverrideLinear ) { + encoding = THREE.GammaEncoding; + } + + return encoding; + } + this.getParameters = function ( material, lights, fog, object ) { var shaderID = shaderIDs[ material.type ]; // heuristics to create shader parameters according to lights in the scene @@ -87,19 +109,6 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) { } - var getTextureEncodingFromMap = function( map, gammaOverrideLinear ) { - var encoding; - if( ! map ) { - encoding = THREE.LinearEncoding; - } - 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; - } - return encoding; - } - var parameters = { shaderID: shaderID, From f40a9f55be4a565c37af4139285a814e14c3308c Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 09:34:49 -0500 Subject: [PATCH 6/9] have linearToOutputTexel the last encoding function as it is used last. --- src/renderers/webgl/WebGLProgram.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/renderers/webgl/WebGLProgram.js b/src/renderers/webgl/WebGLProgram.js index 57b9b388ab341c..330501249b9e78 100644 --- a/src/renderers/webgl/WebGLProgram.js +++ b/src/renderers/webgl/WebGLProgram.js @@ -500,10 +500,10 @@ THREE.WebGLProgram = ( function () { ( 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 ) : '', + parameters.outputEncoding ? getTexelEncodingFunction( "linearToOutputTexel", parameters.outputEncoding ) : '', '\n' From 3c4face74e238a6fc2477a5533256296ea2e5c11 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 09:35:12 -0500 Subject: [PATCH 7/9] update ShaderSkin to use new linearToOutputTexel function. --- examples/js/ShaderSkin.js | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/examples/js/ShaderSkin.js b/examples/js/ShaderSkin.js index c0b720d9a0bf6f..90c4dc9bb4aa49 100644 --- a/examples/js/ShaderSkin.js +++ b/examples/js/ShaderSkin.js @@ -247,11 +247,9 @@ THREE.ShaderSkin = { "outgoingLight += diffuseColor.xyz * ( totalDiffuseLight + ambientLightColor * diffuse ) + totalSpecularLight;", - THREE.ShaderChunk[ "linear_to_gamma_fragment" ], - THREE.ShaderChunk[ "fog_fragment" ], - - "gl_FragColor = vec4( outgoingLight, diffuseColor.a );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects + "gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects + THREE.ShaderChunk[ "fog_fragment" ], "}" @@ -550,10 +548,10 @@ THREE.ShaderSkin = { "}", - THREE.ShaderChunk[ "fog_fragment" ], - "gl_FragColor = vec4( outgoingLight, diffuseColor.a );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects + THREE.ShaderChunk[ "fog_fragment" ], + "}" ].join( "\n" ), From 3bd62a1bacaed8aa10db5fa59dfc207a16e30c9a Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 10:07:15 -0500 Subject: [PATCH 8/9] add comment that HDR-focused encodings do not support transparency --- src/Three.js | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/Three.js b/src/Three.js index 1345fa28922125..6a1e13c88098b5 100644 --- a/src/Three.js +++ b/src/Three.js @@ -310,9 +310,12 @@ THREE.TriangleFanDrawMode = 2; THREE.LinearEncoding = 3000; // No encoding at all. THREE.sRGBEncoding = 3001; -THREE.RGBEEncoding = 3002; // AKA Radiance +THREE.GammaEncoding = 3007; // uses GAMMA_FACTOR, for backwards compatibility with WebGLRenderer.gammaInput/gammaOutput + +// The following Texture Encodings are for RGB-only (no alpha) HDR light emission sources. +// These encodings should not specified as output encodings except in rare situations. +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 +THREE.RGBDEncoding = 3006; // MaxRange is 256. From 7210aadabbee25dbaa4a9b39463ab00abcd47027 Mon Sep 17 00:00:00 2001 From: Ben Houston Date: Fri, 26 Feb 2016 11:38:33 -0500 Subject: [PATCH 9/9] fix accessing internal WebGLRenderer current render target. --- src/renderers/WebGLRenderer.js | 6 ++++++ src/renderers/webgl/WebGLPrograms.js | 3 +-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js index 597dd796c748f1..f91d1715615f70 100644 --- a/src/renderers/WebGLRenderer.js +++ b/src/renderers/WebGLRenderer.js @@ -3365,6 +3365,12 @@ THREE.WebGLRenderer = function ( parameters ) { } + this.getCurrentRenderTarget = function() { + + return _currentRenderTarget; + + } + this.setRenderTarget = function ( renderTarget ) { _currentRenderTarget = renderTarget; diff --git a/src/renderers/webgl/WebGLPrograms.js b/src/renderers/webgl/WebGLPrograms.js index 7d891f9f157761..9eff101a1427c6 100644 --- a/src/renderers/webgl/WebGLPrograms.js +++ b/src/renderers/webgl/WebGLPrograms.js @@ -117,14 +117,13 @@ THREE.WebGLPrograms = function ( renderer, capabilities ) { } } - var parameters = { shaderID: shaderID, precision: precision, supportsVertexTextures: capabilities.vertexTextures, - outputEncoding: getTextureEncodingFromMap( renderer._currentRenderTarget, renderer.gammaOutput ), + outputEncoding: getTextureEncodingFromMap( renderer.getCurrentRenderTarget(), renderer.gammaOutput ), map: !! material.map, mapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ), envMap: !! material.envMap,