@plastic-software/three 0.167.0

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

@@ -0,0 +1,9 @@
+export default /* glsl */`
+vec3 objectNormal = vec3( normal );
+
+#ifdef USE_TANGENT
+
+	vec3 objectTangent = vec3( tangent.xyz );
+
+#endif
+`;

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

@@ -0,0 +1,33 @@
+export default /* glsl */`
+
+float G_BlinnPhong_Implicit( /* const in float dotNL, const in float dotNV */ ) {
+
+	// geometry term is (n dot l)(n dot v) / 4(n dot l)(n dot v)
+	return 0.25;
+
+}
+
+float D_BlinnPhong( const in float shininess, const in float dotNH ) {
+
+	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
+
+}
+
+vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
+
+	vec3 halfDir = normalize( lightDir + viewDir );
+
+	float dotNH = saturate( dot( normal, halfDir ) );
+	float dotVH = saturate( dot( viewDir, halfDir ) );
+
+	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
+
+	float G = G_BlinnPhong_Implicit( /* dotNL, dotNV */ );
+
+	float D = D_BlinnPhong( shininess, dotNH );
+
+	return F * ( G * D );
+
+} // validated
+
+`;

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

@@ -0,0 +1,43 @@
+export default /* glsl */`
+#ifdef USE_BUMPMAP
+
+	uniform sampler2D bumpMap;
+	uniform float bumpScale;
+
+	// Bump Mapping Unparametrized Surfaces on the GPU by Morten S. Mikkelsen
+	// https://mmikk.github.io/papers3d/mm_sfgrad_bump.pdf
+
+	// Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)
+
+	vec2 dHdxy_fwd() {
+
+		vec2 dSTdx = dFdx( vBumpMapUv );
+		vec2 dSTdy = dFdy( vBumpMapUv );
+
+		float Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;
+		float dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;
+		float dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;
+
+		return vec2( dBx, dBy );
+
+	}
+
+	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
+
+		// normalize is done to ensure that the bump map looks the same regardless of the texture's scale
+		vec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );
+		vec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );
+		vec3 vN = surf_norm; // normalized
+
+		vec3 R1 = cross( vSigmaY, vN );
+		vec3 R2 = cross( vN, vSigmaX );
+
+		float fDet = dot( vSigmaX, R1 ) * faceDirection;
+
+		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
+		return normalize( abs( fDet ) * surf_norm - vGrad );
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef USE_CLEARCOAT
+
+	vec3 clearcoatNormal = nonPerturbedNormal;
+
+#endif
+`;

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

@@ -0,0 +1,10 @@
+export default /* glsl */`
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;
+	clearcoatMapN.xy *= clearcoatNormalScale;
+
+	clearcoatNormal = normalize( tbn2 * clearcoatMapN );
+
+#endif
+`;

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

@@ -0,0 +1,21 @@
+export default /* glsl */`
+
+#ifdef USE_CLEARCOATMAP
+
+	uniform sampler2D clearcoatMap;
+
+#endif
+
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	uniform sampler2D clearcoatNormalMap;
+	uniform vec2 clearcoatNormalScale;
+
+#endif
+
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	uniform sampler2D clearcoatRoughnessMap;
+
+#endif
+`;

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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,9 @@
+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

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

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

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

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+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 );
+}
+
+`;

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

@@ -0,0 +1,137 @@
+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;
+
+}
+
+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
+`;

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

@@ -0,0 +1,186 @@
+export default /* glsl */`
+#ifdef ENVMAP_TYPE_CUBE_UV
+
+	#define cubeUV_minMipLevel 4.0
+	#define cubeUV_minTileSize 16.0
+
+	// These shader functions convert between the UV coordinates of a single face of
+	// a cubemap, the 0-5 integer index of a cube face, and the direction vector for
+	// sampling a textureCube (not generally normalized ).
+
+	float getFace( vec3 direction ) {
+
+		vec3 absDirection = abs( direction );
+
+		float face = - 1.0;
+
+		if ( absDirection.x > absDirection.z ) {
+
+			if ( absDirection.x > absDirection.y )
+
+				face = direction.x > 0.0 ? 0.0 : 3.0;
+
+			else
+
+				face = direction.y > 0.0 ? 1.0 : 4.0;
+
+		} else {
+
+			if ( absDirection.z > absDirection.y )
+
+				face = direction.z > 0.0 ? 2.0 : 5.0;
+
+			else
+
+				face = direction.y > 0.0 ? 1.0 : 4.0;
+
+		}
+
+		return face;
+
+	}
+
+	// RH coordinate system; PMREM face-indexing convention
+	vec2 getUV( vec3 direction, float face ) {
+
+		vec2 uv;
+
+		if ( face == 0.0 ) {
+
+			uv = vec2( direction.z, direction.y ) / abs( direction.x ); // pos x
+
+		} else if ( face == 1.0 ) {
+
+			uv = vec2( - direction.x, - direction.z ) / abs( direction.y ); // pos y
+
+		} else if ( face == 2.0 ) {
+
+			uv = vec2( - direction.x, direction.y ) / abs( direction.z ); // pos z
+
+		} else if ( face == 3.0 ) {
+
+			uv = vec2( - direction.z, direction.y ) / abs( direction.x ); // neg x
+
+		} else if ( face == 4.0 ) {
+
+			uv = vec2( - direction.x, direction.z ) / abs( direction.y ); // neg y
+
+		} else {
+
+			uv = vec2( direction.x, direction.y ) / abs( direction.z ); // neg z
+
+		}
+
+		return 0.5 * ( uv + 1.0 );
+
+	}
+
+	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
+
+		float face = getFace( direction );
+
+		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
+
+		mipInt = max( mipInt, cubeUV_minMipLevel );
+
+		float faceSize = exp2( mipInt );
+
+		highp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0; // #25071
+
+		if ( face > 2.0 ) {
+
+			uv.y += faceSize;
+
+			face -= 3.0;
+
+		}
+
+		uv.x += face * faceSize;
+
+		uv.x += filterInt * 3.0 * cubeUV_minTileSize;
+
+		uv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );
+
+		uv.x *= CUBEUV_TEXEL_WIDTH;
+		uv.y *= CUBEUV_TEXEL_HEIGHT;
+
+		#ifdef texture2DGradEXT
+
+			return texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb; // disable anisotropic filtering
+
+		#else
+
+			return texture2D( envMap, uv ).rgb;
+
+		#endif
+
+	}
+
+	// These defines must match with PMREMGenerator
+
+	#define cubeUV_r0 1.0
+	#define cubeUV_m0 - 2.0
+	#define cubeUV_r1 0.8
+	#define cubeUV_m1 - 1.0
+	#define cubeUV_r4 0.4
+	#define cubeUV_m4 2.0
+	#define cubeUV_r5 0.305
+	#define cubeUV_m5 3.0
+	#define cubeUV_r6 0.21
+	#define cubeUV_m6 4.0
+
+	float roughnessToMip( float roughness ) {
+
+		float mip = 0.0;
+
+		if ( roughness >= cubeUV_r1 ) {
+
+			mip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;
+
+		} else if ( roughness >= cubeUV_r4 ) {
+
+			mip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;
+
+		} else if ( roughness >= cubeUV_r5 ) {
+
+			mip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;
+
+		} else if ( roughness >= cubeUV_r6 ) {
+
+			mip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;
+
+		} else {
+
+			mip = - 2.0 * log2( 1.16 * roughness ); // 1.16 = 1.79^0.25
+		}
+
+		return mip;
+
+	}
+
+	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
+
+		float mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );
+
+		float mipF = fract( mip );
+
+		float mipInt = floor( mip );
+
+		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
+
+		if ( mipF == 0.0 ) {
+
+			return vec4( color0, 1.0 );
+
+		} else {
+
+			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
+
+			return vec4( mix( color0, color1, mipF ), 1.0 );
+
+		}
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,5 @@
+export default /* glsl */`
+void main() {
+	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
+}
+`;

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

@@ -0,0 +1,5 @@
+export default /* glsl */`
+void main() {
+	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+}
+`;