super-three 0.165.0 → 0.168.0

package/{examples/jsm → src}/renderers/common/nodes/Nodes.js

@@ -1,8 +1,13 @@
 import DataMap from '../DataMap.js';
 import ChainMap from '../ChainMap.js';
 import NodeBuilderState from './NodeBuilderState.js';
-import { EquirectangularReflectionMapping, EquirectangularRefractionMapping, NoToneMapping, SRGBColorSpace } from 'three';
-import { NodeFrame, vec4, objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, viewportBottomLeft, normalWorld, pmremTexture, viewportTopLeft } from '../../../nodes/Nodes.js';
+import { cubeMapNode } from '../../../nodes/utils/CubeMapNode.js';
+import { NodeFrame } from '../../../nodes/Nodes.js';
+import { objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, normalWorld, pmremTexture, viewportUV } from '../../../nodes/TSL.js';
+
+import { EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
+
+const outputNodeMap = new WeakMap();
 
 class Nodes extends DataMap {
 
@@ -107,8 +112,10 @@ class Nodes extends DataMap {
 
 			if ( nodeBuilderState === undefined ) {
 
-				const nodeBuilder = this.backend.createNodeBuilder( renderObject.object, this.renderer, renderObject.scene );
+				const nodeBuilder = this.backend.createNodeBuilder( renderObject.object, this.renderer );
+				nodeBuilder.scene = renderObject.scene;
 				nodeBuilder.material = renderObject.material;
+				nodeBuilder.camera = renderObject.camera;
 				nodeBuilder.context.material = renderObject.material;
 				nodeBuilder.lightsNode = renderObject.lightsNode;
 				nodeBuilder.environmentNode = this.getEnvironmentNode( renderObject.scene );
@@ -182,6 +189,8 @@ class Nodes extends DataMap {
 			nodeBuilder.getBindings(),
 			nodeBuilder.updateNodes,
 			nodeBuilder.updateBeforeNodes,
+			nodeBuilder.updateAfterNodes,
+			nodeBuilder.instanceBindGroups,
 			nodeBuilder.transforms
 		);
 
@@ -219,7 +228,7 @@ class Nodes extends DataMap {
 
 			const cacheKey = [];
 
-			if ( lightsNode ) cacheKey.push( lightsNode.getCacheKey() );
+			if ( lightsNode ) cacheKey.push( lightsNode.getCacheKey( true ) );
 			if ( environmentNode ) cacheKey.push( environmentNode.getCacheKey() );
 			if ( fogNode ) cacheKey.push( fogNode.getCacheKey() );
 
@@ -257,17 +266,39 @@ class Nodes extends DataMap {
 
 		if ( background ) {
 
-			if ( sceneData.background !== background ) {
+			const forceUpdate = ( scene.backgroundBlurriness === 0 && sceneData.backgroundBlurriness > 0 ) || ( scene.backgroundBlurriness > 0 && sceneData.backgroundBlurriness === 0 );
+
+			if ( sceneData.background !== background || forceUpdate ) {
 
 				let backgroundNode = null;
 
 				if ( background.isCubeTexture === true || ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) ) {
 
-					backgroundNode = pmremTexture( background, normalWorld );
+					if ( scene.backgroundBlurriness > 0 ) {
+
+						backgroundNode = pmremTexture( background, normalWorld );
+
+					} else {
+
+						let envMap;
+
+						if ( background.isCubeTexture === true ) {
+
+							envMap = cubeTexture( background );
+
+						} else {
+
+							envMap = texture( background );
+
+						}
+
+						backgroundNode = cubeMapNode( envMap );
+
+					}
 
 				} else if ( background.isTexture === true ) {
 
-					backgroundNode = texture( background, viewportBottomLeft ).setUpdateMatrix( true );
+					backgroundNode = texture( background, viewportUV.flipY() ).setUpdateMatrix( true );
 
 				} else if ( background.isColor !== true ) {
 
@@ -277,6 +308,7 @@ class Nodes extends DataMap {
 
 				sceneData.backgroundNode = backgroundNode;
 				sceneData.background = background;
+				sceneData.backgroundBlurriness = scene.backgroundBlurriness;
 
 			}
 
@@ -386,29 +418,30 @@ class Nodes extends DataMap {
 
 	}
 
-	getOutputNode( outputTexture ) {
+	getOutputCacheKey() {
 
-		let output = texture( outputTexture, viewportTopLeft );
+		const renderer = this.renderer;
 
-		if ( this.isToneMappingState ) {
+		return renderer.toneMapping + ',' + renderer.currentColorSpace;
 
-			if ( this.renderer.toneMappingNode ) {
+	}
 
-				output = vec4( this.renderer.toneMappingNode.context( { color: output.rgb } ), output.a );
+	hasOutputChange( outputTarget ) {
 
-			} else if ( this.renderer.toneMapping !== NoToneMapping ) {
+		const cacheKey = outputNodeMap.get( outputTarget );
 
-				output = output.toneMapping( this.renderer.toneMapping );
+		return cacheKey !== this.getOutputCacheKey();
 
-			}
+	}
 
-		}
+	getOutputNode( outputTexture ) {
 
-		if ( this.renderer.currentColorSpace === SRGBColorSpace ) {
+		const renderer = this.renderer;
+		const cacheKey = this.getOutputCacheKey();
 
-			output = output.linearToColorSpace( this.renderer.currentColorSpace );
+		const output = texture( outputTexture, viewportUV ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
 
-		}
+		outputNodeMap.set( outputTexture, cacheKey );
 
 		return output;
 
@@ -416,12 +449,27 @@ class Nodes extends DataMap {
 
 	updateBefore( renderObject ) {
 
-		const nodeFrame = this.getNodeFrameForRender( renderObject );
 		const nodeBuilder = renderObject.getNodeBuilderState();
 
 		for ( const node of nodeBuilder.updateBeforeNodes ) {
 
-			nodeFrame.updateBeforeNode( node );
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
+
+		}
+
+	}
+
+	updateAfter( renderObject ) {
+
+		const nodeBuilder = renderObject.getNodeBuilderState();
+
+		for ( const node of nodeBuilder.updateAfterNodes ) {
+
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
 
 		}
 

package/src/renderers/common/nodes/StandardNodeLibrary.js

@@ -0,0 +1,105 @@
+import NodeLibrary from './NodeLibrary.js';
+
+// Materials
+import { MeshPhongMaterial } from '../../../materials/MeshPhongMaterial.js';
+import MeshPhongNodeMaterial from '../../../materials/nodes/MeshPhongNodeMaterial.js';
+import { MeshStandardMaterial } from '../../../materials/MeshStandardMaterial.js';
+import MeshStandardNodeMaterial from '../../../materials/nodes/MeshStandardNodeMaterial.js';
+import { MeshPhysicalMaterial } from '../../../materials/MeshPhysicalMaterial.js';
+import MeshPhysicalNodeMaterial from '../../../materials/nodes/MeshPhysicalNodeMaterial.js';
+import { MeshToonMaterial } from '../../../materials/MeshToonMaterial.js';
+import MeshToonNodeMaterial from '../../../materials/nodes/MeshToonNodeMaterial.js';
+import { MeshBasicMaterial } from '../../../materials/MeshBasicMaterial.js';
+import MeshBasicNodeMaterial from '../../../materials/nodes/MeshBasicNodeMaterial.js';
+import { MeshLambertMaterial } from '../../../materials/MeshLambertMaterial.js';
+import MeshLambertNodeMaterial from '../../../materials/nodes/MeshLambertNodeMaterial.js';
+import { MeshNormalMaterial } from '../../../materials/MeshNormalMaterial.js';
+import MeshNormalNodeMaterial from '../../../materials/nodes/MeshNormalNodeMaterial.js';
+import { MeshMatcapMaterial } from '../../../materials/MeshMatcapMaterial.js';
+import MeshMatcapNodeMaterial from '../../../materials/nodes/MeshMatcapNodeMaterial.js';
+import { LineBasicMaterial } from '../../../materials/LineBasicMaterial.js';
+import LineBasicNodeMaterial from '../../../materials/nodes/LineBasicNodeMaterial.js';
+import { LineDashedMaterial } from '../../../materials/LineDashedMaterial.js';
+import LineDashedNodeMaterial from '../../../materials/nodes/LineDashedNodeMaterial.js';
+import { PointsMaterial } from '../../../materials/PointsMaterial.js';
+import PointsNodeMaterial from '../../../materials/nodes/PointsNodeMaterial.js';
+import { SpriteMaterial } from '../../../materials/SpriteMaterial.js';
+import SpriteNodeMaterial from '../../../materials/nodes/SpriteNodeMaterial.js';
+import { ShadowMaterial } from '../../../materials/ShadowMaterial.js';
+import ShadowNodeMaterial from '../../../materials/nodes/ShadowNodeMaterial.js';
+//import { MeshDepthMaterial } from '../../../materials/MeshDepthMaterial.js';
+//import MeshDepthNodeMaterial from '../../../materials/nodes/MeshDepthNodeMaterial.js';
+//import { MeshDistanceMaterial } from '../../../materials/MeshDistanceMaterial.js';
+//import MeshDistanceNodeMaterial from '../../../materials/nodes/MeshDistanceNodeMaterial.js';
+
+// Lights
+import { PointLight } from '../../../lights/PointLight.js';
+import { PointLightNode } from '../../../nodes/Nodes.js';
+import { DirectionalLight } from '../../../lights/DirectionalLight.js';
+import { DirectionalLightNode } from '../../../nodes/Nodes.js';
+import { RectAreaLight } from '../../../lights/RectAreaLight.js';
+import { RectAreaLightNode } from '../../../nodes/Nodes.js';
+import { SpotLight } from '../../../lights/SpotLight.js';
+import { SpotLightNode } from '../../../nodes/Nodes.js';
+import { AmbientLight } from '../../../lights/AmbientLight.js';
+import { AmbientLightNode } from '../../../nodes/Nodes.js';
+import { HemisphereLight } from '../../../lights/HemisphereLight.js';
+import { HemisphereLightNode } from '../../../nodes/Nodes.js';
+import { LightProbe } from '../../../lights/LightProbe.js';
+import { LightProbeNode } from '../../../nodes/Nodes.js';
+import IESSpotLight from '../../../lights/webgpu/IESSpotLight.js';
+import { IESSpotLightNode } from '../../../nodes/Nodes.js';
+
+// Tone Mapping
+import { LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping } from '../../../constants.js';
+import * as TMF from '../../../nodes/display/ToneMappingFunctions.js';
+
+// Color Space
+import { LinearSRGBColorSpace, SRGBColorSpace } from '../../../constants.js';
+import { getColorSpaceMethod } from '../../../nodes/display/ColorSpaceNode.js';
+import * as CSF from '../../../nodes/display/ColorSpaceFunctions.js';
+
+class StandardNodeLibrary extends NodeLibrary {
+
+	constructor() {
+
+		super();
+
+		this.addMaterial( MeshPhongNodeMaterial, MeshPhongMaterial );
+		this.addMaterial( MeshStandardNodeMaterial, MeshStandardMaterial );
+		this.addMaterial( MeshPhysicalNodeMaterial, MeshPhysicalMaterial );
+		this.addMaterial( MeshToonNodeMaterial, MeshToonMaterial );
+		this.addMaterial( MeshBasicNodeMaterial, MeshBasicMaterial );
+		this.addMaterial( MeshLambertNodeMaterial, MeshLambertMaterial );
+		this.addMaterial( MeshNormalNodeMaterial, MeshNormalMaterial );
+		this.addMaterial( MeshMatcapNodeMaterial, MeshMatcapMaterial );
+		this.addMaterial( LineBasicNodeMaterial, LineBasicMaterial );
+		this.addMaterial( LineDashedNodeMaterial, LineDashedMaterial );
+		this.addMaterial( PointsNodeMaterial, PointsMaterial );
+		this.addMaterial( SpriteNodeMaterial, SpriteMaterial );
+		this.addMaterial( ShadowNodeMaterial, ShadowMaterial );
+
+		this.addLight( PointLightNode, PointLight );
+		this.addLight( DirectionalLightNode, DirectionalLight );
+		this.addLight( RectAreaLightNode, RectAreaLight );
+		this.addLight( SpotLightNode, SpotLight );
+		this.addLight( AmbientLightNode, AmbientLight );
+		this.addLight( HemisphereLightNode, HemisphereLight );
+		this.addLight( LightProbeNode, LightProbe );
+		this.addLight( IESSpotLightNode, IESSpotLight );
+
+		this.addToneMapping( TMF.LinearToneMapping, LinearToneMapping );
+		this.addToneMapping( TMF.ReinhardToneMapping, ReinhardToneMapping );
+		this.addToneMapping( TMF.CineonToneMapping, CineonToneMapping );
+		this.addToneMapping( TMF.ACESFilmicToneMapping, ACESFilmicToneMapping );
+		this.addToneMapping( TMF.AgXToneMapping, AgXToneMapping );
+		this.addToneMapping( TMF.NeutralToneMapping, NeutralToneMapping );
+
+		this.addColorSpace( CSF.LinearTosRGB, getColorSpaceMethod( LinearSRGBColorSpace, SRGBColorSpace ) );
+		this.addColorSpace( CSF.sRGBToLinear, getColorSpaceMethod( SRGBColorSpace, LinearSRGBColorSpace ) );
+
+	}
+
+}
+
+export default StandardNodeLibrary;

package/src/renderers/shaders/ShaderChunk/batching_pars_vertex.glsl.js

@@ -1,7 +1,12 @@
 export default /* glsl */`
 #ifdef USE_BATCHING
-	attribute float batchId;
+	#if ! defined( GL_ANGLE_multi_draw )
+	#define gl_DrawID _gl_DrawID
+	uniform int _gl_DrawID;
+	#endif
+
 	uniform highp sampler2D batchingTexture;
+	uniform highp usampler2D batchingIdTexture;
 	mat4 getBatchingMatrix( const in float i ) {
 
 		int size = textureSize( batchingTexture, 0 ).x;
@@ -15,6 +20,16 @@ export default /* glsl */`
 		return mat4( v1, v2, v3, v4 );
 
 	}
+
+	float getIndirectIndex( const in int i ) {
+
+		int size = textureSize( batchingIdTexture, 0 ).x;
+		int x = i % size;
+		int y = i / size;
+		return float( texelFetch( batchingIdTexture, ivec2( x, y ), 0 ).r );
+
+	}
+
 #endif
 
 #ifdef USE_BATCHING_COLOR

package/src/renderers/shaders/ShaderChunk/batching_vertex.glsl.js

@@ -1,5 +1,5 @@
 export default /* glsl */`
 #ifdef USE_BATCHING
-	mat4 batchingMatrix = getBatchingMatrix( batchId );
+	mat4 batchingMatrix = getBatchingMatrix( getIndirectIndex( gl_DrawID ) );
 #endif
 `;

package/src/renderers/shaders/ShaderChunk/color_vertex.glsl.js

@@ -23,7 +23,7 @@ export default /* glsl */`
 
 #ifdef USE_BATCHING_COLOR
 
-	vec3 batchingColor = getBatchingColor( batchId );
+	vec3 batchingColor = getBatchingColor( getIndirectIndex( gl_DrawID ) );
 
 	vColor.xyz *= batchingColor.xyz;
 

package/src/renderers/shaders/ShaderChunk/colorspace_pars_fragment.glsl.js

@@ -32,13 +32,4 @@ vec4 sRGBTransferOETF( in vec4 value ) {
 	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
 }
 
-// @deprecated, r156
-vec4 LinearToLinear( in vec4 value ) {
-	return value;
-}
-
-// @deprecated, r156
-vec4 LinearTosRGB( in vec4 value ) {
-	return sRGBTransferOETF( value );
-}
 `;

package/src/renderers/shaders/ShaderChunk/common.glsl.js

@@ -85,16 +85,6 @@ mat3 transposeMat3( const in mat3 m ) {
 
 }
 
-float luminance( const in vec3 rgb ) {
-
-	// assumes rgb is in linear color space with sRGB primaries and D65 white point
-
-	const vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );
-
-	return dot( weights, rgb );
-
-}
-
 bool isPerspectiveMatrix( mat4 m ) {
 
 	return m[ 2 ][ 3 ] == - 1.0;

package/src/renderers/shaders/ShaderChunk/lights_fragment_begin.glsl.js

@@ -68,7 +68,7 @@ IncidentLight directLight;
 
 		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
 		pointLightShadow = pointLightShadows[ i ];
-		directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
 		#endif
 
 		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
@@ -116,7 +116,7 @@ IncidentLight directLight;
 
 		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
 		spotLightShadow = spotLightShadows[ i ];
-		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
 		#endif
 
 		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
@@ -142,7 +142,7 @@ IncidentLight directLight;
 
 		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
 		directionalLightShadow = directionalLightShadows[ i ];
-		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
 		#endif
 
 		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );

package/src/renderers/shaders/ShaderChunk/packing.glsl.js

@@ -9,36 +9,68 @@ vec3 unpackRGBToNormal( const in vec3 rgb ) {
 
 const float PackUpscale = 256. / 255.; // fraction -> 0..1 (including 1)
 const float UnpackDownscale = 255. / 256.; // 0..1 -> fraction (excluding 1)
+const float ShiftRight8 = 1. / 256.;
+const float Inv255 = 1. / 255.;
 
-const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
-const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
+const vec4 PackFactors = vec4( 1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0 );
 
-const float ShiftRight8 = 1. / 256.;
+const vec2 UnpackFactors2 = vec2( UnpackDownscale, 1.0 / PackFactors.g );
+const vec3 UnpackFactors3 = vec3( UnpackDownscale / PackFactors.rg, 1.0 / PackFactors.b );
+const vec4 UnpackFactors4 = vec4( UnpackDownscale / PackFactors.rgb, 1.0 / PackFactors.a );
 
 vec4 packDepthToRGBA( const in float v ) {
-	vec4 r = vec4( fract( v * PackFactors ), v );
-	r.yzw -= r.xyz * ShiftRight8; // tidy overflow
-	return r * PackUpscale;
+	if( v <= 0.0 )
+		return vec4( 0., 0., 0., 0. );
+	if( v >= 1.0 )
+		return vec4( 1., 1., 1., 1. );
+	float vuf;
+	float af = modf( v * PackFactors.a, vuf );
+	float bf = modf( vuf * ShiftRight8, vuf );
+	float gf = modf( vuf * ShiftRight8, vuf );
+	return vec4( vuf * Inv255, gf * PackUpscale, bf * PackUpscale, af );
+}
+
+vec3 packDepthToRGB( const in float v ) {
+	if( v <= 0.0 )
+		return vec3( 0., 0., 0. );
+	if( v >= 1.0 )
+		return vec3( 1., 1., 1. );
+	float vuf;
+	float bf = modf( v * PackFactors.b, vuf );
+	float gf = modf( vuf * ShiftRight8, vuf );
+	// the 0.9999 tweak is unimportant, very tiny empirical improvement
+	// return vec3( vuf * Inv255, gf * PackUpscale, bf * 0.9999 );
+	return vec3( vuf * Inv255, gf * PackUpscale, bf );
+}
+
+vec2 packDepthToRG( const in float v ) {
+	if( v <= 0.0 )
+		return vec2( 0., 0. );
+	if( v >= 1.0 )
+		return vec2( 1., 1. );
+	float vuf;
+	float gf = modf( v * 256., vuf );
+	return vec2( vuf * Inv255, gf );
 }
 
 float unpackRGBAToDepth( const in vec4 v ) {
-	return dot( v, UnpackFactors );
+	return dot( v, UnpackFactors4 );
 }
 
-vec2 packDepthToRG( in highp float v ) {
-	return packDepthToRGBA( v ).yx;
+float unpackRGBToDepth( const in vec3 v ) {
+	return dot( v, UnpackFactors3 );
 }
 
-float unpackRGToDepth( const in highp vec2 v ) {
-	return unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );
+float unpackRGToDepth( const in vec2 v ) {
+	return v.r * UnpackFactors2.r + v.g * UnpackFactors2.g;
 }
 
-vec4 pack2HalfToRGBA( vec2 v ) {
+vec4 pack2HalfToRGBA( const in vec2 v ) {
 	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
 	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
 }
 
-vec2 unpackRGBATo2Half( vec4 v ) {
+vec2 unpackRGBATo2Half( const in vec4 v ) {
 	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
 }
 

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl.js

@@ -19,6 +19,7 @@ export default /* glsl */`
 		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
 
 		struct DirectionalLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;
@@ -34,6 +35,7 @@ export default /* glsl */`
 		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
 
 		struct SpotLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;
@@ -50,6 +52,7 @@ export default /* glsl */`
 		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
 
 		struct PointLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;
@@ -103,7 +106,7 @@ export default /* glsl */`
 
 	}
 
-	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
+	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
 
 		float shadow = 1.0;
 
@@ -196,7 +199,7 @@ export default /* glsl */`
 
 		}
 
-		return shadow;
+		return mix( 1.0, shadow, shadowIntensity );
 
 	}
 
@@ -271,7 +274,7 @@ export default /* glsl */`
 
 	}
 
-	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
+	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
 
 		float shadow = 1.0;
 
@@ -316,7 +319,7 @@ export default /* glsl */`
 
 		}
 
-		return shadow;
+		return mix( 1.0, shadow, shadowIntensity );
 
 	}
 

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl.js

@@ -15,6 +15,7 @@ export default /* glsl */`
 		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
 
 		struct DirectionalLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;
@@ -28,6 +29,7 @@ export default /* glsl */`
 	#if NUM_SPOT_LIGHT_SHADOWS > 0
 
 		struct SpotLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;
@@ -44,6 +46,7 @@ export default /* glsl */`
 		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
 
 		struct PointLightShadow {
+			float shadowIntensity;
 			float shadowBias;
 			float shadowNormalBias;
 			float shadowRadius;

package/src/renderers/shaders/ShaderChunk/shadowmask_pars_fragment.glsl.js

@@ -13,7 +13,7 @@ float getShadowMask() {
 	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
 
 		directionalLight = directionalLightShadows[ i ];
-		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowIntensity, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
 
 	}
 	#pragma unroll_loop_end
@@ -28,7 +28,7 @@ float getShadowMask() {
 	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
 
 		spotLight = spotLightShadows[ i ];
-		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
+		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowIntensity, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
 
 	}
 	#pragma unroll_loop_end
@@ -43,7 +43,7 @@ float getShadowMask() {
 	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
 
 		pointLight = pointLightShadows[ i ];
-		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
+		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowIntensity, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
 
 	}
 	#pragma unroll_loop_end

package/src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl.js

@@ -22,9 +22,9 @@ vec3 ReinhardToneMapping( vec3 color ) {
 }
 
 // source: http://filmicworlds.com/blog/filmic-tonemapping-operators/
-vec3 OptimizedCineonToneMapping( vec3 color ) {
+vec3 CineonToneMapping( vec3 color ) {
 
-	// optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
+	// filmic operator by Jim Hejl and Richard Burgess-Dawson
 	color *= toneMappingExposure;
 	color = max( vec3( 0.0 ), color - 0.004 );
 	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );

package/src/renderers/shaders/ShaderLib/depth.glsl.js

@@ -91,6 +91,14 @@ void main() {
 
 		gl_FragColor = packDepthToRGBA( fragCoordZ );
 
+	#elif DEPTH_PACKING == 3202
+
+		gl_FragColor = vec4( packDepthToRGB( fragCoordZ ), 1.0 );
+
+	#elif DEPTH_PACKING == 3203
+
+		gl_FragColor = vec4( packDepthToRG( fragCoordZ ), 0.0, 1.0 );
+
 	#endif
 
 }

package/src/renderers/shaders/UniformsLib.js

@@ -130,6 +130,7 @@ const UniformsLib = {
 		} },
 
 		directionalLightShadows: { value: [], properties: {
+			shadowIntensity: 1,
 			shadowBias: {},
 			shadowNormalBias: {},
 			shadowRadius: {},
@@ -150,6 +151,7 @@ const UniformsLib = {
 		} },
 
 		spotLightShadows: { value: [], properties: {
+			shadowIntensity: 1,
 			shadowBias: {},
 			shadowNormalBias: {},
 			shadowRadius: {},
@@ -168,6 +170,7 @@ const UniformsLib = {
 		} },
 
 		pointLightShadows: { value: [], properties: {
+			shadowIntensity: 1,
 			shadowBias: {},
 			shadowNormalBias: {},
 			shadowRadius: {},

package/src/renderers/webgl/WebGLAttributes.js

@@ -145,6 +145,8 @@ function WebGLAttributes( gl ) {
 
 	function update( attribute, bufferType ) {
 
+		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
+
 		if ( attribute.isGLBufferAttribute ) {
 
 			const cached = buffers.get( attribute );
@@ -164,8 +166,6 @@ function WebGLAttributes( gl ) {
 
 		}
 
-		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
-
 		const data = buffers.get( attribute );
 
 		if ( data === undefined ) {