super-three 0.181.0 → 0.185.0

package/examples/jsm/tsl/lighting/data/SpotLightDataNode.js

@@ -0,0 +1,161 @@
+import { Color, Node, Vector3, Vector4 } from 'three/webgpu';
+import { Loop, NodeUpdateType, getDistanceAttenuation, positionView, renderGroup, smoothstep, uniform, uniformArray, vec3 } from 'three/tsl';
+
+const _lightPosition = /*@__PURE__*/ new Vector3();
+const _targetPosition = /*@__PURE__*/ new Vector3();
+
+const warn = ( message ) => {
+
+	console.warn( `THREE.SpotLightDataNode: ${ message }` );
+
+};
+
+/**
+ * Batched data node for simple spot lights in dynamic lighting mode.
+ *
+ * Projected spot lights keep the default per-light path.
+ *
+ * @augments Node
+ */
+class SpotLightDataNode extends Node {
+
+	static get type() {
+
+		return 'SpotLightDataNode';
+
+	}
+
+	constructor( maxCount = 16 ) {
+
+		super();
+
+		this.maxCount = maxCount;
+		this._lights = [];
+		this._colors = [];
+		this._positionsAndCutoff = [];
+		this._directionsAndDecay = [];
+		this._cones = [];
+
+		for ( let i = 0; i < maxCount; i ++ ) {
+
+			this._colors.push( new Color() );
+			this._positionsAndCutoff.push( new Vector4() );
+			this._directionsAndDecay.push( new Vector4() );
+			this._cones.push( new Vector4() );
+
+		}
+
+		this.colorsNode = uniformArray( this._colors, 'color' ).setGroup( renderGroup );
+		this.positionsAndCutoffNode = uniformArray( this._positionsAndCutoff, 'vec4' ).setGroup( renderGroup );
+		this.directionsAndDecayNode = uniformArray( this._directionsAndDecay, 'vec4' ).setGroup( renderGroup );
+		this.conesNode = uniformArray( this._cones, 'vec4' ).setGroup( renderGroup );
+		this.countNode = uniform( 0, 'int' ).setGroup( renderGroup );
+		this.updateType = NodeUpdateType.RENDER;
+
+	}
+
+	setLights( lights ) {
+
+		if ( lights.length > this.maxCount ) {
+
+			warn( `${ lights.length } lights exceed the configured max of ${ this.maxCount }. Excess lights are ignored.` );
+
+		}
+
+		this._lights = lights;
+
+		return this;
+
+	}
+
+	update( { camera } ) {
+
+		const count = Math.min( this._lights.length, this.maxCount );
+
+		this.countNode.value = count;
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const light = this._lights[ i ];
+
+			this._colors[ i ].copy( light.color ).multiplyScalar( light.intensity );
+
+			_lightPosition.setFromMatrixPosition( light.matrixWorld );
+			_lightPosition.applyMatrix4( camera.matrixWorldInverse );
+
+			const positionAndCutoff = this._positionsAndCutoff[ i ];
+			positionAndCutoff.x = _lightPosition.x;
+			positionAndCutoff.y = _lightPosition.y;
+			positionAndCutoff.z = _lightPosition.z;
+			positionAndCutoff.w = light.distance;
+
+			_lightPosition.setFromMatrixPosition( light.matrixWorld );
+			_targetPosition.setFromMatrixPosition( light.target.matrixWorld );
+			_lightPosition.sub( _targetPosition ).transformDirection( camera.matrixWorldInverse );
+
+			const directionAndDecay = this._directionsAndDecay[ i ];
+			directionAndDecay.x = _lightPosition.x;
+			directionAndDecay.y = _lightPosition.y;
+			directionAndDecay.z = _lightPosition.z;
+			directionAndDecay.w = light.decay;
+
+			const cone = this._cones[ i ];
+			cone.x = Math.cos( light.angle );
+			cone.y = Math.cos( light.angle * ( 1 - light.penumbra ) );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		const surfacePosition = builder.context.positionView || positionView;
+		const { lightingModel, reflectedLight } = builder.context;
+		const dynDiffuse = vec3( 0 ).toVar( 'dynSpotDiffuse' );
+		const dynSpecular = vec3( 0 ).toVar( 'dynSpotSpecular' );
+
+		Loop( this.countNode, ( { i } ) => {
+
+			const positionAndCutoff = this.positionsAndCutoffNode.element( i );
+			const lightViewPosition = positionAndCutoff.xyz;
+			const cutoffDistance = positionAndCutoff.w;
+
+			const directionAndDecay = this.directionsAndDecayNode.element( i );
+			const spotDirection = directionAndDecay.xyz;
+			const decayExponent = directionAndDecay.w;
+
+			const cone = this.conesNode.element( i );
+			const coneCos = cone.x;
+			const penumbraCos = cone.y;
+
+			const lightVector = lightViewPosition.sub( surfacePosition ).toVar();
+			const lightDirection = lightVector.normalize().toVar();
+			const lightDistance = lightVector.length();
+
+			const angleCos = lightDirection.dot( spotDirection );
+			const spotAttenuation = smoothstep( coneCos, penumbraCos, angleCos );
+			const distanceAttenuation = getDistanceAttenuation( {
+				lightDistance,
+				cutoffDistance,
+				decayExponent
+			} );
+
+			const lightColor = this.colorsNode.element( i ).mul( spotAttenuation ).mul( distanceAttenuation ).toVar();
+
+			lightingModel.direct( {
+				lightDirection,
+				lightColor,
+				lightNode: { light: {}, shadowNode: null },
+				reflectedLight: { directDiffuse: dynDiffuse, directSpecular: dynSpecular }
+			}, builder );
+
+		} );
+
+		reflectedLight.directDiffuse.addAssign( dynDiffuse );
+		reflectedLight.directSpecular.addAssign( dynSpecular );
+
+	}
+
+}
+
+export default SpotLightDataNode;

package/examples/jsm/tsl/math/Bayer.js

@@ -1,5 +1,5 @@
-import { TextureLoader } from 'three';
-import { Fn, int, ivec2, textureLoad } from 'three/tsl';
+import { ImageBitmapLoader, Texture } from 'three';
+import { Fn, int, ivec2, textureLoad, screenUV, screenSize, mod, floor, float, vec3 } from 'three/tsl';
 
 /**
  * @module Bayer
@@ -25,10 +25,60 @@ export const bayer16 = Fn( ( [ uv ] ) => {
 
 		const bayer16Base64 = 'data:image/png;base64,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';
 
-		bayer16Texture = new TextureLoader().load( bayer16Base64 );
+		bayer16Texture = new Texture();
+		const loader = new ImageBitmapLoader();
+
+		loader.setOptions( { imageOrientation: 'flipY', premultiplyAlpha: 'none' } );
+
+		loader.load( bayer16Base64, ( imageBitmap ) => {
+
+			bayer16Texture.image = imageBitmap;
+			bayer16Texture.flipY = false;
+			bayer16Texture.needsUpdate = true;
+
+		} );
 
 	}
 
 	return textureLoad( bayer16Texture, ivec2( uv ).mod( int( 16 ) ) );
 
 } );
+
+/**
+ * This TSL function applies Bayer dithering to a color input. It uses a 4x4 Bayer matrix
+ * pattern to add structured noise before color quantization, which helps reduce visible
+ * color banding when limiting color depth.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} color - The input color to apply dithering to.
+ * @param {Node<float>} [steps=32] - The number of color steps per channel.
+ * @return {Node<vec3>} The dithered color ready for quantization.
+ *
+ * @example
+ * // Apply dithering with posterize
+ * const ditheredColor = bayerDither( inputColor, 32 );
+ * const finalColor = posterize( ditheredColor, 32 );
+ */
+export const bayerDither = Fn( ( [ color, steps = float( 32.0 ) ] ) => {
+
+	const screenPos = screenUV.mul( screenSize );
+	const x = mod( floor( screenPos.x ), float( 4.0 ) );
+	const y = mod( floor( screenPos.y ), float( 4.0 ) );
+
+	// Simplified Bayer matrix approximation
+	const bayer = mod(
+		floor( x.add( 1.0 ) ).mul( floor( y.add( 1.0 ) ) ).mul( 17.0 ),
+		16.0
+	).div( 16.0 ).sub( 0.5 );
+
+	// Apply dither offset before quantization
+	const ditherOffset = bayer.div( steps );
+
+	return vec3(
+		color.r.add( ditherOffset ),
+		color.g.add( ditherOffset ),
+		color.b.add( ditherOffset )
+	);
+
+} );

package/examples/jsm/tsl/math/curlNoise.js

@@ -0,0 +1,107 @@
+import { mod, Fn, vec2, div, vec4, dot, floor, step, sub, min, max, mul, abs, vec3, inverseSqrt, add, float } from 'three/tsl';
+
+/**
+ * Permutation polynomial for noise generation.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} x - Input vector.
+ * @return {Node<vec4>} Permuted vector.
+ */
+export const permute = /*@__PURE__*/ Fn( ( [ x ] ) => {
+
+	return mod( x.mul( x ).mul( 34. ).add( x ), 289. );
+
+}, { x: 'vec4', return: 'vec4' } );
+
+/**
+ * 3D Simplex noise implementation in TSL.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} v - Input coordinate vector.
+ * @return {Node<float>} Simplex noise value.
+ */
+export const snoise = /*@__PURE__*/ Fn( ( [ v ] ) => {
+
+	const C = div( 1., vec2( 6, 3 ) );
+	const D = vec4( 0, .5, 1, 2 );
+	const i = floor( v.add( dot( v, C.yyy ) ) );
+	const x0 = v.sub( i ).add( dot( i, C.xxx ) );
+	const g = step( x0.yzx, x0.xyz );
+	const l = sub( 1., g );
+	const i1 = min( g.xyz, l.zxy );
+	const i2 = max( g.xyz, l.zxy );
+	const x1 = x0.sub( i1 ).add( C.x );
+	const x2 = x0.sub( i2 ).add( C.y );
+	const x3 = x0.sub( D.yyy );
+	i.assign( mod( i, 289. ) );
+	const p = permute( permute( permute( i.z.add( vec4( 0., i1.z, i2.z, 1. ) ) ).add( i.y ).add( vec4( 0., i1.y, i2.y, 1. ) ) ).add( i.x ).add( vec4( 0., i1.x, i2.x, 1. ) ) );
+	const ns = mul( .142857142857, D.wyz ).sub( D.xzx );
+	const j = p.sub( mul( 49., floor( p.mul( ns.z ).mul( ns.z ) ) ) );
+	const x_ = floor( j.mul( ns.z ) );
+	const x = x_.mul( ns.x ).add( ns.yyyy );
+	const y = floor( j.sub( mul( 7., x_ ) ) ).mul( ns.x ).add( ns.yyyy );
+	const h = sub( 1., abs( x ) ).sub( abs( y ) );
+	const b0 = vec4( x.xy, y.xy );
+	const b1 = vec4( x.zw, y.zw );
+	const sh = step( h, vec4( 0 ) ).negate();
+	const a0 = b0.xzyw.add( floor( b0 ).mul( 2. ).add( 1. ).xzyw.mul( sh.xxyy ) );
+	const a1 = b1.xzyw.add( floor( b1 ).mul( 2. ).add( 1. ).xzyw.mul( sh.zzww ) );
+	const p0 = vec3( a0.xy, h.x );
+	const p1 = vec3( a0.zw, h.y );
+	const p2 = vec3( a1.xy, h.z );
+	const p3 = vec3( a1.zw, h.w );
+	const norm = inverseSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );
+	p0.mulAssign( norm.x );
+	p1.mulAssign( norm.y );
+	p2.mulAssign( norm.z );
+	p3.mulAssign( norm.w );
+	const m = max( sub( .6, vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ) ), 0. );
+
+	return add( .5, mul( 12., dot( m.mul( m ).mul( m ), vec4( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ), dot( p3, x3 ) ) ) ) );
+
+}, { v: 'vec3', return: 'float' } );
+
+/**
+ * 3D Simplex noise vector. Returns a vec3 containing three independent noise samples.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} x - Input coordinate vector.
+ * @return {Node<vec3>} Vector of three noise values.
+ */
+export const snoiseVec3 = /*@__PURE__*/ Fn( ( [ x ] ) => {
+
+	return vec3( snoise( vec3( x ).mul( 2. ).sub( 1. ) ), snoise( vec3( x.y.sub( 19.1 ), x.z.add( 33.4 ), x.x.add( 47.2 ) ) ).mul( 2. ).sub( 1. ), snoise( vec3( x.z.add( 74.2 ), x.x.sub( 124.5 ), x.y.add( 99.4 ) ).mul( 2. ).sub( 1. ) ) );
+
+}, { x: 'vec3', return: 'vec3' } );
+
+/**
+ * 3D Curl noise in TSL. Generates a divergence-free vector field from simplex noise.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - Input coordinate vector.
+ * @return {Node<vec3>} Curl noise vector.
+ */
+export const curlNoise = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	const e = float( .1 );
+	const dx = vec3( e, 0.0, 0.0 );
+	const dy = vec3( 0.0, e, 0.0 );
+	const dz = vec3( 0.0, 0.0, e );
+	const p_x0 = snoiseVec3( p.sub( dx ) );
+	const p_x1 = snoiseVec3( p.add( dx ) );
+	const p_y0 = snoiseVec3( p.sub( dy ) );
+	const p_y1 = snoiseVec3( p.add( dy ) );
+	const p_z0 = snoiseVec3( p.sub( dz ) );
+	const p_z1 = snoiseVec3( p.add( dz ) );
+	const x = p_y1.z.sub( p_y0.z ).sub( p_z1.y ).add( p_z0.y );
+	const y = p_z1.x.sub( p_z0.x ).sub( p_x1.z ).add( p_x0.z );
+	const z = p_x1.y.sub( p_x0.y ).sub( p_y1.x ).add( p_y0.x );
+	const divisor = div( 1.0, mul( 2.0, e ) );
+
+	return vec3( x, y, z ).mul( divisor );
+
+}, { p: 'vec3', return: 'vec3' } );

package/examples/jsm/tsl/shadows/TileShadowNode.js

@@ -162,7 +162,7 @@ class TileShadowNode extends ShadowBaseNode {
 		const depthTexture = new DepthTexture( shadowWidth, shadowHeight, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, tileCount );
 		depthTexture.compareFunction = LessCompare;
 		depthTexture.name = 'ShadowDepthArrayTexture';
-		const shadowMap = builder.createRenderTarget( shadowWidth, shadowHeight, { format: RedFormat, depth: tileCount } );
+		const shadowMap = builder.createRenderTarget( shadowWidth, shadowHeight, { format: RedFormat, depth: tileCount, useArrayDepthTexture: true } );
 		shadowMap.depthTexture = depthTexture;
 		shadowMap.texture.name = 'ShadowTexture';
 		this.shadowMap = shadowMap;

package/examples/jsm/tsl/shadows/TileShadowNodeHelper.js

@@ -1,5 +1,5 @@
 import { Group, NodeMaterial, Mesh, PlaneGeometry, DoubleSide, CameraHelper } from 'three/webgpu';
-import { Fn, vec4, vec3, texture, uv, positionLocal, vec2, float, screenSize } from 'three/tsl';
+import { Fn, vec4, vec3, texture, uv, positionLocal, vec2, float, int, screenSize } from 'three/tsl';
 
 /**
  * Helper class to manage and display debug visuals for TileShadowNode.
@@ -18,7 +18,7 @@ class TileShadowNodeHelper extends Group {
 
 		if ( ! tileShadowNode ) {
 
-			throw new Error( 'TileShadowNode instance is required for TileShadowNodeHelper.' );
+			throw new Error( 'THREE.TileShadowNode instance is required for TileShadowNodeHelper.' );
 
 		}
 
@@ -109,7 +109,7 @@ class TileShadowNodeHelper extends Group {
 
 				const sampledDepth = texture( this.tileShadowNode.shadowMap.depthTexture )
 					.sample( uv().flipY() )
-					.depth( float( i ) ) // Sample correct layer
+					.depth( int( i ) ) // Sample correct layer
 					.compare( 0.9 ); // Example comparison value
 
 				// Simple tint based on index for visual distinction

package/examples/jsm/tsl/utils/GroundedSkybox.js

@@ -0,0 +1,62 @@
+import { Fn, If, vec3, float, min, cameraPosition, positionWorld } from 'three/tsl';
+
+/**
+ * @module GroundedSkybox
+ * @three_import import { getGroundProjectedNormal } from 'three/addons/tsl/utils/GroundedSkybox.js';
+ */
+
+/**
+ * Projects the world position onto a sphere whose bottom is clipped by a ground disk,
+ * then returns a vector usable for sampling an environment cube map.
+ *
+ * @tsl
+ * @function
+ * @param {Node<float>} radiusNode - The radius of the projection sphere. Must be large enough to ensure the scene's camera stays inside.
+ * @param {Node<float>} heightNode - The height is how far the camera that took the photo was above the ground. A larger value will magnify the downward part of the image.
+ * @return {Node<vec3>} A direction vector for sampling the environment cube map.
+ */
+export const getGroundProjectedNormal = Fn( ( [ radiusNode, heightNode ] ) => {
+
+	const p = positionWorld.sub( cameraPosition ).normalize().toConst();
+	const camPos = cameraPosition.toVar();
+	camPos.y.subAssign( heightNode );
+
+	// sphereIntersect( camPos, p, vec3( 0 ), radius )
+	const b = camPos.dot( p ).toConst();
+	const c = camPos.dot( camPos ).sub( radiusNode.mul( radiusNode ) ).toConst();
+	const h = b.mul( b ).sub( c ).toConst();
+
+	const intersection = h.greaterThanEqual( 0 ).select( h.sqrt().sub( b ), - 1 );
+
+	const projected = vec3( 0, 1, 0 ).toVar();
+
+	If( intersection.greaterThan( 0 ), () => {
+
+		// diskIntersectWithBackFaceCulling( camPos, p, diskCenter, n, radius )
+		const diskCenter = vec3( 0, heightNode.negate(), 0 ).toConst();
+		const n = vec3( 0, 1, 0 ).toConst();
+		const d = p.dot( n ).toConst();
+
+		const intersection2 = float( 1e6 ).toVar();
+
+		If( d.lessThanEqual( 0 ), () => {
+
+			const o = camPos.sub( diskCenter ).toConst();
+			const t = n.dot( o ).negate().div( d ).toConst();
+			const q = o.add( p.mul( t ) ).toConst();
+
+			If( q.dot( q ).lessThan( radiusNode.mul( radiusNode ) ), () => {
+
+				intersection2.assign( t );
+
+			} );
+
+		} );
+
+		projected.assign( camPos.add( p.mul( min( intersection, intersection2 ) ) ).div( radiusNode ) );
+
+	} );
+
+	return projected;
+
+} );

package/examples/jsm/tsl/utils/RNoise.js

@@ -0,0 +1,51 @@
+import { float, Fn, fract, int, vec2, vec4 } from 'three/tsl';
+
+/**
+ * Returns a TSL function that samples texture-free analytic R² noise.
+ * Index 0 uses continuous screen pixels; other indices tile-shift with an R²
+ * sequence into a 64×64 period. Values are four independent R² dimensions
+ * hashed from the sample coordinates.
+ *
+ * @param {UniformNode<Vector2>} resolution
+ * @param {number} [seed=0] - Added to the coordinate hash so each pass gets an independent R² phase.
+ */
+export function bindAnalyticNoise( resolution, seed = 0 ) {
+
+	const seedOffset = int( seed );
+
+	const r4 = ( coords ) => {
+
+		const P = 1.32471795724474602596;
+
+		const t = coords.x.mul( 1 / P ).add( coords.y.mul( 1 / P ** 2 ) ).add( float( seed ) );
+
+		return vec4(
+			fract( t.mul( P ).mul( 1 / P ) ),
+			fract( t.mul( P * 2 ).mul( 1 / P ** 2 ) ),
+			fract( t.mul( P * 3 ).mul( 0.4198754210 ) ), // this is not 1 / P ** 3, however this magic constant gives better noise
+			fract( t.mul( P * 4 ).mul( 1 / P ** 3 ) )
+		);
+
+	};
+
+	return Fn( ( [ uvCoord, sampleIndex ] ) => {
+
+		const index = int( sampleIndex ).add( seedOffset );
+		const noise = vec4().toVar();
+
+		const tileSize = float( 32 );
+
+		const screenPixel = uvCoord.mul( resolution ).floor();
+		const offset = fract( vec2(
+			float( index ).mul( 0.7548776662 ),
+			float( index ).mul( 0.5698402910 )
+		) ).mul( tileSize ).floor();
+		const coords = screenPixel.add( offset ).mod( tileSize );
+
+		noise.assign( r4( coords ) );
+
+		return noise;
+
+	} );
+
+}