@needle-tools/three 0.145.0

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

@@ -0,0 +1,16 @@
+export default /* glsl */`
+#ifdef USE_LOGDEPTHBUF
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		varying float vFragDepth;
+		varying float vIsPerspective;
+
+	#else
+
+		uniform float logDepthBufFC;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,22 @@
+export default /* glsl */`
+#ifdef USE_LOGDEPTHBUF
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		vFragDepth = 1.0 + gl_Position.w;
+		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
+
+	#else
+
+		if ( isPerspectiveMatrix( projectionMatrix ) ) {
+
+			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
+
+			gl_Position.z *= gl_Position.w;
+
+		}
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,17 @@
+export default /* glsl */`
+#ifdef USE_MAP
+
+	vec4 sampledDiffuseColor = texture2D( map, vUv );
+
+	#ifdef DECODE_VIDEO_TEXTURE
+
+		// inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved)
+
+		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
+
+	#endif
+
+	diffuseColor *= sampledDiffuseColor;
+
+#endif
+`;

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

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

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

@@ -0,0 +1,19 @@
+export default /* glsl */`
+#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+
+	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
+
+#endif
+
+#ifdef USE_MAP
+
+	diffuseColor *= texture2D( map, uv );
+
+#endif
+
+#ifdef USE_ALPHAMAP
+
+	diffuseColor.a *= texture2D( alphaMap, uv ).g;
+
+#endif
+`;

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

@@ -0,0 +1,19 @@
+export default /* glsl */`
+#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+
+	uniform mat3 uvTransform;
+
+#endif
+
+#ifdef USE_MAP
+
+	uniform sampler2D map;
+
+#endif
+
+#ifdef USE_ALPHAMAP
+
+	uniform sampler2D alphaMap;
+
+#endif
+`;

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

@@ -0,0 +1,12 @@
+export default /* glsl */`
+float metalnessFactor = metalness;
+
+#ifdef USE_METALNESSMAP
+
+	vec4 texelMetalness = texture2D( metalnessMap, vUv );
+
+	// reads channel B, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
+	metalnessFactor *= texelMetalness.b;
+
+#endif
+`;

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

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

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

@@ -0,0 +1,24 @@
+export default /* glsl */`
+#if defined( USE_MORPHCOLORS ) && defined( MORPHTARGETS_TEXTURE )
+
+	// morphTargetBaseInfluence is set based on BufferGeometry.morphTargetsRelative value:
+	// When morphTargetsRelative is false, this is set to 1 - sum(influences); this results in normal = sum((target - base) * influence)
+	// When morphTargetsRelative is true, this is set to 1; as a result, all morph targets are simply added to the base after weighting
+	vColor *= morphTargetBaseInfluence;
+
+	for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+		#if defined( USE_COLOR_ALPHA )
+
+			if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];
+
+		#elif defined( USE_COLOR )
+
+			if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];
+
+		#endif
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,27 @@
+export default /* glsl */`
+#ifdef USE_MORPHNORMALS
+
+	// morphTargetBaseInfluence is set based on BufferGeometry.morphTargetsRelative value:
+	// When morphTargetsRelative is false, this is set to 1 - sum(influences); this results in normal = sum((target - base) * influence)
+	// When morphTargetsRelative is true, this is set to 1; as a result, all morph targets are simply added to the base after weighting
+	objectNormal *= morphTargetBaseInfluence;
+
+	#ifdef MORPHTARGETS_TEXTURE
+
+		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];
+
+		}
+
+	#else
+
+		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
+		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
+		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
+		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,38 @@
+export default /* glsl */`
+#ifdef USE_MORPHTARGETS
+
+	uniform float morphTargetBaseInfluence;
+
+	#ifdef MORPHTARGETS_TEXTURE
+
+		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
+		uniform sampler2DArray morphTargetsTexture;
+		uniform ivec2 morphTargetsTextureSize;
+
+		vec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {
+
+			int texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;
+			int y = texelIndex / morphTargetsTextureSize.x;
+			int x = texelIndex - y * morphTargetsTextureSize.x;
+
+			ivec3 morphUV = ivec3( x, y, morphTargetIndex );
+			return texelFetch( morphTargetsTexture, morphUV, 0 );
+
+		}
+
+	#else
+
+		#ifndef USE_MORPHNORMALS
+
+			uniform float morphTargetInfluences[ 8 ];
+
+		#else
+
+			uniform float morphTargetInfluences[ 4 ];
+
+		#endif
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,36 @@
+export default /* glsl */`
+#ifdef USE_MORPHTARGETS
+
+	// morphTargetBaseInfluence is set based on BufferGeometry.morphTargetsRelative value:
+	// When morphTargetsRelative is false, this is set to 1 - sum(influences); this results in position = sum((target - base) * influence)
+	// When morphTargetsRelative is true, this is set to 1; as a result, all morph targets are simply added to the base after weighting
+	transformed *= morphTargetBaseInfluence;
+
+	#ifdef MORPHTARGETS_TEXTURE
+
+		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+			if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];
+
+		}
+
+	#else
+
+		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
+		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
+		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
+		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
+
+		#ifndef USE_MORPHNORMALS
+
+			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
+			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
+			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
+			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
+
+		#endif
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,46 @@
+export default /* glsl */`
+float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
+
+#ifdef FLAT_SHADED
+
+	vec3 fdx = dFdx( vViewPosition );
+	vec3 fdy = dFdy( vViewPosition );
+	vec3 normal = normalize( cross( fdx, fdy ) );
+
+#else
+
+	vec3 normal = normalize( vNormal );
+
+	#ifdef DOUBLE_SIDED
+
+		normal = normal * faceDirection;
+
+	#endif
+
+	#ifdef USE_TANGENT
+
+		vec3 tangent = normalize( vTangent );
+		vec3 bitangent = normalize( vBitangent );
+
+		#ifdef DOUBLE_SIDED
+
+			tangent = tangent * faceDirection;
+			bitangent = bitangent * faceDirection;
+
+		#endif
+
+		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
+
+			mat3 vTBN = mat3( tangent, bitangent, normal );
+
+		#endif
+
+	#endif
+
+#endif
+
+// non perturbed normal for clearcoat among others
+
+vec3 geometryNormal = normal;
+
+`;

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

@@ -0,0 +1,41 @@
+export default /* glsl */`
+
+#ifdef OBJECTSPACE_NORMALMAP
+
+	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0; // overrides both flatShading and attribute normals
+
+	#ifdef FLIP_SIDED
+
+		normal = - normal;
+
+	#endif
+
+	#ifdef DOUBLE_SIDED
+
+		normal = normal * faceDirection;
+
+	#endif
+
+	normal = normalize( normalMatrix * normal );
+
+#elif defined( TANGENTSPACE_NORMALMAP )
+
+	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
+	mapN.xy *= normalScale;
+
+	#ifdef USE_TANGENT
+
+		normal = normalize( vTBN * mapN );
+
+	#else
+
+		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
+
+	#endif
+
+#elif defined( USE_BUMPMAP )
+
+	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
+
+#endif
+`;

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

@@ -0,0 +1,14 @@
+export default /* glsl */`
+#ifndef FLAT_SHADED
+
+	varying vec3 vNormal;
+
+	#ifdef USE_TANGENT
+
+		varying vec3 vTangent;
+		varying vec3 vBitangent;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,14 @@
+export default /* glsl */`
+#ifndef FLAT_SHADED
+
+	varying vec3 vNormal;
+
+	#ifdef USE_TANGENT
+
+		varying vec3 vTangent;
+		varying vec3 vBitangent;
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,14 @@
+export default /* glsl */`
+#ifndef FLAT_SHADED // normal is computed with derivatives when FLAT_SHADED
+
+	vNormal = normalize( transformedNormal );
+
+	#ifdef USE_TANGENT
+
+		vTangent = normalize( transformedTangent );
+		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
+
+	#endif
+
+#endif
+`;

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

@@ -0,0 +1,43 @@
+export default /* glsl */`
+#ifdef USE_NORMALMAP
+
+	uniform sampler2D normalMap;
+	uniform vec2 normalScale;
+
+#endif
+
+#ifdef OBJECTSPACE_NORMALMAP
+
+	uniform mat3 normalMatrix;
+
+#endif
+
+#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
+
+	// Normal Mapping Without Precomputed Tangents
+	// http://www.thetenthplanet.de/archives/1180
+
+	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
+
+		vec3 q0 = dFdx( eye_pos.xyz );
+		vec3 q1 = dFdy( eye_pos.xyz );
+		vec2 st0 = dFdx( vUv.st );
+		vec2 st1 = dFdy( vUv.st );
+
+		vec3 N = surf_norm; // normalized
+
+		vec3 q1perp = cross( q1, N );
+		vec3 q0perp = cross( N, q0 );
+
+		vec3 T = q1perp * st0.x + q0perp * st1.x;
+		vec3 B = q1perp * st0.y + q0perp * st1.y;
+
+		float det = max( dot( T, T ), dot( B, B ) );
+		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
+
+		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,12 @@
+export default /* glsl */`
+#ifdef OPAQUE
+diffuseColor.a = 1.0;
+#endif
+
+// https://github.com/mrdoob/three.js/pull/22425
+#ifdef USE_TRANSMISSION
+diffuseColor.a *= material.transmissionAlpha + 0.1;
+#endif
+
+gl_FragColor = vec4( outgoingLight, diffuseColor.a );
+`;

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

@@ -0,0 +1,54 @@
+export default /* glsl */`
+vec3 packNormalToRGB( const in vec3 normal ) {
+	return normalize( normal ) * 0.5 + 0.5;
+}
+
+vec3 unpackRGBToNormal( const in vec3 rgb ) {
+	return 2.0 * rgb.xyz - 1.0;
+}
+
+const float PackUpscale = 256. / 255.; // fraction -> 0..1 (including 1)
+const float UnpackDownscale = 255. / 256.; // 0..1 -> fraction (excluding 1)
+
+const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
+const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
+
+const float ShiftRight8 = 1. / 256.;
+
+vec4 packDepthToRGBA( const in float v ) {
+	vec4 r = vec4( fract( v * PackFactors ), v );
+	r.yzw -= r.xyz * ShiftRight8; // tidy overflow
+	return r * PackUpscale;
+}
+
+float unpackRGBAToDepth( const in vec4 v ) {
+	return dot( v, UnpackFactors );
+}
+
+vec4 pack2HalfToRGBA( 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 ) {
+	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
+}
+
+// NOTE: viewZ/eyeZ is < 0 when in front of the camera per OpenGL conventions
+
+float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
+	return ( viewZ + near ) / ( near - far );
+}
+float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
+	return linearClipZ * ( near - far ) - near;
+}
+
+// NOTE: https://twitter.com/gonnavis/status/1377183786949959682
+
+float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
+	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
+}
+float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
+	return ( near * far ) / ( ( far - near ) * invClipZ - far );
+}
+`;

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

@@ -0,0 +1,8 @@
+export default /* glsl */`
+#ifdef PREMULTIPLIED_ALPHA
+
+	// Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
+	gl_FragColor.rgb *= gl_FragColor.a;
+
+#endif
+`;

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

@@ -0,0 +1,13 @@
+export default /* glsl */`
+vec4 mvPosition = vec4( transformed, 1.0 );
+
+#ifdef USE_INSTANCING
+
+	mvPosition = instanceMatrix * mvPosition;
+
+#endif
+
+mvPosition = modelViewMatrix * mvPosition;
+
+gl_Position = projectionMatrix * mvPosition;
+`;

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

@@ -0,0 +1,12 @@
+export default /* glsl */`
+float roughnessFactor = roughness;
+
+#ifdef USE_ROUGHNESSMAP
+
+	vec4 texelRoughness = texture2D( roughnessMap, vUv );
+
+	// reads channel G, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
+	roughnessFactor *= texelRoughness.g;
+
+#endif
+`;

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

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