@gnsx/three 0.185.16 → 0.186.0

package/examples/jsm/tsl/display/TemporalReprojectNode.js

@@ -1,4 +1,4 @@
-import { EPSILON, Fn, If, abs, convertToTexture, dFdx, dFdy, dot, exp, float, floor, fwidth, getViewPosition, ivec2, luminance, max, min, mix, nodeObject, normalize, passTexture, screenCoordinate, select, smoothstep, sqrt, struct, texture, textureLoad, uniform, unpackRGBToNormal, uv, vec2, vec3, vec4, velocity } from '@gnsx/three/tsl';
+import { EPSILON, Fn, If, abs, convertToTexture, dFdx, dFdy, dot, exp, float, floor, fwidth, getViewPosition, ivec2, luminance, max, min, mix, nodeObject, normalize, passTexture, screenCoordinate, select, smoothstep, sqrt, struct, texture, textureLoad, uniform, unpackRGBToNormal, uv, vec2, vec3, vec4, velocity, context, OnBeforeRenderPipeline, OnAfterRenderPipeline } from '@gnsx/three/tsl';
 import { DepthTexture, HalfFloatType, Matrix4, NodeMaterial, NodeUpdateType, QuadMesh, RenderTarget, RendererUtils, TempNode, Vector2, Vector3 } from '@gnsx/three/webgpu';
 import { ENV_RAY_LENGTH, ENV_RAY_LENGTH_THRESHOLD } from '../utils/SpecularHelpers.js';
 
@@ -256,7 +256,7 @@ const sampleBilinearTap = Fn( ( [
 	const reprojDepth = textureLoad( previousDepthNode, tapCoord ).r;
 	const reprojViewPos = getViewPosition( vec2( tapCoord ).add( 0.5 ).div( resolution ), reprojDepth, previousProjectionMatrixInverse );
 	const reprojWorldPos = previousCameraWorldMatrix.mul( vec4( reprojViewPos, 1.0 ) ).xyz;
-	const reprojWorldNorm = unpackRGBToNormal( textureLoad( previousNormalNode, tapCoord ).rgb ).transformDirection( previousCameraViewMatrix );
+	const reprojWorldNorm = unpackRGBToNormal( textureLoad( previousNormalNode, tapCoord ).rgb ).transformNormalByInverseViewMatrix( previousCameraViewMatrix );
 
 	const planeDiff = abs( dot( reprojWorldPos.sub( worldPosition ), worldNormal ) ).toVar();
 	planeDiff.divAssign( abs( reprojViewPos.z ) );
@@ -727,36 +727,39 @@ class TemporalReprojectNode extends TempNode {
 
 	setup( builder ) {
 
-		const renderPipeline = builder.context.renderPipeline;
+		const sharedContext = context( builder.getSharedContext() );
 
-		if ( renderPipeline ) {
+		if ( builder.renderPipeline && ! builder.context.renderPipelineState.viewOffsetOwner ) {
+
+			builder.context.renderPipelineState.viewOffsetOwner = this;
 
 			this._needsPostProcessingSync = true;
 
-			renderPipeline.context.onBeforeRenderPipeline = () => {
+			OnBeforeRenderPipeline( () => {
 
 				this.setViewOffset();
 
-			};
+			} );
 
-			renderPipeline.context.onAfterRenderPipeline = () => {
+			OnAfterRenderPipeline( () => {
 
 				this.clearViewOffset();
 
-			};
+			} );
 
 		}
 
-		this._resolveMaterial.fragmentNode = this._buildResolve( builder );
+		this._resolveMaterial.contextNode = sharedContext;
+		this._resolveMaterial.fragmentNode = this._buildResolve();
 		this._resolveMaterial.needsUpdate = true;
 
-		this._buildSeed( builder );
+		this._buildSeed( sharedContext );
 
 		return this._textureNode;
 
 	}
 
-	_buildSeed( builder ) {
+	_buildSeed( sharedContext ) {
 
 		const seed = Fn( () => {
 
@@ -768,12 +771,13 @@ class TemporalReprojectNode extends TempNode {
 
 		} );
 
-		this._seedMaterial.fragmentNode = seed().context( builder.getSharedContext() );
+		this._seedMaterial.contextNode = sharedContext;
+		this._seedMaterial.fragmentNode = seed();
 		this._seedMaterial.needsUpdate = true;
 
 	}
 
-	_buildResolve( builder ) {
+	_buildResolve() {
 
 		const isSpecular = this.mode === 'specular';
 		const cameraUniforms = this._cameraUniforms;
@@ -794,7 +798,7 @@ class TemporalReprojectNode extends TempNode {
 
 			// Shared 3×3 beauty fetch: feeds both the variance-clip box and the SSR ray-length stats.
 			const neighborhood = collectNeighborhood( this.beautyNode, beautyTexel, inputColor, this.flickerSuppression );
-			const worldNormal = viewNormal.transformDirection( cameraUniforms.viewMatrix ).toVar();
+			const worldNormal = viewNormal.transformNormalByInverseViewMatrix( cameraUniforms.viewMatrix ).toVar();
 
 			const viewPosition = getViewPosition( uvNode, depth, cameraUniforms.projectionMatrixInverse ).toVar();
 			const worldPosition = cameraUniforms.worldMatrix.mul( vec4( viewPosition, 1.0 ) ).xyz.toVar();
@@ -944,7 +948,7 @@ class TemporalReprojectNode extends TempNode {
 
 		} );
 
-		return resolve().context( builder.getSharedContext() );
+		return resolve();
 
 	}
 
@@ -979,6 +983,8 @@ class TemporalReprojectNode extends TempNode {
 
 	dispose() {
 
+		super.dispose();
+
 		this._previousNormalTexture.dispose();
 
 		if ( this._previousDepthNode.value !== this._historyRenderTarget.depthTexture ) {

package/examples/jsm/tsl/display/depthAwareBlur.js

@@ -0,0 +1,63 @@
+import { abs, exp, float, Fn, int, logarithmicDepthToViewZ, Loop, max, perspectiveDepthToViewZ, reference, uv } from '@gnsx/three/tsl';
+
+/**
+ * Applies one pass of a separable, depth-aware (bilateral) blur to a screen-space signal.
+ *
+ * The spatial term is a fixed 5-tap gaussian along `directionNode`; the edge-stopping term
+ * rejects neighbours whose view-space depth differs from the center, so the signal is smoothed
+ * across surfaces but not across silhouettes. Depth rejection is measured relative to `radius`,
+ * which keeps it scale invariant. Run it twice (horizontal then vertical) for a full separable
+ * blur. Handy for denoising a half-resolution effect such as ambient occlusion.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} inputNode - The texture node to blur; its red channel is filtered.
+ * @param {Node<float>} depthNode - The scene depth texture node.
+ * @param {Node<vec2>} directionNode - One texel step along the blur axis, e.g. `vec2( 1 / width, 0 )`.
+ * @param {Camera} camera - The camera the scene is rendered with.
+ * @param {Node<float> | number} [sharpness=2] - How strongly a depth difference rejects a neighbour.
+ * @param {Node<float> | number} [radius=1] - The world-space scale the depth rejection is relative to.
+ * @returns {Node<float>} The blurred value.
+ */
+export const depthAwareBlur = /*#__PURE__*/ Fn( ( [ inputNode, depthNode, directionNode, camera, sharpness = 2, radius = 1 ], builder ) => {
+
+	const cameraNear = reference( 'near', 'float', camera );
+	const cameraFar = reference( 'far', 'float', camera );
+
+	const viewZ = ( uvNode ) => {
+
+		const depth = depthNode.sample( uvNode ).r;
+
+		if ( builder.renderer.logarithmicDepthBuffer === true ) {
+
+			return logarithmicDepthToViewZ( depth, cameraNear, cameraFar );
+
+		}
+
+		return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+
+	};
+
+	const uvNode = uv();
+	const centerViewZ = viewZ( uvNode ).toVar();
+
+	const sum = float( 0 ).toVar();
+	const weightSum = float( 0 ).toVar();
+
+	Loop( { start: int( - 2 ), end: int( 3 ), type: 'int', condition: '<' }, ( { i } ) => {
+
+		const fi = float( i );
+		const sampleUv = uvNode.add( directionNode.mul( fi ) );
+
+		const spatialWeight = exp( fi.mul( fi ).mul( - 0.5 ) );
+		const depthWeight = exp( abs( viewZ( sampleUv ).sub( centerViewZ ) ).div( radius ).mul( sharpness ).negate() );
+		const weight = spatialWeight.mul( depthWeight );
+
+		sum.addAssign( inputNode.sample( sampleUv ).r.mul( weight ) );
+		weightSum.addAssign( weight );
+
+	} );
+
+	return sum.div( max( weightSum, float( 0.0001 ) ) );
+
+} );

package/examples/jsm/tsl/display/hashBlur.js

@@ -1,4 +1,4 @@
-import { float, Fn, vec2, uv, sin, rand, degrees, cos, Loop, vec4, premultiplyAlpha, unpremultiplyAlpha, convertToTexture, nodeObject } from '@gnsx/three/tsl';
+import { float, Fn, vec2, uv, sin, rand, TWO_PI, cos, Loop, vec4, premultiplyAlpha, unpremultiplyAlpha, convertToTexture, nodeObject } from '@gnsx/three/tsl';
 
 /**
  * Applies a hash blur effect to the given texture node.
@@ -41,7 +41,8 @@ export const hashBlur = /*#__PURE__*/ Fn( ( [ textureNode, bluramount = float( 0
 
 	Loop( { start: 0., end: repeats, type: 'float' }, ( { i } ) => {
 
-		const q = vec2( vec2( cos( degrees( i.div( repeats ).mul( 360. ) ) ), sin( degrees( i.div( repeats ).mul( 360. ) ) ) ).mul( rand( vec2( i, targetUV.x.add( targetUV.y ) ) ).add( bluramount ) ) );
+		const angle = i.div( repeats ).mul( TWO_PI ).toConst();
+		const q = vec2( cos( angle ), sin( angle ) ).mul( rand( vec2( i, targetUV.x.add( targetUV.y ) ) ).add( bluramount ) );
 		const uv2 = vec2( targetUV.add( q.mul( bluramount ) ) );
 		blurred_image.addAssign( tap( uv2 ) );
 

package/examples/jsm/tsl/lighting/ClusteredLightsNode.js

@@ -44,7 +44,6 @@ class ClusteredLightsNode extends LightsNode {
 
 		this.materialLights = [];
 		this.clusteredLights = [];
-		this._allLights = [];
 
 		this.maxLights = maxLights;
 		this.tileSize = tileSize;
@@ -57,9 +56,15 @@ class ClusteredLightsNode extends LightsNode {
 		this._lightIndexes = null;
 		this._screenClusterIndex = null;
 		this._compute = null;
-		this._lightsTexture = null;
-		this._zSliceRangesTexture = null;
-		this._zSliceRangesData = null;
+
+		const lightsData = new Float32Array( maxLights * 4 * 2 );
+		this._lightsTexture = new DataTexture( lightsData, lightsData.length / 8, 2, RGBAFormat, FloatType );
+
+		// Per Z-slice light range for Z-culling (CPU-sorted, uploaded each frame)
+
+		this._zSliceRangesData = new Float32Array( zSlices * 4 );
+		this._zSliceRangesTexture = new DataTexture( this._zSliceRangesData, zSlices, 1, RGBAFormat, FloatType );
+
 		this._lightViewZ = new Float32Array( maxLights );
 		this._lightSortOrder = [];
 
@@ -139,8 +144,6 @@ class ClusteredLightsNode extends LightsNode {
 
 		const zRanges = this._zSliceRangesData;
 
-		if ( zRanges === null ) return;
-
 		const near = camera.near;
 		const far = camera.far;
 		const NZ = this.zSlices;
@@ -206,8 +209,6 @@ class ClusteredLightsNode extends LightsNode {
 
 	setLights( lights ) {
 
-		this._allLights = lights;
-
 		const { clusteredLights, materialLights } = this;
 
 		let materialIndex = 0;
@@ -230,13 +231,13 @@ class ClusteredLightsNode extends LightsNode {
 		materialLights.length = materialIndex;
 		clusteredLights.length = clusteredIndex;
 
-		return super.setLights( materialLights );
+		return super.setLights( lights );
 
 	}
 
-	getLights() {
+	getBuiltinLights() {
 
-		return this._allLights;
+		return this.materialLights;
 
 	}
 
@@ -421,7 +422,7 @@ class ClusteredLightsNode extends LightsNode {
 
 	create( width, height ) {
 
-		const { tileSize, maxLights, zSlices, maxLightsPerCluster, _chunksPerCluster: chunksPerCluster } = this;
+		const { tileSize, zSlices, maxLightsPerCluster, _chunksPerCluster: chunksPerCluster } = this;
 
 		const bufferSize = new Vector2( width, height );
 
@@ -432,20 +433,25 @@ class ClusteredLightsNode extends LightsNode {
 
 		this._gridDimensions.value.set( NX, NY );
 
-		// Lights data texture (same layout as TiledLightsNode)
+		// release the compute pipeline and bindings built for the previous grid
 
-		const lightsData = new Float32Array( maxLights * 4 * 2 );
-		const lightsTexture = new DataTexture( lightsData, lightsData.length / 8, 2, RGBAFormat, FloatType );
+		if ( this._compute !== null ) this._compute.dispose();
 
-		// Per Z-slice light range for Z-culling (CPU-sorted, uploaded each frame)
+		// Per-cluster light-index storage (ivec4 chunks).
+
+		const lightIndexesLength = clusterCount * chunksPerCluster * 4;
+
+		let lightIndexes = this._lightIndexes;
 
-		const zSliceRangesData = new Float32Array( NZ * 4 );
-		const zSliceRangesTexture = new DataTexture( zSliceRangesData, NZ, 1, RGBAFormat, FloatType );
+		if ( lightIndexes === null || lightIndexes.value.array.length < lightIndexesLength ) {
 
-		// Per-cluster light-index storage (ivec4 chunks)
+			// TODO: Free the outgoing buffer once the renderer destroys the GPU resources of
+			// standalone storage attributes (`Bindings._destroyBindings()` skips storage buffers).
 
-		const lightIndexesArray = new Int32Array( clusterCount * chunksPerCluster * 4 );
-		const lightIndexes = attributeArray( lightIndexesArray, 'ivec4' ).setName( 'lightIndexes' );
+			const lightIndexesArray = new Int32Array( lightIndexesLength );
+			lightIndexes = attributeArray( lightIndexesArray, 'ivec4' ).setName( 'lightIndexes' );
+
+		}
 
 		// compute-side accessors (use instanceIndex)
 
@@ -531,7 +537,7 @@ class ClusteredLightsNode extends LightsNode {
 			const index = int( 0 ).toVar();
 
 			// Z-culling: only test lights that can reach this cluster's Z-slice
-			const zRange = textureLoad( zSliceRangesTexture, ivec2( cz, 0 ) );
+			const zRange = textureLoad( this._zSliceRangesTexture, ivec2( cz, 0 ) );
 			const rangeStart = int( zRange.x );
 			const rangeEnd = int( zRange.y );
 
@@ -592,15 +598,20 @@ class ClusteredLightsNode extends LightsNode {
 		this._lightIndexes = lightIndexes;
 		this._screenClusterIndex = screenClusterIndex;
 		this._compute = compute;
-		this._lightsTexture = lightsTexture;
-		this._zSliceRangesTexture = zSliceRangesTexture;
-		this._zSliceRangesData = zSliceRangesData;
 
 	}
 
-	get hasLights() {
+	/**
+	 * Frees the GPU resources allocated by this node.
+	 */
+	dispose() {
+
+		if ( this._compute !== null ) this._compute.dispose();
+
+		this._lightsTexture.dispose();
+		this._zSliceRangesTexture.dispose();
 
-		return super.hasLights || this.clusteredLights.length > 0;
+		super.dispose();
 
 	}
 

package/examples/jsm/tsl/lighting/LightProbeGridNode.js

@@ -0,0 +1,136 @@
+import { AnalyticLightNode, Vector3 } from '@gnsx/three/webgpu';
+import { array, getShIrradianceAt, normalWorld, positionWorld, texture3D, uniform, vec3 } from '@gnsx/three/tsl';
+
+// Padding texels at each boundary of every atlas sub-volume.
+export const ATLAS_PADDING = 1;
+
+/**
+ * Samples the packed SH atlas and evaluates L2 irradiance for the given normal.
+ *
+ * The atlas stores the seven RGBA sub-volumes stacked along Z, each occupying
+ * `( nz + 2 )` slices: one padding slice (a copy of the nearest edge slice) at
+ * each end to prevent color bleeding when the hardware trilinear filter reads
+ * across a sub-volume boundary.
+ *
+ * @private
+ * @param {Texture3DNode} atlas - The atlas texture node.
+ * @param {Node<vec3>} uvw - The probe-grid sample coordinate (texel centers).
+ * @param {Node<vec3>} res - The probe resolution.
+ * @param {Node<vec3>} normal - The world-space normal.
+ * @return {Node<vec3>} The non-negative irradiance.
+ */
+function evaluateGridIrradiance( atlas, uvw, res, normal ) {
+
+	const nz = res.z;
+	const paddedSlices = nz.add( 2.0 * ATLAS_PADDING );
+	const atlasDepth = paddedSlices.mul( 7.0 );
+	const uvZBase = uvw.z.mul( nz ).add( ATLAS_PADDING );
+
+	const slice = ( t ) => atlas.sample( vec3( uvw.xy, uvZBase.add( paddedSlices.mul( t ) ).div( atlasDepth ) ) );
+
+	const s0 = slice( 0 ), s1 = slice( 1 ), s2 = slice( 2 ), s3 = slice( 3 );
+	const s4 = slice( 4 ), s5 = slice( 5 ), s6 = slice( 6 );
+
+	// Unpack 9 vec3 L2 SH coefficients and evaluate irradiance.
+
+	const sh = array( [
+		s0.xyz,
+		vec3( s0.w, s1.xy ),
+		vec3( s1.zw, s2.x ),
+		s2.yzw,
+		s3.xyz,
+		vec3( s3.w, s4.xy ),
+		vec3( s4.zw, s5.x ),
+		s5.yzw,
+		s6.xyz
+	] );
+
+	return getShIrradianceAt( normal, sh ).max( vec3( 0.0 ) );
+
+}
+
+/**
+ * The light node that applies a {@link LightProbeGrid} to the scene. It samples
+ * the baked L2 spherical-harmonic atlas at the surface position and adds the
+ * resulting irradiance to the lighting context, so every standard node material
+ * picks up the grid automatically (same role as the WebGL `lights_fragment_begin`
+ * integration).
+ *
+ * @private
+ * @augments AnalyticLightNode
+ */
+class LightProbeGridNode extends AnalyticLightNode {
+
+	static get type() {
+
+		return 'LightProbeGridNode';
+
+	}
+
+	constructor( light = null ) {
+
+		super( light );
+
+		this._min = uniform( new Vector3() );
+		this._max = uniform( new Vector3() );
+		this._resolution = uniform( new Vector3() );
+		this._intensity = uniform( 1 );
+		this._falloff = uniform( 0 );
+
+	}
+
+	update( /* frame */ ) {
+
+		const light = this.light;
+
+		this._min.value.copy( light.boundingBox.min );
+		this._max.value.copy( light.boundingBox.max );
+		this._resolution.value.copy( light.resolution );
+		this._intensity.value = light.intensity;
+		this._falloff.value = light.falloff;
+
+	}
+
+	setup( builder ) {
+
+		const light = this.light;
+
+		// No baked data yet: contribute nothing.
+
+		if ( light.texture === null ) return;
+
+		const min = this._min;
+		const max = this._max;
+		const res = this._resolution;
+
+		const range = max.sub( min );
+		const resMinusOne = res.sub( 1.0 );
+		const spacing = range.div( resMinusOne );
+
+		// Offset along the normal by half a probe spacing, then remap to texel centers.
+
+		const samplePos = positionWorld.add( normalWorld.mul( spacing ).mul( 0.5 ) );
+		const uvw = samplePos.sub( min ).div( range ).clamp( 0.0, 1.0 ).mul( resMinusOne ).div( res ).add( vec3( 0.5 ).div( res ) );
+
+		const result = evaluateGridIrradiance( texture3D( light.texture ), uvw, res, normalWorld );
+
+		let irradiance = result.mul( this._intensity );
+
+		// Optional smooth boundary for blending grids; falloff 0 applies everywhere.
+
+		if ( light.falloff > 0 ) {
+
+			const outside = min.sub( positionWorld ).max( 0.0 ).add( positionWorld.sub( max ).max( 0.0 ) );
+			const weight = outside.length().smoothstep( 0.0, this._falloff ).oneMinus();
+
+			irradiance = irradiance.mul( weight );
+
+		}
+
+		builder.context.irradiance.addAssign( irradiance );
+
+	}
+
+}
+
+export { LightProbeGridNode };

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

@@ -0,0 +1,112 @@
+import { Fn, Loop, dot, float, fract, int, min, sin, vec2, vec3, TWO_PI } from '@gnsx/three/tsl';
+
+/**
+ * @module VoronoiNoise
+ * @three_import import { voronoi2d, voronoi3d } from 'three/addons/tsl/math/voronoiNoise.js';
+ */
+
+/**
+ * Generates a pseudo-random vec2 from the given coordinate.
+ *
+ * Reference: {@link https://www.shadertoy.com/view/MslGD8}.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} p - The input coordinate.
+ * @return {Node<vec2>} A pseudo-random value in the range `[0, 1]`.
+ */
+export const hash2d = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	return fract( sin( vec2( dot( p, vec2( 127.1, 311.7 ) ), dot( p, vec2( 269.5, 183.3 ) ) ) ).mul( 18.5453 ) );
+
+}, { p: 'vec2', return: 'vec2' } );
+
+/**
+ * Animated 2D Voronoi noise. The feature points orbit inside their cells so the
+ * resulting pattern morphs over time.
+ *
+ * Reference: {@link https://www.shadertoy.com/view/MslGD8}.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} p - The input coordinate.
+ * @param {Node<float>} time - The animation time.
+ * @return {Node<float>} The squared distance to the closest feature point, roughly in the range `[0, 1]`.
+ */
+export const voronoi2d = /*@__PURE__*/ Fn( ( [ p, time ] ) => {
+
+	const n = p.floor().toConst();
+	const f = p.fract().toConst();
+	const minDist = float( 8 ).toVar();
+
+	Loop( { start: int( - 1 ), end: int( 1 ), name: 'x', condition: '<=' }, ( { x } ) => {
+
+		Loop( { start: int( - 1 ), end: int( 1 ), name: 'y', condition: '<=' }, ( { y } ) => {
+
+			const g = vec2( float( x ), float( y ) ).toConst();
+			const o = hash2d( n.add( g ) ).toConst();
+			const r = g.sub( f ).add( sin( time.add( o.mul( TWO_PI ) ) ).mul( 0.5 ).add( 0.5 ) );
+
+			minDist.assign( min( minDist, dot( r, r ) ) );
+
+		} );
+
+	} );
+
+	return minDist;
+
+}, { p: 'vec2', time: 'float', return: 'float' } );
+
+/**
+ * Generates a pseudo-random vec3 from the given coordinate.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - The input coordinate.
+ * @return {Node<vec3>} A pseudo-random value in the range `[0, 1]`.
+ */
+export const hash3d = /*@__PURE__*/ Fn( ( [ p ] ) => {
+
+	return fract( sin( vec3( dot( p, vec3( 127.1, 311.7, 74.7 ) ), dot( p, vec3( 269.5, 183.3, 246.1 ) ), dot( p, vec3( 113.5, 271.9, 124.6 ) ) ) ).mul( 18.5453 ) );
+
+}, { p: 'vec3', return: 'vec3' } );
+
+/**
+ * Animated 3D Voronoi noise. Like {@link voronoi2d} but with a volumetric input
+ * coordinate so the pattern can be applied to arbitrary surfaces without
+ * projection artifacts. Evaluates 27 cells instead of 9 and is therefore
+ * considerably more expensive than the 2D version.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - The input coordinate.
+ * @param {Node<float>} time - The animation time.
+ * @return {Node<float>} The squared distance to the closest feature point, roughly in the range `[0, 1]`.
+ */
+export const voronoi3d = /*@__PURE__*/ Fn( ( [ p, time ] ) => {
+
+	const n = p.floor().toConst();
+	const f = p.fract().toConst();
+	const minDist = float( 8 ).toVar();
+
+	Loop( { start: int( - 1 ), end: int( 1 ), name: 'x', condition: '<=' }, ( { x } ) => {
+
+		Loop( { start: int( - 1 ), end: int( 1 ), name: 'y', condition: '<=' }, ( { y } ) => {
+
+			Loop( { start: int( - 1 ), end: int( 1 ), name: 'z', condition: '<=' }, ( { z } ) => {
+
+				const g = vec3( float( x ), float( y ), float( z ) ).toConst();
+				const o = hash3d( n.add( g ) ).toConst();
+				const r = g.sub( f ).add( sin( time.add( o.mul( TWO_PI ) ) ).mul( 0.5 ).add( 0.5 ) );
+
+				minDist.assign( min( minDist, dot( r, r ) ) );
+
+			} );
+
+		} );
+
+	} );
+
+	return minDist;
+
+}, { p: 'vec3', time: 'float', return: 'float' } );

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

@@ -14,7 +14,7 @@ import {
 	Quaternion
 } from '@gnsx/three/webgpu';
 
-import { min, Fn, shadow, NodeUpdateType, getShadowMaterial, getShadowRenderObjectFunction } from '@gnsx/three/tsl';
+import { min, Fn, shadow, NodeUpdateType } from '@gnsx/three/tsl';
 
 const { resetRendererAndSceneState, restoreRendererAndSceneState } = RendererUtils;
 let _rendererState;
@@ -273,14 +273,11 @@ class TileShadowNode extends ShadowBaseNode {
 		const depthVersion = shadowMap.depthTexture.version;
 		this._depthVersionCached = depthVersion;
 		const currentRenderObjectFunction = renderer.getRenderObjectFunction();
-		const currentMRT = renderer.getMRT();
-		const useVelocity = currentMRT ? currentMRT.has( 'velocity' ) : false;
 
 		_rendererState = resetRendererAndSceneState( renderer, scene, _rendererState );
-		scene.overrideMaterial = getShadowMaterial( light );
+		scene.overrideMaterial = this.getShadowMaterial();
 		renderer.setRenderTarget( this.shadowMap );
 
-
 		for ( let index = 0; index < this.lights.length; index ++ ) {
 
 			const light = this.lights[ index ];
@@ -297,7 +294,7 @@ class TileShadowNode extends ShadowBaseNode {
 
 			shadow.updateMatrices( light );
 
-			renderer.setRenderObjectFunction( getShadowRenderObjectFunction( renderer, shadow, shadowType, useVelocity ) );
+			renderer.setRenderObjectFunction( this.getShadowRenderObjectFunction( renderer, shadow ) );
 			this.shadowMap.setSize( shadow.mapSize.width, shadow.mapSize.height, shadowMap.depth );
 
 		}
@@ -447,6 +444,7 @@ class TileShadowNode extends ShadowBaseNode {
 
 		// Dispose lights, nodes, and shadow map
 		this.disposeLightsAndNodes();
+		this.disposeShadowMaterial();
 		super.dispose();
 
 	}

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

@@ -53,17 +53,17 @@ export const RaymarchingBox = ( steps, callback ) => {
 	bounds.assign( vec2( max( bounds.x, 0.0 ), bounds.y ) );
 
 	const inc = vec3( rayDir.abs().reciprocal() ).toVar();
-	const delta = float( min( inc.x, min( inc.y, inc.z ) ) ).toVar();
+	const stepSize = float( min( inc.x, min( inc.y, inc.z ) ) ).toVar();
 
-	delta.divAssign( float( steps ) );
+	stepSize.divAssign( float( steps ) );
 
 	const positionRay = vec3( vOrigin.add( bounds.x.mul( rayDir ) ) ).toVar();
 
-	Loop( { type: 'float', start: bounds.x, end: bounds.y, update: delta }, () => {
+	Loop( { type: 'float', start: bounds.x, end: bounds.y, update: stepSize }, () => {
 
-		callback( { positionRay } );
+		callback( { positionRay, stepSize } );
 
-		positionRay.addAssign( rayDir.mul( delta ) );
+		positionRay.addAssign( rayDir.mul( stepSize ) );
 
 	} );