@unikia/upe-renderer 0.186.110 → 0.187.11

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

@@ -1,5 +1,5 @@
-import { abs, atan, bool, convertToTexture, cos, cross, Discard, dot, EPSILON, exp, float, Fn, getScreenPosition, getViewPosition, If, int, log, Loop, luminance, mat2, max, mix, nodeObject, NodeUpdateType, normalize, passTexture, PI, property, reflect, sin, smoothstep, sqrt, tan, texture, uniform, unpackRGBToNormal, uv, vec2, vec3, vec4, context } from 'three/tsl';
-import { HalfFloatType, MathUtils, Matrix4, NodeMaterial, QuadMesh, RendererUtils, RenderTarget, TempNode, Vector2 } from 'three/webgpu';
+import { abs, atan, bool, convertToTexture, cos, cross, Discard, dot, EPSILON, exp, float, Fn, getScreenPosition, getViewPosition, If, int, log, Loop, luminance, mat2, max, mix, nodeObject, NodeUpdateType, normalize, passTexture, PI, property, reflect, sin, smoothstep, sqrt, tan, texture, uniform, unpackRGBToNormal, uv, vec2, vec3, vec4, context, isBackgroundDepth } from 'three/tsl';
+import { HalfFloatType, MathUtils, Matrix4, NodeMaterial, QuadMesh, RendererUtils, RenderTarget, Node, Vector2 } from 'three/webgpu';
 import { bindAnalyticNoise } from '../utils/RNoise.js';
 import { ENV_RAY_LENGTH_THRESHOLD } from '../utils/SpecularHelpers.js';
 
@@ -32,14 +32,7 @@ const vogelDisk = Fn( ( [ i, radius ] ) => {
 	const r = radius.mul( sqrt( i.add( 0.5 ).div( sampleCount ) ) );
 	return vec2( cos( theta ), sin( theta ) ).mul( r );
 
-} ).setLayout( {
-	name: 'vogelDisk',
-	type: 'vec2',
-	inputs: [
-		{ name: 'i', type: 'float' },
-		{ name: 'radius', type: 'float' }
-	]
-} );
+}, { i: 'float', radius: 'float', return: 'vec2' } );
 
 /**
  * Chromatic color-similarity distance between two linear base colors (albedo).
@@ -66,24 +59,9 @@ const diffuseColorDistance = Fn( ( [ a, b, compressLuma ] ) => {
 
 	return dLuma.add( dChroma.mul( DIFFUSE_CHROMA_WEIGHT ) );
 
-} ).setLayout( {
-	name: 'diffuseColorDistance',
-	type: 'float',
-	inputs: [
-		{ name: 'a', type: 'vec3' },
-		{ name: 'b', type: 'vec3' },
-		{ name: 'compressLuma', type: 'float' }
-	]
-} );
+}, { a: 'vec3', b: 'vec3', compressLuma: 'float', return: 'float' } );
 
-const _temporalWeight = Fn( ( [ x, strength ] ) => float( 1 ).div( x.pow( strength ) ) ).setLayout( {
-	name: 'temporalWeight',
-	type: 'float',
-	inputs: [
-		{ name: 'x', type: 'float' },
-		{ name: 'strength', type: 'float' }
-	]
-} );
+const _temporalWeight = Fn( ( [ x, strength ] ) => float( 1 ).div( x.pow( strength ) ), { x: 'float', strength: 'float', return: 'float' } );
 
 /**
  * Temporal accumulation variance factor in `[0, 1]`. Higher values mean more history confidence.
@@ -94,14 +72,7 @@ const getTemporalVarianceFactor = Fn( ( [ frameNum, strength ] ) => {
 
 	return _temporalWeight( frameNum, strength ).max( 0.05 );
 
-} ).setLayout( {
-	name: 'getTemporalVarianceFactor',
-	type: 'float',
-	inputs: [
-		{ name: 'frameNum', type: 'float' },
-		{ name: 'strength', type: 'float' }
-	]
-} );
+}, { frameNum: 'float', strength: 'float', return: 'float' } );
 
 /**
  * World-space frustum height at `viewZ`. Algorithm originally from REBLUR (NRD).
@@ -113,14 +84,7 @@ const computeFrustumSize = Fn( ( [ viewZ, tanHalfFovY ] ) => {
 
 	return float( 2 ).mul( viewZ ).mul( tanHalfFovY );
 
-} ).setLayout( {
-	name: 'computeFrustumSize',
-	type: 'float',
-	inputs: [
-		{ name: 'viewZ', type: 'float' },
-		{ name: 'tanHalfFovY', type: 'float' }
-	]
-} );
+}, { viewZ: 'float', tanHalfFovY: 'float', return: 'float' } );
 
 /**
  * Maps world-space SSR ray length to `[0, 1]`. Environment rays (`worldRayLength == 0`) map to `1`.
@@ -131,26 +95,18 @@ const computeFrustumSize = Fn( ( [ viewZ, tanHalfFovY ] ) => {
 const computeHitDistFactor = Fn( ( [ worldRayLength, viewZ, tanHalfFovY ] ) => {
 
 	const frustumSize = computeFrustumSize( viewZ, tanHalfFovY );
-	const factor = worldRayLength.div( frustumSize.max( 1e-6 ) ).clamp( 0, 1 );
+	const factor = worldRayLength.div( frustumSize.max( EPSILON ) ).clamp( 0, 1 );
 
 	return factor;
 
-} ).setLayout( {
-	name: 'computeHitDistFactor',
-	type: 'float',
-	inputs: [
-		{ name: 'worldRayLength', type: 'float' },
-		{ name: 'viewZ', type: 'float' },
-		{ name: 'tanHalfFovY', type: 'float' }
-	]
-} );
+}, { worldRayLength: 'float', viewZ: 'float', tanHalfFovY: 'float', return: 'float' } );
 
 /**
  * Maps an AO factor for edge-stopping comparisons.
  *
  * @tsl
  */
-const mapAo = Fn( ( [ aoVal ] ) => aoVal.pow( 0.1 ) );
+const mapAo = Fn( ( [ aoVal ] ) => aoVal.pow( 0.1 ), { aoVal: 'float', return: 'float' } );
 
 /**
  * Specular dominant direction — smooth surfaces lean toward reflection, rough toward normal.
@@ -161,15 +117,7 @@ const getSpecularDominantDirection = Fn( ( [ N, V, roughness ] ) => {
 
 	return normalize( mix( N, reflect( V.negate(), N ), roughness.oneMinus() ) );
 
-} ).setLayout( {
-	name: 'getSpecularDominantDirection',
-	type: 'vec3',
-	inputs: [
-		{ name: 'N', type: 'vec3' },
-		{ name: 'V', type: 'vec3' },
-		{ name: 'roughness', type: 'float' }
-	]
-} );
+}, { N: 'vec3', V: 'vec3', roughness: 'float', return: 'vec3' } );
 
 /**
  * GGX inverse-CDF: half-angle tangent enclosing `percent` of the specular lobe volume.
@@ -180,16 +128,9 @@ const getSpecularDominantDirection = Fn( ( [ N, V, roughness ] ) => {
 const specularLobeTanHalfAngle = Fn( ( [ roughness, percent ] ) => {
 
 	const alpha = roughness.mul( roughness );
-	return alpha.mul( sqrt( percent.div( float( 1 ).sub( percent ).max( 1e-6 ) ) ) );
-
-} ).setLayout( {
-	name: 'specularLobeTanHalfAngle',
-	type: 'float',
-	inputs: [
-		{ name: 'roughness', type: 'float' },
-		{ name: 'percent', type: 'float' }
-	]
-} );
+	return alpha.mul( sqrt( percent.div( float( 1 ).sub( percent ).max( EPSILON ) ) ) );
+
+}, { roughness: 'float', percent: 'float', return: 'float' } );
 
 const EXP_WEIGHT_SCALE = 4;
 const NORMAL_ENCODING_ERROR = 1.5 / 255;
@@ -211,15 +152,7 @@ const lobeNormalFalloff = Fn( ( [ roughness, aggressivity, invNormalPhi ] ) => {
 	const invHalfAngle = float( 1 ).div( lobeHalfAngle );
 	return invHalfAngle.mul( invHalfAngle ).mul( 2 * EXP_WEIGHT_SCALE );
 
-} ).setLayout( {
-	name: 'lobeNormalFalloff',
-	type: 'float',
-	inputs: [
-		{ name: 'roughness', type: 'float' },
-		{ name: 'aggressivity', type: 'float' },
-		{ name: 'invNormalPhi', type: 'float' }
-	]
-} );
+}, { roughness: 'float', aggressivity: 'float', invNormalPhi: 'float', return: 'float' } );
 
 /**
  * Adaptive lobe normal edge-stopping weight
@@ -237,15 +170,7 @@ const lobeNormalWeight = Fn( ( [ viewNormal, nNormalV, lobeFalloff ] ) => {
 
 	return exp( cosA.sub( 1 ).mul( lobeFalloff ) );
 
-} ).setLayout( {
-	name: 'lobeNormalWeight',
-	type: 'float',
-	inputs: [
-		{ name: 'viewNormal', type: 'vec3' },
-		{ name: 'nNormalV', type: 'vec3' },
-		{ name: 'lobeFalloff', type: 'float' }
-	]
-} );
+}, { viewNormal: 'vec3', nNormalV: 'vec3', lobeFalloff: 'float', return: 'float' } );
 
 /**
  * View-space plane distance between two surface points (edge-stopping geometry term).
@@ -256,15 +181,7 @@ const planeDistance = Fn( ( [ position, nPosition, normal ] ) => {
 
 	return abs( dot( position.sub( nPosition ), normal ) );
 
-} ).setLayout( {
-	name: 'planeDistance',
-	type: 'float',
-	inputs: [
-		{ name: 'position', type: 'vec3' },
-		{ name: 'nPosition', type: 'vec3' },
-		{ name: 'normal', type: 'vec3' },
-	]
-} );
+}, { position: 'vec3', nPosition: 'vec3', normal: 'vec3', return: 'float' } );
 
 /**
  * Inverse-luminance temporal blend with optional adaptive trust (Karis-style).
@@ -286,18 +203,6 @@ const karisTemporalBlend = Fn( ( [ denoisedRgb, denoisedRaw, a, flickerSuppressi
 	const wRaw = aTrust.div( luminance( denoisedRaw ).mul( effFlicker ).mul( 10 ).add( 1 ) );
 	return denoisedRgb.mul( wHist ).add( denoisedRaw.mul( wRaw ) ).div( wHist.add( wRaw ).max( EPSILON ) );
 
-} ).setLayout( {
-	name: 'karisTemporalBlend',
-	type: 'vec3',
-	inputs: [
-		{ name: 'denoisedRgb', type: 'vec3' },
-		{ name: 'denoisedRaw', type: 'vec3' },
-		{ name: 'a', type: 'float' },
-		{ name: 'flickerSuppression', type: 'float' },
-		{ name: 'adaptiveTrust', type: 'float' },
-		{ name: 'nbhdMeanLuma', type: 'float' },
-		{ name: 'nbhdStddevLuma', type: 'float' }
-	]
 } );
 
 const toTextureNode = ( value ) => {
@@ -337,10 +242,10 @@ const toTextureNode = ( value ) => {
  * The denoising kernel is selected at construction time via `mode`:
  * `'diffuse'` (SSGI) or `'specular'` (SSR). The kernel uses a fixed 8-sample Vogel disk.
  *
- * @augments TempNode
+ * @augments Node
  * @three_import import { recurrentDenoise } from 'three/addons/tsl/display/RecurrentDenoiseNode.js';
  */
-class RecurrentDenoiseNode extends TempNode {
+class RecurrentDenoiseNode extends Node {
 
 	static get type() {
 
@@ -496,7 +401,6 @@ class RecurrentDenoiseNode extends TempNode {
 
 		if ( needsRestart === true ) {
 
-			renderer.initRenderTarget( this._renderTarget );
 			renderer.setRenderTarget( this._renderTarget );
 			renderer.clear();
 			renderer.setRenderTarget( null );
@@ -522,7 +426,7 @@ class RecurrentDenoiseNode extends TempNode {
 			const angle = r.mul( 2 ).mul( PI );
 			return mat2( cos( angle ), sin( angle ).negate(), sin( angle ), cos( angle ) );
 
-		} );
+		}, { r: 'float', return: 'mat2' } );
 
 		const sampleTexture = ( uvCoord ) => texture( this.textureNode, uvCoord ).max( 0 );
 		const sampleRaw = ( uvCoord ) => this.rawNode?.sample( uvCoord )?.max( 0 ) ?? vec3( 0 ).max( 0 );
@@ -588,13 +492,6 @@ class RecurrentDenoiseNode extends TempNode {
 			// vec3( avgRayLength, meanLuma, stddevLuma )
 			return vec4( avgRayLength, meanLuma, stddevLuma, hasEnvRay.toFloat() );
 
-		} ).setLayout( {
-			name: 'getNeighborhoodStats',
-			type: 'vec4',
-			inputs: [
-				{ name: 'uvCoord', type: 'vec2' },
-				{ name: 'centerSample', type: 'vec4' }
-			]
 		} );
 
 		const denoiseFn = Fn( ( [ uvCoord ] ) => {
@@ -870,7 +767,7 @@ class RecurrentDenoiseNode extends TempNode {
 
 			};
 
-			If( depth.greaterThanEqual( 1.0 ), () => {
+			If( isBackgroundDepth( depth ), () => {
 
 				Discard();
 
@@ -908,8 +805,8 @@ export default RecurrentDenoiseNode;
  * @param {RecurrentDenoiseNodeOptions} [options={}]
  * @returns {RecurrentDenoiseNode}
  */
-export const recurrentDenoise = ( inputTexture, camera, options = {} ) => nodeObject( new RecurrentDenoiseNode(
+export const recurrentDenoise = ( inputTexture, camera, options = {} ) => new RecurrentDenoiseNode(
 	toTextureNode( inputTexture ),
 	camera,
 	options
-) );
+);

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

@@ -1,4 +1,4 @@
-import { HalfFloatType, LinearFilter, NearestFilter, RenderTarget, Texture, Vector2, QuadMesh, NodeMaterial, TempNode, RendererUtils } from 'three/webgpu';
+import { HalfFloatType, LinearFilter, NearestFilter, RenderTarget, Texture, Vector2, QuadMesh, NodeMaterial, Node, RendererUtils } from 'three/webgpu';
 import { abs, Fn, NodeUpdateType, uv, uniform, convertToTexture, vec2, vec4, passTexture, max, step, dot, float, texture, If, Loop, int, Break, sqrt, sign, mix, context } from 'three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
@@ -14,10 +14,10 @@ let _rendererState;
  * Used Preset: SMAA 1x Medium (with color edge detection)
  * Reference: {@link https://github.com/iryoku/smaa/releases/tag/v2.8}.
  *
- * @augments TempNode
+ * @augments Node
  * @three_import import { smaa } from 'three/addons/tsl/display/SMAANode.js';
  */
-class SMAANode extends TempNode {
+class SMAANode extends Node {
 
 	static get type() {
 

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

@@ -1,5 +1,5 @@
-import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils, RedFormat } from 'three/webgpu';
-import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, getScreenPositionFromClip, vogelDiskSample, interleavedGradientNoise, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec4, int, dot, max, clamp, length, screenCoordinate, PI2, texture, passTexture, context } from 'three/tsl';
+import { RenderTarget, Vector2, Node, QuadMesh, NodeMaterial, RendererUtils, RedFormat } from 'three/webgpu';
+import { reference, getViewPosition, getScreenPositionFromClip, vogelDiskSample, interleavedGradientNoise, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec4, int, dot, max, clamp, length, screenCoordinate, PI2, texture, passTexture, context, isBackgroundDepth, projectionDepth } from 'three/tsl';
 import { depthAwareBlur } from './depthAwareBlur.js';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
@@ -26,10 +26,10 @@ let _rendererState;
  * renderPipeline.outputNode = scenePassColor.mul( aoPass.r );
  * ```
  *
- * @augments TempNode
+ * @augments Node
  * @three_import import { ssao } from 'three/addons/tsl/display/SSAONode.js';
  */
-class SSAONode extends TempNode {
+class SSAONode extends Node {
 
 	static get type() {
 
@@ -320,21 +320,7 @@ class SSAONode extends TempNode {
 
 		const uvNode = uv();
 
-		const sampleDepth = ( uv ) => {
-
-			const depth = this.depthNode.sample( uv ).r;
-
-			if ( builder.renderer.logarithmicDepthBuffer === true ) {
-
-				const viewZ = logarithmicDepthToViewZ( depth, this._cameraNear, this._cameraFar );
-
-				return viewZToPerspectiveDepth( viewZ, this._cameraNear, this._cameraFar );
-
-			}
-
-			return depth;
-
-		};
+		const sampleDepth = ( uv ) => projectionDepth( this.depthNode.sample( uv ).r, this._cameraNear, this._cameraFar );
 
 		// ambient occlusion
 
@@ -342,7 +328,7 @@ class SSAONode extends TempNode {
 
 			const depth = sampleDepth( uvNode ).toVar();
 
-			depth.greaterThanEqual( 1.0 ).discard();
+			isBackgroundDepth( depth ).discard();
 
 			const viewPosition = getViewPosition( uvNode, depth, this._cameraProjectionMatrixInverse ).toVar();
 			const viewNormal = this.normalNode.sample( uvNode ).rgb.normalize().toVar();

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

@@ -1,5 +1,5 @@
-import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils, MathUtils, RGBFormat, RedFormat, UnsignedInt101111Type, UnsignedByteType } from 'three/webgpu';
-import { clamp, normalize, reference, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, countOneBits, interleavedGradientNoise, property, outputStruct, context } from 'three/tsl';
+import { RenderTarget, Vector2, Node, QuadMesh, NodeMaterial, RendererUtils, MathUtils, RGBFormat, RedFormat, UnsignedInt101111Type, UnsignedByteType } from 'three/webgpu';
+import { clamp, normalize, reference, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, countOneBits, interleavedGradientNoise, property, outputStruct, context, isBackgroundDepth, min, projectionDepth } from 'three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -37,10 +37,10 @@ let _rendererState;
  * - Medium: `sliceCount` of `3`, `stepCount` of `8`.
  * - High: `sliceCount` of `4`, `stepCount` of `12`.
  *
- * @augments TempNode
+ * @augments Node
  * @three_import import { ssgi } from 'three/addons/tsl/display/SSGINode.js';
  */
-class SSGINode extends TempNode {
+class SSGINode extends Node {
 
 	static get type() {
 
@@ -83,6 +83,16 @@ class SSGINode extends TempNode {
 		 */
 		this.normalNode = normalNode;
 
+		/**
+		 * The resolution scale. Values towards `0.5` noticeably increase noise, so it's
+		 * recommended to lower the renderer's pixel ratio first. Use this property only
+		 * for fine-tuning performance.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.resolutionScale = 1;
+
 		/**
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders
 		 * its effect once per frame in `updateBefore()`.
@@ -226,6 +236,14 @@ class SSGINode extends TempNode {
 		 */
 		this._temporalOffset = uniform( 0 );
 
+		/**
+		 * Resolution scale uniform.
+		 *
+		 * @private
+		 * @type {UniformNode<float>}
+		 */
+		this._resolutionScale = uniform( 0 );
+
 		/**
 		 * Represents the projection matrix of the scene's camera.
 		 *
@@ -342,6 +360,10 @@ class SSGINode extends TempNode {
 	 */
 	setSize( width, height ) {
 
+		width = Math.round( this.resolutionScale * width );
+		height = Math.round( this.resolutionScale * height );
+
+		this._resolutionScale.value = this.resolutionScale;
 		this._resolution.value.set( width, height );
 		this._ssgiRenderTarget.setSize( width, height );
 
@@ -421,19 +443,16 @@ class SSGINode extends TempNode {
 		const MAX_RAY = uint( 32 );
 		const globalOccludedBitfield = uint( 0 );
 
-		const sampleDepth = ( uv ) => {
+		const sampleDepth = ( uv ) => projectionDepth( this.depthNode.sample( uv ).r, this._cameraNear, this._cameraFar );
 
-			const depth = this.depthNode.sample( uv ).r;
+		const sampleCenterDepth = ( uv ) => {
 
-			if ( builder.renderer.logarithmicDepthBuffer === true ) {
+			// Sidestep the nearest-rounding during depth access for the unjittered center pixel to avoid banding
 
-				const viewZ = logarithmicDepthToViewZ( depth, this._cameraNear, this._cameraFar );
+			const g = this.depthNode.gather().sample( uv );
+			const depth = builder.renderer.reversedDepthBuffer === true ? max( max( g.x, g.y ), max( g.z, g.w ) ) : min( min( g.x, g.y ), min( g.z, g.w ) );
 
-				return viewZToPerspectiveDepth( viewZ, this._cameraNear, this._cameraFar );
-
-			}
-
-			return depth;
+			return projectionDepth( depth, this._cameraNear, this._cameraFar );
 
 		};
 
@@ -446,13 +465,7 @@ class SSGINode extends TempNode {
 
 			return float( 0.25 ).mul( sub( position.y, position.x ).bitAnd( 3 ) );
 
-		} ).setLayout( {
-			name: 'spatialOffsets',
-			type: 'float',
-			inputs: [
-				{ name: 'position', type: 'vec2' }
-			]
-		} );
+		}, { position: 'vec2', return: 'float' } );
 
 		const GTAOFastAcos = Fn( ( [ value ] ) => {
 
@@ -464,13 +477,7 @@ class SSGINode extends TempNode {
 
 			return vec2( x, y );
 
-		} ).setLayout( {
-			name: 'GTAOFastAcos',
-			type: 'vec2',
-			inputs: [
-				{ name: 'value', type: 'vec2' }
-			]
-		} );
+		}, { value: 'vec2', return: 'vec2' } );
 
 		const horizonSampling = Fn( ( [ directionIsRight, stepRadius, radiusVS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ] ) => {
 
@@ -563,9 +570,9 @@ class SSGINode extends TempNode {
 
 		const gi = Fn( () => {
 
-			const depth = sampleDepth( uvNode ).toVar();
+			const depth = this._resolutionScale.lessThan( 1 ).select( sampleCenterDepth( uvNode ), sampleDepth( uvNode ) ).toConst();
 
-			depth.greaterThanEqual( 1.0 ).discard();
+			isBackgroundDepth( depth ).discard();
 
 			const viewPosition = getViewPosition( uvNode, depth, this._cameraProjectionMatrixInverse ).toVar();
 			const viewNormal = sampleNormal( uvNode ).toVar();