three-gpu-pathtracer 0.0.24 → 0.0.25

package/src/webgpu/nodes/utils.wgsl.js

@@ -0,0 +1,366 @@
+import { wgslFn } from 'three/tsl';
+import { scatterRecordStruct } from './structs.wgsl.js';
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+
+export const inverseMat3x3Func = wgslFn( /* wgsl */ `
+
+	fn inverse(m: mat3x3f) -> mat3x3f {
+		var adj: mat3x3f;
+		adj[0][0] =   (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+		adj[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+		adj[2][0] =   (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+		adj[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+		adj[1][1] =   (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+		adj[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+		adj[0][2] =   (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		adj[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+		adj[2][2] =   (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+
+		let det = ( m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
+			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]));
+
+		return adj * ( 1.0 / det );
+	}
+
+` );
+
+export const getBasisFromNormalFunc = wgslFn( /* wgsl */ `
+
+	fn getBasisFromNormal( normal: vec3f ) -> mat3x3f {
+
+		var other: vec3f;
+		if ( abs( normal.x ) > 0.5 ) {
+
+			other = vec3f( 0.0, 1.0, 0.0 );
+
+		} else {
+
+			other = vec3f( 1.0, 0.0, 0.0 );
+
+		}
+
+		let ortho = normalize( cross( normal, other ) );
+		let ortho2 = normalize( cross( normal, ortho ) );
+		return mat3x3f( ortho2, ortho, normal );
+
+	}
+
+` );
+
+export const iorToF0Func = wgslFn( /* wgsl */ `
+
+	fn iorToF0( ior: f32 ) -> f32 {
+		return pow( ( 1 - ior ) / ( 1 + ior ), 2 );
+	}
+
+` );
+
+export const iorToF0GeneralFunc = wgslFn( /* wgsl */ `
+
+	fn iorToF0General( transmittedIor: f32, incidentIor: f32 ) -> f32 {
+
+		return pow( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ), 2 );
+
+	}
+
+` );
+
+export const iorToF0GeneralVecFunc = wgslFn( /* wgsl */ `
+
+	fn iorToF0GeneralVec( transmittedIor: vec3f, incidentIor: vec3f ) -> vec3f {
+
+		let v = ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor );
+		return v * v;
+
+	}
+
+` );
+
+export const fresnel0ToIorFunc = wgslFn( /* wgsl */ `
+
+	fn fresnel0ToIor( f0: vec3f ) -> vec3f {
+
+		let sqrtF0 = sqrt( f0 );
+		return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );
+
+	}
+
+` );
+
+export const schlickFresnelFunc = wgslFn( /* wgsl */ `
+
+	fn schlickFresnel( cosine: f32, f0: f32 ) -> f32 {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+` );
+
+export const schlickFresnelVecFunc = wgslFn( /* wgsl */ `
+
+	fn schlickFresnelVec( cosine: f32, f0: vec3f, f90: vec3f ) -> vec3f {
+
+		return f0 + ( f90 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+` );
+
+export const totalInternalReflectionFunc = wgslFn( /* wgsl */ `
+
+	fn totalInternalReflection( cosTheta: f32, eta: f32 ) -> bool {
+
+		let sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+		return eta * sinTheta > 1.0;
+
+	}
+
+` );
+
+export const totalInternalReflectionVecFunc = wgslFn( /* wgsl */ `
+
+	fn totalInternalReflectionVec( cosTheta: f32, eta: vec3f ) -> vec3<bool> {
+
+		let sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+		return eta * sinTheta > vec3f( 1.0 );
+
+	}
+
+` );
+
+export const evaluateFresnelFunc = wgslFn( /* wgsl */ `
+
+	fn evaluateFresnel( cosine: f32, eta: f32, f0: vec3f, f90: vec3f ) -> vec3f {
+
+		if ( totalInternalReflection( cosine, eta ) ) {
+
+			return f90;
+
+		}
+
+		return f0 + ( f90 - f0 ) * pow( 1.0 - cosine, 5.0 );
+	}
+
+`, [ totalInternalReflectionFunc ] );
+
+export const dielectricFresnelFunc = wgslFn( /* wgsl */ `
+
+	fn dielectricFresnel( cosThetaI: f32, eta: f32 ) -> f32 {
+
+		// https://schuttejoe.github.io/post/disneybsdf/
+		let ni = eta;
+		let nt = 1.0;
+
+		// Check for total internal reflection
+		let sinThetaISq = 1.0 - cosThetaI * cosThetaI;
+		let sinThetaTSq = eta * eta * sinThetaISq;
+		if ( sinThetaTSq >= 1.0 ) {
+
+			return 1.0;
+
+		}
+
+		let sinThetaT = sqrt( sinThetaTSq );
+		let cosThetaT = sqrt( max( 0.0, 1.0 - sinThetaT * sinThetaT ) );
+		let rParallel = ( ( nt * cosThetaI ) - ( ni * cosThetaT ) ) / ( ( nt * cosThetaI ) + ( ni * cosThetaT ) );
+		let rPerpendicular = ( ( ni * cosThetaI ) - ( nt * cosThetaT ) ) / ( ( ni * cosThetaI ) + ( nt * cosThetaT ) );
+		return ( rParallel * rParallel + rPerpendicular * rPerpendicular ) / 2.0;
+
+	}
+
+` );
+
+export const disneyFresnelFunc = wgslFn( /* wgsl */ `
+
+	fn disneyFresnel( wo: vec3f, wi: vec3f, wh: vec3f, f0: f32, eta: f32, metalness: f32 ) -> f32 {
+
+		let dotHV = dot( wo, wh );
+		if ( totalInternalReflection( dotHV, eta ) ) {
+
+			return 1.0;
+
+		}
+
+		let dotHL = dot( wi, wh );
+		let dielectricF = dielectricFresnel( abs( dotHV ), eta );
+		let metallicF = schlickFresnel( dotHL, f0 );
+
+		return mix( dielectricF, metallicF, metalness );
+
+	}
+
+`, [ totalInternalReflectionFunc, dielectricFresnelFunc, schlickFresnelFunc ] );
+
+export const isTerminatingScatterFunc = wgslFn( /* wgsl */ `
+
+	fn isTerminatingScatter( scatterRec: ScatterRecord ) -> bool {
+
+		return scatterRec.pdf <= 0;
+
+	}
+
+`, [ scatterRecordStruct ] );
+
+// Clamp individual light-path contributions using Cycles' RGB sum while preserving chromaticity.
+// Matches film_clamp_light in Cycles' kernel/film/light_passes.h, including the x3 limit
+// scaling applied to the user-facing clamp values in scene/integrator.cpp.
+export const clampPathContributionFunc = wgslFn( /* wgsl */ `
+
+	fn clampPathContribution( contribution: vec3f, pathDepth: u32, clampDirect: f32, clampIndirect: f32 ) -> vec3f {
+
+		let limit = select( clampIndirect, clampDirect, pathDepth <= 1u ) * 3.0;
+		if ( limit <= 0.0 ) {
+
+			return contribution;
+
+		}
+
+		let strength = dot( abs( contribution ), vec3f( 1.0 ) );
+		if ( strength > limit ) {
+
+			return contribution * ( limit / strength );
+
+		}
+
+		return contribution;
+
+	}
+
+` );
+
+export const applyWrapFunc = wgslFn( /* wgsl */ `
+
+	fn applyWrap( v: f32, wrapMode: i32 ) -> f32 {
+
+		var res = v;
+		if ( wrapMode == 1 ) {
+
+			// ClampToEdge
+			res = clamp( res, 0.0, 1.0 );
+
+		} else if ( wrapMode == 2 ) {
+
+			// MirroredRepeat
+			res = 1.0 - abs( 2.0 * fract( res * 0.5 ) - 1.0 );
+
+		} else {
+
+			// Repeat
+			res = fract( res );
+
+		}
+
+		return res;
+
+	}
+
+` );
+
+// Bit-level ray origin offset based on Section 6.2.2 of "A Fast and Robust
+// Method for Avoiding Self-Intersection" in Ray Tracing Gems:
+// https://github.com/Apress/ray-tracing-gems/blob/master/Ch_06_A_Fast_and_Robust_Method_for_Avoiding_Self-Intersection/offset_ray.cu
+// The original implementation expects a normal oriented for the outgoing ray;
+// this version orients the geometric normal internally.
+export const offsetRayOriginFunc = wgslFn( /* wgsl */ `
+
+	fn offsetRayOrigin( point: vec3f, direction: vec3f, geometricNormal: vec3f ) -> vec3f {
+
+		let normal = normalize( select( -geometricNormal, geometricNormal, dot( direction, geometricNormal ) >= 0.0 ) );
+		let intScale = 256.0;
+		let integerOffset = vec3i( intScale * normal );
+		let pointBits = bitcast<vec3i>( point );
+		let signedOffset = select( integerOffset, -integerOffset, point < vec3f( 0.0 ) );
+		let offsetPoint = bitcast<vec3f>( pointBits + signedOffset );
+		let origin = 1.0 / 32.0;
+		let floatScale = 1.0 / 65536.0;
+		return select( offsetPoint, point + floatScale * normal, abs( point ) < vec3f( origin ) );
+
+	}
+
+` );
+
+// Wraps a bilinear tap that is off the edge of a tile back to the texel the wrap mode calls for
+export const wrapTexelIndexFunc = wgslFn( /* wgsl */ `
+
+	fn wrapTexelIndex( i: i32, size: i32, wrapMode: i32 ) -> i32 {
+
+		if ( wrapMode == 0 ) {
+
+			// Repeat wraps to the opposite edge
+			return ( ( i % size ) + size ) % size;
+
+		}
+
+		// ClampToEdge and MirroredRepeat both fold back onto the edge texel
+		return clamp( i, 0, size - 1 );
+
+	}
+
+` );
+
+// Factory: builds sampleTexel bound to the given per-instance textureInfo uniform
+// array node ( must be named "textureInfo" ). Called once per scene so a single
+// sampleTexel / textureInfo binding is shared by every caller in a pipeline. A distinct
+// name must be given when a second atlas binding is used in the same pipeline.
+export const sampleTexelFunc = ( textureInfoUniform, atlas, name = 'sampleTexel' ) => wgslTagFn/* wgsl */ `
+
+	fn ${ name }( uv: vec2f, packed: i32, lod: f32 ) -> vec4f {
+
+		let texIndex = packed & 0x7FFFFF;
+		let wrapS    = ( packed >> 26 ) & 0x3;
+		let wrapT    = ( packed >> 28 ) & 0x3;
+		let nearest  = ( packed >> 30 ) & 0x1;
+
+		// look up the texture's rect and page within the atlas. three wraps a
+		// uniformArray in a struct ( textureInfoStruct ) with a "value" array member.
+		let info   = ${ textureInfoUniform }[ u32( texIndex ) ];
+		let offset = vec2f( vec2u( info.x & 0xFFFFu, info.x >> 16u ) );
+		let size   = vec2f( vec2u( info.y & 0xFFFFu, info.y >> 16u ) );
+		let page   = i32( info.z & 0xFFFFu );
+
+		// wrap is applied on the logical uv first, then remapped into the tile
+		let wrappedUv = vec2f(
+			${ applyWrapFunc }( uv.x, wrapS ),
+			${ applyWrapFunc }( uv.y, wrapT ),
+		);
+
+		if ( nearest == 1 ) {
+
+			let tileTexel = clamp( vec2i( wrappedUv * size ), vec2i( 0 ), vec2i( size ) - vec2i( 1 ) );
+			return textureLoad( ${ atlas }, vec2i( offset ) + tileTexel, page, 0 );
+
+		} else {
+
+			// The tile's neighbors in the atlas are unrelated textures, so hardware
+			// filtering cannot supply the taps that fall outside it. Filter here instead
+			// and resolve each tap through the wrap mode.
+			let texelPos = wrappedUv * size - vec2f( 0.5 );
+			let basePos = floor( texelPos );
+			let base = vec2i( basePos );
+			let f = texelPos - basePos;
+
+			let intSize = vec2i( size );
+			let x0 = ${ wrapTexelIndexFunc }( base.x,     intSize.x, wrapS );
+			let x1 = ${ wrapTexelIndexFunc }( base.x + 1, intSize.x, wrapS );
+			let y0 = ${ wrapTexelIndexFunc }( base.y,     intSize.y, wrapT );
+			let y1 = ${ wrapTexelIndexFunc }( base.y + 1, intSize.y, wrapT );
+
+			let tile = vec2i( offset );
+			let c00 = textureLoad( ${ atlas }, tile + vec2i( x0, y0 ), page, 0 );
+			let c10 = textureLoad( ${ atlas }, tile + vec2i( x1, y0 ), page, 0 );
+			let c01 = textureLoad( ${ atlas }, tile + vec2i( x0, y1 ), page, 0 );
+			let c11 = textureLoad( ${ atlas }, tile + vec2i( x1, y1 ), page, 0 );
+
+			return mix(
+				mix( c00, c10, f.x ),
+				mix( c01, c11, f.x ),
+				f.y,
+			);
+
+		}
+
+	}
+`;
+

package/src/webgpu/shims/ArrayCameraShim.js

@@ -0,0 +1,74 @@
+import { ArrayCamera, Matrix4, Vector4, WebGPUCoordinateSystem } from 'three';
+import { uniformArray, int } from 'three/tsl';
+import { ndcToCameraRay, rayStruct, wgslTagFn } from 'three-mesh-bvh/webgpu';
+
+ArrayCamera.prototype.getCameraRayFn = function getCameraRayFn() {
+
+	const result = { fn: null, update: null };
+
+	const cameraCount = int( 0 );
+	const invViewProjectionMatrices = uniformArray( [], 'mat4' );
+	const viewports = uniformArray( [], 'vec4' );
+
+	result.fn = wgslTagFn/* wgsl */`
+		fn getCameraRay( uv: vec2f, resolution: vec2f, ray: ptr<function, ${ rayStruct }> ) -> bool {
+
+			let pixel = uv * resolution;
+
+			for ( var i = 0u; i < ${ cameraCount }u; i ++ ) {
+
+				let viewport = ${ viewports }[ i ];
+				let viewportMax = viewport.xy + viewport.zw;
+				if ( all( pixel >= viewport.xy ) && all( pixel < viewportMax ) ) {
+
+					let cameraUv = ( pixel - viewport.xy ) / viewport.zw;
+					let ndc = cameraUv * 2.0 - vec2f( 1.0 );
+					*ray = ${ ndcToCameraRay }( ndc, ${ invViewProjectionMatrices }[ i ] );
+					return true;
+
+				}
+
+			}
+
+			return false;
+
+		}
+	`;
+
+	result.update = () => {
+
+		const { cameras } = this;
+		const needsRebuild = cameraCount.node.value !== cameras.length;
+		cameraCount.node.value = cameras.length;
+
+		while ( viewports.array.length < cameras.length ) {
+
+			viewports.array.push( new Vector4() );
+			invViewProjectionMatrices.array.push( new Matrix4() );
+
+		}
+
+		invViewProjectionMatrices.array.length = cameras.length;
+		viewports.array.length = cameras.length;
+
+		for ( let i = 0; i < cameras.length; i ++ ) {
+
+			const camera = cameras[ i ];
+			const viewport = camera.viewport;
+
+			camera.coordinateSystem = WebGPUCoordinateSystem;
+			camera.updateMatrixWorld();
+			camera.updateProjectionMatrix();
+
+			invViewProjectionMatrices.array[ i ].multiplyMatrices( camera.matrixWorld, camera.projectionMatrixInverse );
+			viewports.array[ i ].copy( viewport );
+
+		}
+
+		return needsRebuild;
+
+	};
+
+	return result;
+
+};

package/src/webgpu/shims/EquirectCameraShim.js

@@ -0,0 +1,37 @@
+import { Matrix4 } from 'three';
+import { uniform, PI } from 'three/tsl';
+import { wgslTagFn, rayStruct } from 'three-mesh-bvh/webgpu';
+import { EquirectCamera } from '../../objects/EquirectCamera.js';
+
+EquirectCamera.prototype.getCameraRayFn = function getCameraRayFn() {
+
+	const cameraToWorld = uniform( new Matrix4() );
+	const fn = wgslTagFn/* wgsl */`
+		fn getCameraRay( uv: vec2f, resolution: vec2f, ray: ptr<function, ${ rayStruct }> ) -> bool {
+
+			// screen uv to spherical direction, matching three.js' equirect orientation
+			let theta = ( uv.x - 0.5 ) * 2.0 * ${ PI };
+			let phi = ( 1.0 - uv.y ) * ${ PI };
+			let sinPhi = sin( phi );
+			let direction = vec3f( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+
+			// equirect ignores the projection - orient by the camera world matrix and place the origin.
+			// there is no projection far plane, so the trace distance is unbounded
+			ray.origin = ( ${ cameraToWorld } * vec4f( 0.0, 0.0, 0.0, 1.0 ) ).xyz;
+			ray.direction = ( ${ cameraToWorld } * vec4f( direction, 0.0 ) ).xyz;
+			ray.maxDist = 0.0;
+			return true;
+
+		}
+	`;
+
+	const update = () => {
+
+		cameraToWorld.value.copy( this.matrixWorld );
+		return false;
+
+	};
+
+	return { fn, update };
+
+};

package/src/webgpu/shims/PhysicalCameraShim.js

@@ -0,0 +1,151 @@
+import { Matrix4, WebGPUCoordinateSystem } from 'three';
+import { uniform, PI } from 'three/tsl';
+import { wgslTagFn, rayStruct, ndcToCameraRay } from 'three-mesh-bvh/webgpu';
+import { rand3, RNG_INDEX_APERTURE_SAMPLE } from '../nodes/random.wgsl.js';
+import { PhysicalCamera } from '../../objects/PhysicalCamera.js';
+
+// aperture sampling helpers
+const sampleCircle = wgslTagFn/* wgsl */`
+	fn sampleCircle( uv: vec2f ) -> vec2f {
+
+		let angle = 2.0 * ${ PI } * uv.x;
+		let radius = sqrt( uv.y );
+		return vec2f( cos( angle ), sin( angle ) ) * radius;
+
+	}
+`;
+
+const sampleTriangle = wgslTagFn/* wgsl */`
+	fn sampleTriangle( a: vec2f, b: vec2f, c: vec2f, rIn: vec2f ) -> vec2f {
+
+		let e1 = a - b;
+		let e2 = c - b;
+
+		var r = rIn;
+		if ( r.x + r.y > 1.0 ) {
+
+			r = vec2f( 1.0 ) - r;
+
+		}
+
+		return e1 * r.x + e2 * r.y;
+
+	}
+`;
+
+const sampleRegularPolygon = wgslTagFn/* wgsl */`
+	fn sampleRegularPolygon( sidesIn: i32, uvw: vec3f ) -> vec2f {
+
+		let sides = max( sidesIn, 3 );
+		let anglePerSegment = 2.0 * ${ PI } / f32( sides );
+		let segment = floor( f32( sides ) * uvw.x );
+
+		let angle1 = anglePerSegment * segment;
+		let angle2 = angle1 + anglePerSegment;
+		let a = vec2f( sin( angle1 ), cos( angle1 ) );
+		let b = vec2f( 0.0, 0.0 );
+		let c = vec2f( sin( angle2 ), cos( angle2 ) );
+
+		return ${ sampleTriangle }( a, b, c, uvw.yz );
+
+	}
+`;
+
+// samples an aperture shape with the given number of blades. 0 means circle
+const sampleAperture = wgslTagFn/* wgsl */`
+	fn sampleAperture( blades: i32, uvw: vec3f ) -> vec2f {
+
+		if ( blades == 0 ) {
+
+			return ${ sampleCircle }( uvw.xy );
+
+		} else {
+
+			return ${ sampleRegularPolygon }( blades, uvw );
+
+		}
+
+	}
+`;
+
+const rotateVector = wgslTagFn/* wgsl */`
+	fn rotateVector( v: vec2f, t: f32 ) -> vec2f {
+
+		let vc = cos( t );
+		let vs = sin( t );
+		return vec2f( v.x * vc - v.y * vs, v.x * vs + v.y * vc );
+
+	}
+`;
+
+PhysicalCamera.prototype.getCameraRayFn = function getCameraRayFn() {
+
+	// camera transform fields
+	const invViewProjectionMatrix = uniform( new Matrix4() );
+	const cameraWorldMatrix = uniform( new Matrix4() );
+
+	// bokeh shape fields
+	const focusDistance = uniform( 0 );
+	const bokehSize = uniform( 0 );
+	const apertureBlades = uniform( 0, 'int' );
+	const apertureRotation = uniform( 0 );
+	const anamorphicRatio = uniform( 1 );
+
+	const fn = wgslTagFn/* wgsl */`
+		fn getCameraRay( uv: vec2f, resolution: vec2f, ray: ptr<function, ${ rayStruct }> ) -> bool {
+
+			// base ray
+			let ndc = uv * 2.0 - vec2f( 1.0 );
+			*ray = ${ ndcToCameraRay }( ndc, ${ invViewProjectionMatrix } );
+
+			// camera state
+			let forward = normalize( ( ${ cameraWorldMatrix } * vec4f( 0.0, 0.0, - 1.0, 0.0 ) ).xyz );
+			let cameraOrigin = ( ${ cameraWorldMatrix } * vec4f( 0.0, 0.0, 0.0, 1.0 ) ).xyz;
+
+			// depth of field
+			// measure focus distance from the camera origin along the optical axis so the focal
+			// surface is a flat plane perpendicular to the camera forward vector rather than a sphere
+			let focalPoint = cameraOrigin + ray.direction * ( ${ focusDistance } / dot( ray.direction, forward ) );
+			let nearDistance = dot( ray.origin - cameraOrigin, forward );
+
+			// sample the aperture shape
+			let shapeUVW = ${ rand3 }( ${ RNG_INDEX_APERTURE_SAMPLE } );
+			var apertureSample = ${ sampleAperture }( ${ apertureBlades }, shapeUVW );
+			apertureSample *= ${ bokehSize } * 0.5 * 1e-3;
+
+			// rotate + squash the sample for anamorphic apertures
+			apertureSample =
+				${ rotateVector }( apertureSample, ${ apertureRotation } )
+				* vec2f( ${ anamorphicRatio }, 1.0 / ${ anamorphicRatio } );
+
+			// aim from the aperture through the focal point, starting on the near plane like the base ray
+			ray.origin = cameraOrigin + ( ${ cameraWorldMatrix } * vec4f( apertureSample, 0.0, 0.0 ) ).xyz;
+			ray.direction = normalize( focalPoint - ray.origin );
+			ray.origin += ray.direction * ( nearDistance / dot( ray.direction, forward ) );
+
+			return true;
+
+		}
+	`;
+
+	const update = () => {
+
+		this.coordinateSystem = WebGPUCoordinateSystem;
+		this.updateMatrixWorld();
+		this.updateProjectionMatrix();
+
+		invViewProjectionMatrix.value.multiplyMatrices( this.matrixWorld, this.projectionMatrixInverse );
+		cameraWorldMatrix.value.copy( this.matrixWorld );
+
+		focusDistance.value = this.focusDistance;
+		bokehSize.value = this.bokehSize;
+		apertureBlades.value = this.apertureBlades;
+		apertureRotation.value = this.apertureRotation;
+		anamorphicRatio.value = this.anamorphicRatio;
+		return false;
+
+	};
+
+	return { fn, update };
+
+};