super-three 0.184.0 → 0.185.0

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

@@ -9,6 +9,15 @@ const _BlurDirectionY = /*@__PURE__*/ new Vector2( 0.0, 1.0 );
 
 let _rendererState;
 
+const luminosityHighPass = Fn( ( { input, threshold, smoothWidth } ) => {
+
+	const v = luminance( input.rgb );
+	const alpha = smoothstep( threshold, threshold.add( smoothWidth ), v );
+
+	return mix( vec4( 0 ), input, alpha );
+
+} );
+
 /**
  * Post processing node for creating a bloom effect.
  * ```js
@@ -74,21 +83,21 @@ class BloomNode extends TempNode {
 		 *
 		 * @type {UniformNode<float>}
 		 */
-		this.strength = uniform( strength );
+		this.strength = strength.isNode ? strength : uniform( strength );
 
 		/**
 		 * The radius of the bloom. Must be in the range `[0,1]`.
 		 *
 		 * @type {UniformNode<float>}
 		 */
-		this.radius = uniform( radius );
+		this.radius = radius.isNode ? radius : uniform( radius );
 
 		/**
 		 * The luminance threshold limits which bright areas contribute to the bloom effect.
 		 *
 		 * @type {UniformNode<float>}
 		 */
-		this.threshold = uniform( threshold );
+		this.threshold = threshold.isNode ? threshold : uniform( threshold );
 
 		/**
 		 * Can be used to tweak the extracted luminance from the scene.
@@ -97,6 +106,22 @@ class BloomNode extends TempNode {
 		 */
 		this.smoothWidth = uniform( 0.01 );
 
+		/**
+		 * Scale factor for the internal render targets.
+		 *
+		 * @private
+		 * @type {number}
+		 * @default 0.5
+		 */
+		this._resolutionScale = 0.5;
+
+		/**
+		 * Can be used to inject a custom high pass filter (e.g., for anamorphic effects).
+		 *
+		 * @type {Function}
+		 */
+		this.highPassFn = luminosityHighPass;
+
 		/**
 		 * An array that holds the render targets for the horizontal blur passes.
 		 *
@@ -253,6 +278,32 @@ class BloomNode extends TempNode {
 
 	}
 
+	/**
+	 * Sets the resolution scale for the pass.
+	 * The resolution scale is a factor that is multiplied with the renderer's width and height.
+	 *
+	 * @param {number} resolutionScale - The resolution scale to set. A value of `1` means full resolution.
+	 * @return {BloomNode} A reference to this node.
+	 */
+	setResolutionScale( resolutionScale ) {
+
+		this._resolutionScale = resolutionScale;
+
+		return this;
+
+	}
+
+	/**
+	 * Gets the current resolution scale of the pass.
+	 *
+	 * @return {number} The current resolution scale. A value of `1` means full resolution.
+	 */
+	getResolutionScale() {
+
+		return this._resolutionScale;
+
+	}
+
 	/**
 	 * Sets the size of the effect.
 	 *
@@ -261,8 +312,8 @@ class BloomNode extends TempNode {
 	 */
 	setSize( width, height ) {
 
-		let resx = Math.round( width / 2 );
-		let resy = Math.round( height / 2 );
+		let resx = Math.floor( width * this._resolutionScale );
+		let resy = Math.floor( height * this._resolutionScale );
 
 		this._renderTargetBright.setSize( resx, resy );
 
@@ -273,8 +324,8 @@ class BloomNode extends TempNode {
 
 			this._separableBlurMaterials[ i ].invSize.value.set( 1 / resx, 1 / resy );
 
-			resx = Math.round( resx / 2 );
-			resy = Math.round( resy / 2 );
+			resx = Math.floor( resx / 2 );
+			resy = Math.floor( resy / 2 );
 
 		}
 
@@ -350,19 +401,8 @@ class BloomNode extends TempNode {
 
 		// luminosity high pass material
 
-		const luminosityHighPass = Fn( () => {
-
-			const texel = this.inputNode;
-			const v = luminance( texel.rgb );
-
-			const alpha = smoothstep( this.threshold, this.threshold.add( this.smoothWidth ), v );
-
-			return mix( vec4( 0 ), texel, alpha );
-
-		} );
-
 		this._highPassFilterMaterial = this._highPassFilterMaterial || new NodeMaterial();
-		this._highPassFilterMaterial.fragmentNode = luminosityHighPass().context( builder.getSharedContext() );
+		this._highPassFilterMaterial.fragmentNode = this.highPassFn( { input: this.inputNode, threshold: this.threshold, smoothWidth: this.smoothWidth } ).context( builder.getSharedContext() );
 		this._highPassFilterMaterial.name = 'Bloom_highPass';
 		this._highPassFilterMaterial.needsUpdate = true;
 

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

@@ -1,5 +1,5 @@
 import { TempNode, NodeMaterial, NodeUpdateType, RenderTarget, Vector2, HalfFloatType, RedFormat, QuadMesh, RendererUtils } from 'three/webgpu';
-import { convertToTexture, nodeObject, Fn, uniform, smoothstep, step, texture, max, uniformArray, outputStruct, property, vec4, vec3, uv, Loop, min, mix } from 'three/tsl';
+import { convertToTexture, nodeObject, Fn, uniform, smoothstep, step, texture, max, uniformArray, outputStruct, property, vec4, vec3, uv, Loop, min, mix, float } from 'three/tsl';
 import { gaussianBlur } from './GaussianBlurNode.js';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
@@ -368,7 +368,7 @@ class DepthOfFieldNode extends TempNode {
 			nearField.assign( step( signedDist, 0 ).mul( CoC ) );
 			farField.assign( step( 0, signedDist ).mul( CoC ) );
 
-			return vec4( 0 );
+			return float( 0 );
 
 		} );
 

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

@@ -304,26 +304,25 @@ class FXAANode extends TempNode {
 		const ApplyFXAA = Fn( ( [ uv, texSize ] ) => {
 
 			const luminance = SampleLuminanceNeighborhood( texSize, uv );
-			If( ShouldSkipPixel( luminance ), () => {
+			const finalUv = vec2( uv ).toVar();
 
-				return Sample( uv );
+			If( ShouldSkipPixel( luminance ).not(), () => {
 
-			} );
+				const pixelBlend = DeterminePixelBlendFactor( luminance );
+				const edge = DetermineEdge( texSize, luminance );
+				const edgeBlend = DetermineEdgeBlendFactor( texSize, luminance, edge, uv );
 
-			const pixelBlend = DeterminePixelBlendFactor( luminance );
-			const edge = DetermineEdge( texSize, luminance );
-			const edgeBlend = DetermineEdgeBlendFactor( texSize, luminance, edge, uv );
+				const finalBlend = max( pixelBlend, edgeBlend );
 
-			const finalBlend = max( pixelBlend, edgeBlend );
-			const finalUv = uv.toVar();
+				If( edge.isHorizontal, () => {
 
-			If( edge.isHorizontal, () => {
+					finalUv.y.addAssign( edge.pixelStep.mul( finalBlend ) );
 
-				finalUv.y.addAssign( edge.pixelStep.mul( finalBlend ) );
+				} ).Else( () => {
 
-			} ).Else( () => {
+					finalUv.x.addAssign( edge.pixelStep.mul( finalBlend ) );
 
-				finalUv.x.addAssign( edge.pixelStep.mul( finalBlend ) );
+				} );
 
 			} );
 

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

@@ -1,5 +1,5 @@
 import { DataTexture, RenderTarget, RepeatWrapping, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, RedFormat } from 'three/webgpu';
-import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, sqrt, sub, acos, clamp } from 'three/tsl';
+import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, acos, clamp } from 'three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -375,10 +375,22 @@ class GTAONode extends TempNode {
 
 				const viewDir = normalize( viewPosition.xyz.negate() ).toVar();
 				const sliceBitangent = normalize( cross( sampleDir.xyz, viewDir ) ).toVar();
-				const sliceTangent = cross( sliceBitangent, viewDir );
-				const normalInSlice = normalize( viewNormal.sub( sliceBitangent.mul( dot( viewNormal, sliceBitangent ) ) ) );
-
-				const tangentToNormalInSlice = cross( normalInSlice, sliceBitangent ).toVar();
+				const sliceTangent = cross( sliceBitangent, viewDir ).toVar();
+
+				// Project the view normal onto the slice plane (remove component along sliceBitangent).
+				// The unnormalized length is the foreshortening weight applied at slice integration.
+				// (Activision GTAO paper, Section 3.2 "Per-pixel sampling".)
+				const projNRaw = viewNormal.sub( sliceBitangent.mul( dot( viewNormal, sliceBitangent ) ) ).toVar();
+				const projNLen = projNRaw.length().toVar();
+				const projN = projNRaw.div( max( projNLen, float( 0.0001 ) ) ).toVar();
+
+				// γ — angle of projN within the slice plane, signed by the tangent direction.
+				const nSin = dot( projN, sliceTangent ).toVar();
+				const nCos = clamp( dot( projN, viewDir ), 0, 1 ).toVar();
+				const signNSin = nSin.greaterThanEqual( 0 ).select( float( 1 ), float( - 1 ) );
+				const angleN = signNSin.mul( acos( nCos ) ).toVar();
+
+				const tangentToNormalInSlice = cross( projN, sliceBitangent ).toVar();
 				const cosHorizons = vec2( dot( viewDir, tangentToNormalInSlice ), dot( viewDir, tangentToNormalInSlice.negate() ) ).toVar();
 
 				// For each slice, the inner loop performs ray marching to find the horizons.
@@ -419,15 +431,24 @@ class GTAONode extends TempNode {
 
 				} );
 
-				// After the horizons are found for a given slice, their contribution to the total occlusion is calculated.
+				// Cosine-weighted inner integral, closed-form (Activision GTAO paper, Eq. 7).
+				// Per horizon h_i:    term_i = −cos( 2 h_i − γ ) + cos( γ ) + 2 h_i sin( γ )
+				// The 0.25 factor is ½ (integral normalization) × ½ (averaging the two horizons).
+				//
+				// In this slice setup `sliceTangent = cross( sliceBitangent, viewDir )` works out
+				// opposite to `sampleDir`, so the +sampleDir samples (cosHorizons.x) live on the
+				// −T side of the slice and −sampleDir samples (cosHorizons.y) on the +T side.
+				// γ is signed by +T (sliceTangent), so hPos must read from cosHorizons.y.
+
+				const hPos = acos( cosHorizons.y ).toVar();
+				const hNeg = acos( cosHorizons.x ).negate().toVar();
+
+				const termPos = cos( hPos.mul( 2 ).sub( angleN ) ).negate().add( nCos ).add( hPos.mul( 2 ).mul( nSin ) );
+				const termNeg = cos( hNeg.mul( 2 ).sub( angleN ) ).negate().add( nCos ).add( hNeg.mul( 2 ).mul( nSin ) );
+				const a = termPos.add( termNeg ).mul( 0.25 );
 
-				const sinHorizons = sqrt( sub( 1.0, cosHorizons.mul( cosHorizons ) ) ).toVar();
-				const nx = dot( normalInSlice, sliceTangent );
-				const ny = dot( normalInSlice, viewDir );
-				const nxb = mul( 0.5, acos( cosHorizons.y ).sub( acos( cosHorizons.x ) ).add( sinHorizons.x.mul( cosHorizons.x ).sub( sinHorizons.y.mul( cosHorizons.y ) ) ) );
-				const nyb = mul( 0.5, sub( 2.0, cosHorizons.x.mul( cosHorizons.x ) ).sub( cosHorizons.y.mul( cosHorizons.y ) ) );
-				const occlusion = nx.mul( nxb ).add( ny.mul( nyb ) );
-				ao.addAssign( occlusion );
+				// |projN| is the foreshortening weight from the per-slice normal projection.
+				ao.addAssign( projNLen.mul( a ) );
 
 			} );
 

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

@@ -434,7 +434,7 @@ class GodraysNode extends TempNode {
 
 			} else {
 
-				throw new Error( 'GodraysNode: Unsupported light type.' );
+				throw new Error( 'THREE.GodraysNode: Unsupported light type.' );
 
 			}