@gnsx/three 0.184.0

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

@@ -0,0 +1,8 @@
+export default /* glsl */`
+#ifdef USE_LOGARITHMIC_DEPTH_BUFFER
+
+	varying float vFragDepth;
+	varying float vIsPerspective;
+
+#endif
+`;

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

@@ -0,0 +1,8 @@
+export default /* glsl */`
+#ifdef USE_LOGARITHMIC_DEPTH_BUFFER
+
+	vFragDepth = 1.0 + gl_Position.w;
+	vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
+
+#endif
+`;

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

@@ -0,0 +1,17 @@
+export default /* glsl */`
+#ifdef USE_MAP
+
+	vec4 sampledDiffuseColor = texture2D( map, vMapUv );
+
+	#ifdef DECODE_VIDEO_TEXTURE
+
+		// use inline sRGB decode until browsers properly support SRGB8_ALPHA8 with video textures (#26516)
+
+		sampledDiffuseColor = sRGBTransferEOTF( sampledDiffuseColor );
+
+	#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,27 @@
+export default /* glsl */`
+#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+
+	#if defined( USE_POINTS_UV )
+
+		vec2 uv = vUv;
+
+	#else
+
+		vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
+
+	#endif
+
+#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,27 @@
+export default /* glsl */`
+#if defined( USE_POINTS_UV )
+
+	varying vec2 vUv;
+
+#else
+
+	#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+
+		uniform mat3 uvTransform;
+
+	#endif
+
+#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, vMetalnessMapUv );
+
+	// 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 )
+
+	// 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/morphinstance_vertex.glsl.js

@@ -0,0 +1,14 @@
+export default /* glsl */`
+#ifdef USE_INSTANCING_MORPH
+
+	float morphTargetInfluences[ MORPHTARGETS_COUNT ];
+
+	float morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;
+
+	for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+		morphTargetInfluences[i] =  texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;
+
+	}
+#endif
+`;

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

@@ -0,0 +1,16 @@
+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;
+
+	for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+		if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,26 @@
+export default /* glsl */`
+#ifdef USE_MORPHTARGETS
+
+	#ifndef USE_INSTANCING_MORPH
+
+		uniform float morphTargetBaseInfluence;
+		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
+
+	#endif
+
+	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 );
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,16 @@
+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;
+
+	for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+
+		if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,76 @@
+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 *= faceDirection;
+
+	#endif
+
+#endif
+
+#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )
+
+	#ifdef USE_TANGENT
+
+		mat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
+
+	#else
+
+		mat3 tbn = getTangentFrame( - vViewPosition, normal,
+		#if defined( USE_NORMALMAP )
+			vNormalMapUv
+		#elif defined( USE_CLEARCOAT_NORMALMAP )
+			vClearcoatNormalMapUv
+		#else
+			vUv
+		#endif
+		);
+
+	#endif
+
+	#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
+
+		tbn[0] *= faceDirection;
+		tbn[1] *= faceDirection;
+
+	#endif
+
+#endif
+
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	#ifdef USE_TANGENT
+
+		mat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
+
+	#else
+
+		mat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );
+
+	#endif
+
+	#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
+
+		tbn2[0] *= faceDirection;
+		tbn2[1] *= faceDirection;
+
+	#endif
+
+#endif
+
+// non perturbed normal for clearcoat among others
+
+vec3 nonPerturbedNormal = normal;
+
+`;

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

@@ -0,0 +1,40 @@
+export default /* glsl */`
+
+#ifdef USE_NORMALMAP_OBJECTSPACE
+
+	normal = texture2D( normalMap, vNormalMapUv ).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( USE_NORMALMAP_TANGENTSPACE )
+
+	vec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;
+
+	#if defined( USE_PACKED_NORMALMAP )
+
+		mapN = vec3( mapN.xy, sqrt( saturate( 1.0 - dot( mapN.xy, mapN.xy ) ) ) );
+
+	#endif
+
+	mapN.xy *= normalScale;
+
+	normal = normalize( tbn * mapN );
+
+#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 USE_NORMALMAP_OBJECTSPACE
+
+	uniform mat3 normalMatrix;
+
+#endif
+
+#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )
+
+	// Normal Mapping Without Precomputed Tangents
+	// http://www.thetenthplanet.de/archives/1180
+
+	mat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {
+
+		vec3 q0 = dFdx( eye_pos.xyz );
+		vec3 q1 = dFdy( eye_pos.xyz );
+		vec2 st0 = dFdx( uv.st );
+		vec2 st1 = dFdy( uv.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 : inversesqrt( det );
+
+		return mat3( T * scale, B * scale, N );
+
+	}
+
+#endif
+`;

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

@@ -0,0 +1,11 @@
+export default /* glsl */`
+#ifdef OPAQUE
+diffuseColor.a = 1.0;
+#endif
+
+#ifdef USE_TRANSMISSION
+diffuseColor.a *= material.transmissionAlpha;
+#endif
+
+gl_FragColor = vec4( outgoingLight, diffuseColor.a );
+`;

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

@@ -0,0 +1,116 @@
+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 float ShiftRight8 = 1. / 256.;
+const float Inv255 = 1. / 255.;
+
+const vec4 PackFactors = vec4( 1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0 );
+
+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 ) {
+	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, UnpackFactors4 );
+}
+
+float unpackRGBToDepth( const in vec3 v ) {
+	return dot( v, UnpackFactors3 );
+}
+
+float unpackRGToDepth( const in vec2 v ) {
+	return v.r * UnpackFactors2.r + v.g * UnpackFactors2.g;
+}
+
+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( const in vec4 v ) {
+	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
+}
+
+// NOTE: viewZ, the z-coordinate in camera space, is negative for points in front of the camera
+
+float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
+	// -near maps to 0; -far maps to 1
+	return ( viewZ + near ) / ( near - far );
+}
+
+float orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {
+
+	#ifdef USE_REVERSED_DEPTH_BUFFER
+	
+		return depth * ( far - near ) - far;
+
+	#else
+
+		return depth * ( near - far ) - near;
+
+	#endif
+}
+
+// NOTE: https://twitter.com/gonnavis/status/1377183786949959682
+
+float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
+	// -near maps to 0; -far maps to 1
+	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
+}
+
+float perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {
+	
+	#ifdef USE_REVERSED_DEPTH_BUFFER
+
+		return ( near * far ) / ( ( near - far ) * depth - near );
+
+	#else
+
+		return ( near * far ) / ( ( far - near ) * depth - far );
+
+	#endif
+}
+`;

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

@@ -0,0 +1,7 @@
+export default /* glsl */`
+#ifdef PREMULTIPLIED_ALPHA
+
+	gl_FragColor.rgb *= gl_FragColor.a;
+
+#endif
+`;

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

@@ -0,0 +1,19 @@
+export default /* glsl */`
+vec4 mvPosition = vec4( transformed, 1.0 );
+
+#ifdef USE_BATCHING
+
+	mvPosition = batchingMatrix * mvPosition;
+
+#endif
+
+#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, vRoughnessMapUv );
+
+	// 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
+`;