@needle-tools/three 0.154.2 → 0.160.2

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

@@ -1,33 +1,78 @@
-export default /* glsl */`
-#if NUM_CLIPPING_PLANES > 0
-
-	vec4 plane;
-
-	#pragma unroll_loop_start
-	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
-
-		plane = clippingPlanes[ i ];
-		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
-
-	}
-	#pragma unroll_loop_end
-
-	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
-
-		bool clipped = true;
-
-		#pragma unroll_loop_start
-		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
-
-			plane = clippingPlanes[ i ];
-			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
-
-		}
-		#pragma unroll_loop_end
-
-		if ( clipped ) discard;
-
-	#endif
-
-#endif
-`;
+export default /* glsl */`
+#if NUM_CLIPPING_PLANES > 0
+
+	vec4 plane;
+
+	#ifdef ALPHA_TO_COVERAGE
+
+		float distanceToPlane, distanceGradient;
+		float clipOpacity = 1.0;
+
+		#pragma unroll_loop_start
+		for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
+
+			plane = clippingPlanes[ i ];
+			distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;
+			distanceGradient = fwidth( distanceToPlane ) / 2.0;
+			clipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );
+
+			if ( clipOpacity == 0.0 ) discard;
+
+		}
+		#pragma unroll_loop_end
+
+		#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
+
+			float unionClipOpacity = 1.0;
+
+			#pragma unroll_loop_start
+			for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
+
+				plane = clippingPlanes[ i ];
+				distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;
+				distanceGradient = fwidth( distanceToPlane ) / 2.0;
+				unionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );
+
+			}
+			#pragma unroll_loop_end
+
+			clipOpacity *= 1.0 - unionClipOpacity;
+
+		#endif
+
+		diffuseColor.a *= clipOpacity;
+
+		if ( diffuseColor.a == 0.0 ) discard;
+
+	#else
+
+		#pragma unroll_loop_start
+		for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
+
+			plane = clippingPlanes[ i ];
+			if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
+
+		}
+		#pragma unroll_loop_end
+
+		#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
+
+			bool clipped = true;
+
+			#pragma unroll_loop_start
+			for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
+
+				plane = clippingPlanes[ i ];
+				clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
+
+			}
+			#pragma unroll_loop_end
+
+			if ( clipped ) discard;
+
+		#endif
+
+	#endif
+
+#endif
+`;

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

@@ -1,9 +1,9 @@
-export default /* glsl */`
-#if NUM_CLIPPING_PLANES > 0
-
-	varying vec3 vClipPosition;
-
-	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
-
-#endif
-`;
+export default /* glsl */`
+#if NUM_CLIPPING_PLANES > 0
+
+	varying vec3 vClipPosition;
+
+	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
+
+#endif
+`;

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

@@ -1,7 +1,7 @@
-export default /* glsl */`
-#if NUM_CLIPPING_PLANES > 0
-
-	varying vec3 vClipPosition;
-
-#endif
-`;
+export default /* glsl */`
+#if NUM_CLIPPING_PLANES > 0
+
+	varying vec3 vClipPosition;
+
+#endif
+`;

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

@@ -1,7 +1,7 @@
-export default /* glsl */`
-#if NUM_CLIPPING_PLANES > 0
-
-	vClipPosition = - mvPosition.xyz;
-
-#endif
-`;
+export default /* glsl */`
+#if NUM_CLIPPING_PLANES > 0
+
+	vClipPosition = - mvPosition.xyz;
+
+#endif
+`;

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

@@ -1,11 +1,11 @@
-export default /* glsl */`
-#if defined( USE_COLOR_ALPHA )
-
-	diffuseColor *= vColor;
-
-#elif defined( USE_COLOR )
-
-	diffuseColor.rgb *= vColor;
-
-#endif
-`;
+export default /* glsl */`
+#if defined( USE_COLOR_ALPHA )
+
+	diffuseColor *= vColor;
+
+#elif defined( USE_COLOR )
+
+	diffuseColor.rgb *= vColor;
+
+#endif
+`;

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

@@ -1,11 +1,11 @@
-export default /* glsl */`
-#if defined( USE_COLOR_ALPHA )
-
-	varying vec4 vColor;
-
-#elif defined( USE_COLOR )
-
-	varying vec3 vColor;
-
-#endif
-`;
+export default /* glsl */`
+#if defined( USE_COLOR_ALPHA )
+
+	varying vec4 vColor;
+
+#elif defined( USE_COLOR )
+
+	varying vec3 vColor;
+
+#endif
+`;

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

@@ -1,11 +1,11 @@
-export default /* glsl */`
-#if defined( USE_COLOR_ALPHA )
-
-	varying vec4 vColor;
-
-#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
-
-	varying vec3 vColor;
-
-#endif
-`;
+export default /* glsl */`
+#if defined( USE_COLOR_ALPHA )
+
+	varying vec4 vColor;
+
+#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
+
+	varying vec3 vColor;
+
+#endif
+`;

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

@@ -1,23 +1,23 @@
-export default /* glsl */`
-#if defined( USE_COLOR_ALPHA )
-
-	vColor = vec4( 1.0 );
-
-#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
-
-	vColor = vec3( 1.0 );
-
-#endif
-
-#ifdef USE_COLOR
-
-	vColor *= color;
-
-#endif
-
-#ifdef USE_INSTANCING_COLOR
-
-	vColor.xyz *= instanceColor.xyz;
-
-#endif
-`;
+export default /* glsl */`
+#if defined( USE_COLOR_ALPHA )
+
+	vColor = vec4( 1.0 );
+
+#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
+
+	vColor = vec3( 1.0 );
+
+#endif
+
+#ifdef USE_COLOR
+
+	vColor *= color;
+
+#endif
+
+#ifdef USE_INSTANCING_COLOR
+
+	vColor.xyz *= instanceColor.xyz;
+
+#endif
+`;

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

@@ -1,3 +1,3 @@
-export default /* glsl */`
-gl_FragColor = linearToOutputTexel( gl_FragColor );
-`;
+export default /* glsl */`
+gl_FragColor = linearToOutputTexel( gl_FragColor );
+`;

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

@@ -1,11 +1,44 @@
-export default /* glsl */`
-
-vec4 LinearToLinear( in vec4 value ) {
-	return value;
-}
-
-vec4 LinearTosRGB( 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 );
-}
-
-`;
+export default /* glsl */`
+
+// http://www.russellcottrell.com/photo/matrixCalculator.htm
+
+// Linear sRGB => XYZ => Linear Display P3
+const mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(
+	vec3( 0.8224621, 0.177538, 0.0 ),
+	vec3( 0.0331941, 0.9668058, 0.0 ),
+	vec3( 0.0170827, 0.0723974, 0.9105199 )
+);
+
+// Linear Display P3 => XYZ => Linear sRGB
+const mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(
+	vec3( 1.2249401, - 0.2249404, 0.0 ),
+	vec3( - 0.0420569, 1.0420571, 0.0 ),
+	vec3( - 0.0196376, - 0.0786361, 1.0982735 )
+);
+
+vec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {
+	return vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );
+}
+
+vec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {
+	return vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );
+}
+
+vec4 LinearTransferOETF( in vec4 value ) {
+	return value;
+}
+
+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

@@ -1,156 +1,147 @@
-export default /* glsl */`
-#define PI 3.141592653589793
-#define PI2 6.283185307179586
-#define PI_HALF 1.5707963267948966
-#define RECIPROCAL_PI 0.3183098861837907
-#define RECIPROCAL_PI2 0.15915494309189535
-#define EPSILON 1e-6
-
-#ifndef saturate
-// <tonemapping_pars_fragment> may have defined saturate() already
-#define saturate( a ) clamp( a, 0.0, 1.0 )
-#endif
-#define whiteComplement( a ) ( 1.0 - saturate( a ) )
-
-float pow2( const in float x ) { return x*x; }
-vec3 pow2( const in vec3 x ) { return x*x; }
-float pow3( const in float x ) { return x*x*x; }
-float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
-float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
-float average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }
-
-// expects values in the range of [0,1]x[0,1], returns values in the [0,1] range.
-// do not collapse into a single function per: http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
-highp float rand( const in vec2 uv ) {
-
-	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
-	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
-
-	return fract( sin( sn ) * c );
-
-}
-
-#ifdef HIGH_PRECISION
-	float precisionSafeLength( vec3 v ) { return length( v ); }
-#else
-	float precisionSafeLength( vec3 v ) {
-		float maxComponent = max3( abs( v ) );
-		return length( v / maxComponent ) * maxComponent;
-	}
-#endif
-
-struct IncidentLight {
-	vec3 color;
-	vec3 direction;
-	bool visible;
-};
-
-struct ReflectedLight {
-	vec3 directDiffuse;
-	vec3 directSpecular;
-	vec3 indirectDiffuse;
-	vec3 indirectSpecular;
-};
-
-struct GeometricContext {
-	vec3 position;
-	vec3 normal;
-	vec3 viewDir;
-#ifdef USE_CLEARCOAT
-	vec3 clearcoatNormal;
-#endif
-};
-
-#ifdef USE_ALPHAHASH
-
-	varying vec3 vPosition;
-
-#endif
-
-vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
-
-	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
-
-}
-
-vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
-
-	// dir can be either a direction vector or a normal vector
-	// upper-left 3x3 of matrix is assumed to be orthogonal
-
-	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
-
-}
-
-mat3 transposeMat3( const in mat3 m ) {
-
-	mat3 tmp;
-
-	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
-	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
-	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
-
-	return tmp;
-
-}
-
-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;
-
-}
-
-vec2 equirectUv( in vec3 dir ) {
-
-	// dir is assumed to be unit length
-
-	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
-
-	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
-
-	return vec2( u, v );
-
-}
-
-vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
-
-	return RECIPROCAL_PI * diffuseColor;
-
-} // validated
-
-vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
-
-	// Original approximation by Christophe Schlick '94
-	// float fresnel = pow( 1.0 - dotVH, 5.0 );
-
-	// Optimized variant (presented by Epic at SIGGRAPH '13)
-	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
-	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
-
-	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
-
-} // validated
-
-float F_Schlick( const in float f0, const in float f90, const in float dotVH ) {
-
-	// Original approximation by Christophe Schlick '94
-	// float fresnel = pow( 1.0 - dotVH, 5.0 );
-
-	// Optimized variant (presented by Epic at SIGGRAPH '13)
-	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
-	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
-
-	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
-
-} // validated
-`;
+export default /* glsl */`
+#define PI 3.141592653589793
+#define PI2 6.283185307179586
+#define PI_HALF 1.5707963267948966
+#define RECIPROCAL_PI 0.3183098861837907
+#define RECIPROCAL_PI2 0.15915494309189535
+#define EPSILON 1e-6
+
+#ifndef saturate
+// <tonemapping_pars_fragment> may have defined saturate() already
+#define saturate( a ) clamp( a, 0.0, 1.0 )
+#endif
+#define whiteComplement( a ) ( 1.0 - saturate( a ) )
+
+float pow2( const in float x ) { return x*x; }
+vec3 pow2( const in vec3 x ) { return x*x; }
+float pow3( const in float x ) { return x*x*x; }
+float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
+float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
+float average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }
+
+// expects values in the range of [0,1]x[0,1], returns values in the [0,1] range.
+// do not collapse into a single function per: http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
+highp float rand( const in vec2 uv ) {
+
+	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
+	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
+
+	return fract( sin( sn ) * c );
+
+}
+
+#ifdef HIGH_PRECISION
+	float precisionSafeLength( vec3 v ) { return length( v ); }
+#else
+	float precisionSafeLength( vec3 v ) {
+		float maxComponent = max3( abs( v ) );
+		return length( v / maxComponent ) * maxComponent;
+	}
+#endif
+
+struct IncidentLight {
+	vec3 color;
+	vec3 direction;
+	bool visible;
+};
+
+struct ReflectedLight {
+	vec3 directDiffuse;
+	vec3 directSpecular;
+	vec3 indirectDiffuse;
+	vec3 indirectSpecular;
+};
+
+#ifdef USE_ALPHAHASH
+
+	varying vec3 vPosition;
+
+#endif
+
+vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
+
+	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
+
+}
+
+vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
+
+	// dir can be either a direction vector or a normal vector
+	// upper-left 3x3 of matrix is assumed to be orthogonal
+
+	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
+
+}
+
+mat3 transposeMat3( const in mat3 m ) {
+
+	mat3 tmp;
+
+	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
+	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
+	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
+
+	return tmp;
+
+}
+
+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;
+
+}
+
+vec2 equirectUv( in vec3 dir ) {
+
+	// dir is assumed to be unit length
+
+	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
+
+	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
+
+	return vec2( u, v );
+
+}
+
+vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
+
+	return RECIPROCAL_PI * diffuseColor;
+
+} // validated
+
+vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
+
+	// Original approximation by Christophe Schlick '94
+	// float fresnel = pow( 1.0 - dotVH, 5.0 );
+
+	// Optimized variant (presented by Epic at SIGGRAPH '13)
+	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
+
+	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
+
+} // validated
+
+float F_Schlick( const in float f0, const in float f90, const in float dotVH ) {
+
+	// Original approximation by Christophe Schlick '94
+	// float fresnel = pow( 1.0 - dotVH, 5.0 );
+
+	// Optimized variant (presented by Epic at SIGGRAPH '13)
+	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
+
+	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
+
+} // validated
+`;