@needle-tools/three 0.145.0

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

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

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

@@ -0,0 +1,191 @@
+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 );
+
+		vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;
+
+		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_v0 0.339
+	#define cubeUV_m0 - 2.0
+	#define cubeUV_r1 0.8
+	#define cubeUV_v1 0.276
+	#define cubeUV_m1 - 1.0
+	#define cubeUV_r4 0.4
+	#define cubeUV_v4 0.046
+	#define cubeUV_m4 2.0
+	#define cubeUV_r5 0.305
+	#define cubeUV_v5 0.016
+	#define cubeUV_m5 3.0
+	#define cubeUV_r6 0.21
+	#define cubeUV_v6 0.0038
+	#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 );
+}
+`;

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

@@ -0,0 +1,36 @@
+export default /* glsl */`
+vec3 transformedNormal = objectNormal;
+
+#ifdef USE_INSTANCING
+
+	// this is in lieu of a per-instance normal-matrix
+	// shear transforms in the instance matrix are not supported
+
+	mat3 m = mat3( instanceMatrix );
+
+	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
+
+	transformedNormal = m * transformedNormal;
+
+#endif
+
+transformedNormal = normalMatrix * transformedNormal;
+
+#ifdef FLIP_SIDED
+
+	transformedNormal = - transformedNormal;
+
+#endif
+
+#ifdef USE_TANGENT
+
+	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
+
+	#ifdef FLIP_SIDED
+
+		transformedTangent = - transformedTangent;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,9 @@
+export default /* glsl */`
+#ifdef USE_DISPLACEMENTMAP
+
+	uniform sampler2D displacementMap;
+	uniform float displacementScale;
+	uniform float displacementBias;
+
+#endif
+`;

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

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef USE_DISPLACEMENTMAP
+
+	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
+
+#endif
+`;

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

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef DITHERING
+
+	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
+
+#endif
+`;

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

@@ -0,0 +1,20 @@
+export default /* glsl */`
+#ifdef DITHERING
+
+	// based on https://www.shadertoy.com/view/MslGR8
+	vec3 dithering( vec3 color ) {
+		//Calculate grid position
+		float grid_position = rand( gl_FragCoord.xy );
+
+		//Shift the individual colors differently, thus making it even harder to see the dithering pattern
+		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
+
+		//modify shift according to grid position.
+		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
+
+		//shift the color by dither_shift
+		return color + dither_shift_RGB;
+	}
+
+#endif
+`;

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

@@ -0,0 +1,9 @@
+export default /* glsl */`
+#ifdef USE_EMISSIVEMAP
+
+	vec4 emissiveColor = texture2D( emissiveMap, vUv );
+
+	totalEmissiveRadiance *= emissiveColor.rgb;
+
+#endif
+`;

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

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef USE_EMISSIVEMAP
+
+	uniform sampler2D emissiveMap;
+
+#endif
+`;

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

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

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

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

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

@@ -0,0 +1,14 @@
+export default /* glsl */`
+#ifdef USE_ENVMAP
+
+	uniform float envMapIntensity;
+	uniform float flipEnvMap;
+
+	#ifdef ENVMAP_TYPE_CUBE
+		uniform samplerCube envMap;
+	#else
+		uniform sampler2D envMap;
+	#endif
+	
+#endif
+`;

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

@@ -0,0 +1,66 @@
+export default /* glsl */`
+#ifdef USE_ENVMAP
+
+	#ifdef ENV_WORLDPOS
+
+		vec3 cameraToFrag;
+
+		if ( isOrthographic ) {
+
+			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
+
+		} else {
+
+			cameraToFrag = normalize( vWorldPosition - cameraPosition );
+
+		}
+
+		// Transforming Normal Vectors with the Inverse Transformation
+		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+
+		#ifdef ENVMAP_MODE_REFLECTION
+
+			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
+
+		#else
+
+			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
+
+		#endif
+
+	#else
+
+		vec3 reflectVec = vReflect;
+
+	#endif
+
+	#ifdef ENVMAP_TYPE_CUBE
+
+		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
+
+	#elif defined( ENVMAP_TYPE_CUBE_UV )
+
+		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
+
+	#else
+
+		vec4 envColor = vec4( 0.0 );
+
+	#endif
+
+	#ifdef ENVMAP_BLENDING_MULTIPLY
+
+		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
+
+	#elif defined( ENVMAP_BLENDING_MIX )
+
+		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
+
+	#elif defined( ENVMAP_BLENDING_ADD )
+
+		outgoingLight += envColor.xyz * specularStrength * reflectivity;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,21 @@
+export default /* glsl */`
+#ifdef USE_ENVMAP
+
+	uniform float reflectivity;
+
+	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )
+
+		#define ENV_WORLDPOS
+
+	#endif
+
+	#ifdef ENV_WORLDPOS
+
+		varying vec3 vWorldPosition;
+		uniform float refractionRatio;
+	#else
+		varying vec3 vReflect;
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,22 @@
+export default /* glsl */`
+#ifdef USE_ENVMAP
+
+	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )
+
+		#define ENV_WORLDPOS
+
+	#endif
+
+	#ifdef ENV_WORLDPOS
+		
+		varying vec3 vWorldPosition;
+
+	#else
+
+		varying vec3 vReflect;
+		uniform float refractionRatio;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,46 @@
+export default /* glsl */`
+#if defined( USE_ENVMAP )
+
+	vec3 getIBLIrradiance( const in vec3 normal ) {
+
+		#if defined( ENVMAP_TYPE_CUBE_UV )
+
+			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+
+			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
+
+			return PI * envMapColor.rgb * envMapIntensity;
+
+		#else
+
+			return vec3( 0.0 );
+
+		#endif
+
+	}
+
+	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
+
+		#if defined( ENVMAP_TYPE_CUBE_UV )
+
+			vec3 reflectVec = reflect( - viewDir, normal );
+
+			// Mixing the reflection with the normal is more accurate and keeps rough objects from gathering light from behind their tangent plane.
+			reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
+
+			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
+
+			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
+
+			return envMapColor.rgb * envMapIntensity;
+
+		#else
+
+			return vec3( 0.0 );
+
+		#endif
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,37 @@
+export default /* glsl */`
+#ifdef USE_ENVMAP
+
+	#ifdef ENV_WORLDPOS
+
+		vWorldPosition = worldPosition.xyz;
+
+	#else
+
+		vec3 cameraToVertex;
+
+		if ( isOrthographic ) {
+
+			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
+
+		} else {
+
+			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
+
+		}
+
+		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
+
+		#ifdef ENVMAP_MODE_REFLECTION
+
+			vReflect = reflect( cameraToVertex, worldNormal );
+
+		#else
+
+			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
+
+		#endif
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,17 @@
+export default /* glsl */`
+#ifdef USE_FOG
+
+	#ifdef FOG_EXP2
+
+		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
+
+	#else
+
+		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
+
+	#endif
+
+	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
+
+#endif
+`;

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

@@ -0,0 +1,19 @@
+export default /* glsl */`
+#ifdef USE_FOG
+
+	uniform vec3 fogColor;
+	varying float vFogDepth;
+
+	#ifdef FOG_EXP2
+
+		uniform float fogDensity;
+
+	#else
+
+		uniform float fogNear;
+		uniform float fogFar;
+
+	#endif
+
+#endif
+`;