rayzee 5.10.2 → 6.0.0

package/src/Processor/TextureCreator.js

@@ -351,7 +351,8 @@ class TextureCache {
 				const width = texture.image.width || 0;
 				const height = texture.image.height || 0;
 				const src = texture.image.src || texture.uuid || '';
-				hash += `${width}x${height}_${src.slice( - 8 )}_`;
+				const flipFlag = texture.flipY === false ? 'n' : 'f';
+				hash += `${width}x${height}_${src.slice( - 8 )}_${flipFlag}_`;
 
 			}
 
@@ -681,12 +682,16 @@ export class TextureCreator {
 
 			if ( ! texture?.image ) continue;
 
+			const flipY = texture.flipY !== false;
+
 			try {
 
 				// Option 1: Direct ImageBitmap transfer (when supported)
 				if ( typeof createImageBitmap !== 'undefined' && texture.image instanceof HTMLImageElement ) {
 
-					const bitmap = await createImageBitmap( texture.image );
+					const bitmap = await createImageBitmap( texture.image, {
+						imageOrientation: flipY ? 'flipY' : 'none',
+					} );
 					texturesData.push( {
 						bitmap: bitmap,
 						width: texture.image.width,
@@ -696,16 +701,22 @@ export class TextureCreator {
 
 				} else { // Option 2: Efficient canvas-based transfer
 
-					const pair = this.canvasPool.getCanvasWithContext( texture.image.width, texture.image.height );
+					const w = texture.image.width;
+					const h = texture.image.height;
+					const bitmap = await createImageBitmap( texture.image, {
+						imageOrientation: flipY ? 'flipY' : 'none',
+					} );
+					const pair = this.canvasPool.getCanvasWithContext( w, h );
 
-					pair.context.drawImage( texture.image, 0, 0 );
-					const imageData = pair.context.getImageData( 0, 0, texture.image.width, texture.image.height );
+					pair.context.drawImage( bitmap, 0, 0 );
+					bitmap.close();
+					const imageData = pair.context.getImageData( 0, 0, w, h );
 
 					// Transfer the underlying ArrayBuffer directly
 					texturesData.push( {
 						data: imageData.data.buffer, // Direct buffer transfer
-						width: texture.image.width,
-						height: texture.image.height,
+						width: w,
+						height: h,
 						isImageData: true
 					} );
 
@@ -759,11 +770,13 @@ export class TextureCreator {
 			for ( let i = batchStart; i < batchEnd; i ++ ) {
 
 				const texture = validTextures[ i ];
+				const flipY = texture.flipY !== false;
 
 				const bitmapPromise = createImageBitmap( texture.image, {
 					resizeWidth: maxWidth,
 					resizeHeight: maxHeight,
-					resizeQuality: 'high'
+					resizeQuality: 'high',
+					imageOrientation: flipY ? 'flipY' : 'none',
 				} );
 
 				batchPromises.push(
@@ -815,9 +828,16 @@ export class TextureCreator {
 		for ( let i = 0; i < validTextures.length; i ++ ) {
 
 			const texture = validTextures[ i ];
+			const bitmap = await createImageBitmap( texture.image, {
+				resizeWidth: maxWidth,
+				resizeHeight: maxHeight,
+				resizeQuality: 'high',
+				imageOrientation: texture.flipY !== false ? 'flipY' : 'none',
+			} );
 
 			pair.context.clearRect( 0, 0, maxWidth, maxHeight );
-			pair.context.drawImage( texture.image, 0, 0, maxWidth, maxHeight );
+			pair.context.drawImage( bitmap, 0, 0 );
+			bitmap.close();
 
 			const imageData = pair.context.getImageData( 0, 0, maxWidth, maxHeight );
 			const offset = maxWidth * maxHeight * 4 * i;
@@ -853,9 +873,16 @@ export class TextureCreator {
 		for ( let i = 0; i < validTextures.length; i ++ ) {
 
 			const texture = validTextures[ i ];
+			const bitmap = await createImageBitmap( texture.image, {
+				resizeWidth: maxWidth,
+				resizeHeight: maxHeight,
+				resizeQuality: 'high',
+				imageOrientation: texture.flipY !== false ? 'flipY' : 'none',
+			} );
 
 			pair.context.clearRect( 0, 0, maxWidth, maxHeight );
-			pair.context.drawImage( texture.image, 0, 0, maxWidth, maxHeight );
+			pair.context.drawImage( bitmap, 0, 0 );
+			bitmap.close();
 
 			const imageData = pair.context.getImageData( 0, 0, maxWidth, maxHeight );
 			const offset = maxWidth * maxHeight * 4 * i;
@@ -1301,7 +1328,7 @@ export class TextureCreator {
 				const mip = tex.mipmaps[ 0 ];
 				const idx = normalized.length;
 				normalized.push( null ); // placeholder — filled after Promise.all
-				bitmapJobs.push( { index: idx, promise: _rawPixelsToBitmap( mip.data, mip.width, mip.height ) } );
+				bitmapJobs.push( { index: idx, flipY: tex.flipY, promise: _rawPixelsToBitmap( mip.data, mip.width, mip.height ) } );
 				continue;
 
 			}
@@ -1323,7 +1350,7 @@ export class TextureCreator {
 
 				const idx = normalized.length;
 				normalized.push( null );
-				bitmapJobs.push( { index: idx, promise: _rawPixelsToBitmap( tex.image.data, tex.image.width, tex.image.height ) } );
+				bitmapJobs.push( { index: idx, flipY: tex.flipY, promise: _rawPixelsToBitmap( tex.image.data, tex.image.width, tex.image.height ) } );
 				continue;
 
 			}
@@ -1339,14 +1366,14 @@ export class TextureCreator {
 
 			for ( let i = 0; i < bitmapJobs.length; i ++ ) {
 
-				const { index } = bitmapJobs[ i ];
+				const { index, flipY } = bitmapJobs[ i ];
 				const result = results[ i ];
 
 				if ( result.status === 'fulfilled' ) {
 
 					const bitmap = result.value;
 					bitmapsToClose.push( bitmap );
-					normalized[ index ] = { image: bitmap };
+					normalized[ index ] = { image: bitmap, flipY };
 
 				} else {
 
@@ -1367,7 +1394,7 @@ export class TextureCreator {
 				const placeholder = new Uint8ClampedArray( [ 255, 255, 255, 255 ] );
 				const bitmap = await createImageBitmap( new ImageData( placeholder, 1, 1 ) );
 				bitmapsToClose.push( bitmap );
-				normalized[ i ] = { image: bitmap };
+				normalized[ i ] = { image: bitmap, flipY: false };
 
 			}
 

package/src/Processor/Workers/AIUpscalerWorker.js

@@ -14,8 +14,13 @@
  *     { type: 'error', message, id? }
  */
 
-// Loaded lazily via CDN to avoid bundling the 69 MB onnxruntime-web package
-const ORT_CDN_URL = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/ort.webgpu.bundle.min.mjs';
+// Asset config supplied via 'load' message from the main thread.
+// Defaults match the upstream Rayzee deployment; override via configureAssets().
+let _assetConfig = {
+	ortRuntimeUrl: 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/ort.webgpu.bundle.min.mjs',
+	ortWasmPaths: 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/',
+	cacheNamespace: 'rayzee',
+};
 
 let ort = null;
 
@@ -23,17 +28,23 @@ async function getOrt() {
 
 	if ( ort ) return ort;
 
-	ort = await import( /* @vite-ignore */ ORT_CDN_URL );
+	ort = await import( /* @vite-ignore */ _assetConfig.ortRuntimeUrl );
 
 	// WASM paths for CDN delivery — WebGPU EP still uses WASM for lightweight shape ops
-	ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.24.3/dist/';
+	ort.env.wasm.wasmPaths = _assetConfig.ortWasmPaths;
 	ort.env.logLevel = 'error';
 
 	return ort;
 
 }
 
-const IDB_NAME = 'ai-upscaler-models';
+// IndexedDB names are namespaced so multiple consumers on the same origin don't collide.
+function getIdbName() {
+
+	return `${_assetConfig.cacheNamespace}:ai-upscaler-models`;
+
+}
+
 const IDB_STORE = 'models';
 
 let session = null;
@@ -45,7 +56,7 @@ function openDB() {
 
 	return new Promise( ( resolve, reject ) => {
 
-		const req = indexedDB.open( IDB_NAME, 1 );
+		const req = indexedDB.open( getIdbName(), 1 );
 		req.onupgradeneeded = () => req.result.createObjectStore( IDB_STORE );
 		req.onsuccess = () => resolve( req.result );
 		req.onerror = () => reject( req.error );
@@ -204,6 +215,10 @@ self.onmessage = async ( e ) => {
 
 		if ( type === 'load' ) {
 
+			// Apply asset overrides from main thread before any network or cache access
+			if ( e.data.ortRuntimeUrl ) _assetConfig.ortRuntimeUrl = e.data.ortRuntimeUrl;
+			if ( e.data.ortWasmPaths ) _assetConfig.ortWasmPaths = e.data.ortWasmPaths;
+			if ( e.data.cacheNamespace ) _assetConfig.cacheNamespace = e.data.cacheNamespace;
 			await loadModel( e.data.url, e.data.sessionOptions );
 
 		} else if ( type === 'infer' ) {

package/src/Stages/ASVGF.js

@@ -4,7 +4,6 @@ import { Fn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform,
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, FloatType, RGBAFormat, NearestFilter, LinearFilter } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
-import { createRenderTargetHelper } from '../Processor/createRenderTargetHelper.js';
 import { luminance } from '../TSL/Common.js';
 
 /**
@@ -25,7 +24,6 @@ export class ASVGF extends RenderStage {
 		} );
 
 		this.renderer = renderer;
-		this.debugContainer = options.debugContainer || null;
 
 		this.temporalAlpha = uniform( options.temporalAlpha ?? 0.1 );
 		this.phiColor = uniform( options.phiColor ?? 10.0 );
@@ -101,17 +99,6 @@ export class ASVGF extends RenderStage {
 
 		this._buildHeatmapCompute();
 
-		this.heatmapHelper = createRenderTargetHelper( this.renderer, this.heatmapTarget, {
-			width: 400,
-			height: 400,
-			position: 'bottom-right',
-			theme: 'dark',
-			title: 'ASVGF Debug',
-			autoUpdate: false
-		} );
-		this.heatmapHelper.hide();
-		( this.debugContainer || document.body ).appendChild( this.heatmapHelper );
-
 		this.frameCount = 0;
 
 	}
@@ -568,7 +555,6 @@ export class ASVGF extends RenderStage {
 
 			this.renderer.compute( this._heatmapComputeNode );
 			this.renderer.copyTextureToTexture( this._heatmapStorageTex, this.heatmapTarget.texture );
-			this.heatmapHelper.update();
 
 		}
 
@@ -576,18 +562,14 @@ export class ASVGF extends RenderStage {
 
 	}
 
-	toggleHeatmap( enabled ) {
+	/**
+	 * Enable or disable the heatmap compute pass. When enabled, the heatmap
+	 * is rendered each frame to {@link this.heatmapTarget} (a public RenderTarget)
+	 * for the host to display however it wants.
+	 */
+	setHeatmapEnabled( enabled ) {
 
 		this.showHeatmap = enabled;
-		if ( enabled ) {
-
-			this.heatmapHelper.show();
-
-		} else {
-
-			this.heatmapHelper.hide();
-
-		}
 
 	}
 
@@ -663,9 +645,6 @@ export class ASVGF extends RenderStage {
 		this._heatmapMotionTexNode?.dispose();
 		this._heatmapGradientTexNode?.dispose();
 
-		// also removes the DOM node
-		this.heatmapHelper?.dispose();
-
 	}
 
 }

package/src/Stages/AdaptiveSampling.js

@@ -4,7 +4,6 @@ import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { NearestFilter, LinearFilter, RGBAFormat, HalfFloatType, FloatType } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
-import { createRenderTargetHelper } from '../Processor/createRenderTargetHelper.js';
 
 // ── wgslFn helpers ──────────────────────────────────────────
 
@@ -150,7 +149,6 @@ export class AdaptiveSampling extends RenderStage {
 		} );
 
 		this.renderer = renderer;
-		this.debugContainer = options.debugContainer || null;
 		this.frameNumber = 0;
 		this.delayByFrames = options.delayByFrames ?? 2;
 		this.showAdaptiveSamplingHelper = false;
@@ -191,7 +189,8 @@ export class AdaptiveSampling extends RenderStage {
 		this._heatmapStorageTex.minFilter = NearestFilter;
 		this._heatmapStorageTex.magFilter = NearestFilter;
 
-		// Heatmap render target — FloatType for clean CPU readback via createRenderTargetHelper
+		// Heatmap render target — FloatType, exposed as a public field for hosts to
+		// display via their own readback helper.
 		this.heatmapTarget = new RenderTarget( w, h, {
 			format: RGBAFormat,
 			type: FloatType,
@@ -214,18 +213,6 @@ export class AdaptiveSampling extends RenderStage {
 		this._buildCompute();
 		this._buildHeatmapCompute();
 
-		// Floating overlay for heatmap visualization
-		this.helper = createRenderTargetHelper( this.renderer, this.heatmapTarget, {
-			width: 400,
-			height: 400,
-			position: 'bottom-right',
-			theme: 'dark',
-			title: 'Adaptive Sampling',
-			autoUpdate: false
-		} );
-		this.helper.hide();
-		( this.debugContainer || document.body ).appendChild( this.helper );
-
 	}
 
 	setupEventListeners() {
@@ -303,8 +290,8 @@ export class AdaptiveSampling extends RenderStage {
 	 * Reads the sampling guidance StorageTexture via textureLoad and maps
 	 * normalizedSamples to a smooth blue→cyan→green→yellow→red gradient.
 	 * Converged pixels are desaturated, brightness is modulated by variance.
-	 * Writes to _heatmapStorageTex, then copied to heatmapTarget for
-	 * createRenderTargetHelper display.
+	 * Writes to _heatmapStorageTex, then copied to the public heatmapTarget
+	 * RenderTarget so the host can display it.
 	 */
 	_buildHeatmapCompute() {
 
@@ -343,13 +330,13 @@ export class AdaptiveSampling extends RenderStage {
 	}
 
 	/**
-	 * Toggle heatmap overlay visibility.
-	 * @param {boolean} val — show/hide
+	 * Enable or disable the heatmap compute pass. When enabled, the heatmap is
+	 * rendered each frame to {@link this.heatmapTarget} (a public RenderTarget)
+	 * for the host to display however it wants.
 	 */
-	toggleHelper( val ) {
+	setHeatmapEnabled( enabled ) {
 
-		this.showAdaptiveSamplingHelper = val;
-		val ? this.helper.show() : this.helper.hide();
+		this.showAdaptiveSamplingHelper = enabled;
 
 	}
 
@@ -387,12 +374,11 @@ export class AdaptiveSampling extends RenderStage {
 		// (StorageTexture extends Texture, works as regular texture for sampling)
 		context.setTexture( 'adaptiveSampling:output', this._outputStorageTex );
 
-		// Render heatmap + update helper overlay if visualization enabled
+		// Render heatmap into public heatmapTarget when enabled
 		if ( this.showAdaptiveSamplingHelper ) {
 
 			this.renderer.compute( this._heatmapComputeNode );
 			this.renderer.copyTextureToTexture( this._heatmapStorageTex, this.heatmapTarget.texture );
-			this.helper.update();
 
 		}
 
@@ -484,7 +470,6 @@ export class AdaptiveSampling extends RenderStage {
 		this._outputStorageTex?.dispose();
 		this.heatmapTarget?.dispose();
 		this._varianceTexNode?.dispose();
-		this.helper?.dispose();
 
 		this._computeNode = null;
 		this._heatmapComputeNode = null;
@@ -492,7 +477,6 @@ export class AdaptiveSampling extends RenderStage {
 		this._outputStorageTex = null;
 		this.heatmapTarget = null;
 		this._varianceTexNode = null;
-		this.helper = null;
 
 	}
 

package/src/Stages/PathTracer.js

@@ -25,10 +25,7 @@ import { LightSerializer } from '../Processor/LightSerializer';
 
 // Constants
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
-
-// STBN atlases - original source: https://github.com/NVIDIA-RTX/STBN/blob/main/Assets/STBN.zip
-const stbnScalarAtlas = 'https://assets.rayzee.atulmourya.com/noise/stbn_scalar_atlas.png';
-const stbnVec2Atlas = 'https://assets.rayzee.atulmourya.com/noise/stbn_vec2_atlas.png';
+import { getAssetConfig } from '../AssetConfig.js';
 
 /**
  * Data layout constants
@@ -50,7 +47,7 @@ const BVH_VEC4_PER_NODE = 4;
  * Events emitted:
  * - pathtracer:frameComplete - When a frame finishes rendering
  * - camera:moved - When camera position/orientation changes
- * - tile:changed - When current tile changes (for OverlayManager TileHelper)
+ * - tile:changed - When current tile changes (for OverlayManager TileHelper). @internal — payload carries internal tile coordinates and may change without notice.
  * - asvgf:reset - Request ASVGF to reset temporal data
  * - asvgf:updateParameters - Update ASVGF parameters
  * - asvgf:setTemporal - Enable/disable ASVGF temporal accumulation
@@ -397,6 +394,8 @@ export class PathTracer extends RenderStage {
 
 		};
 
+		const { stbnScalarAtlas, stbnVec2Atlas } = getAssetConfig();
+
 		loader.load( stbnScalarAtlas, ( tex ) => {
 
 			this.stbnScalarTexture = configure( tex );

package/src/TSL/BVHTraversal.js

@@ -117,27 +117,11 @@ const fastRayAABBDst = wgslFn( `
 	}
 ` );
 
-// ================================================================================
-// VISIBILITY FUNCTIONS
-// ================================================================================
-
-// Side culling — 1 buffer read (slot 10 only)
-// Per-mesh visibility handled at BLAS-pointer level; material visibility always 1.
-export const passesSideCulling = Fn( ( [ materialIndex, rayDirection, normal, materialBuffer ] ) => {
-
-	const sideData = getDatafromStorageBuffer( materialBuffer, materialIndex, int( MATERIAL_SLOT.OPACITY_ALPHA ), int( MATERIAL_SLOTS ) );
-	const side = int( sideData.g );
-	const rayDotNormal = rayDirection.dot( normal );
-	const doubleSide = side.equal( int( 2 ) );
-	const frontSide = side.equal( int( 0 ) ).and( rayDotNormal.lessThan( - 0.0001 ) );
-	const backSide = side.equal( int( 1 ) ).and( rayDotNormal.greaterThan( 0.0001 ) );
-	return doubleSide.or( frontSide ).or( backSide );
-
-} );
-
 // ================================================================================
 // MAIN BVH TRAVERSAL
 // ================================================================================
+// Side culling is performed inline inside traverseBVH/traverseBVHShadow using
+// the per-triangle side flag stored in normalCData.w (slot 5, .w channel).
 
 export const traverseBVH = Fn( ( [
 	ray,

package/src/TSL/Clearcoat.js

@@ -1,6 +1,5 @@
 // Clearcoat BRDF - Ported from clearcoat.fs
-// Note: evaluateLayeredBRDF and calculateLayerAttenuation functions
-// are in MaterialEvaluation.js
+// Note: evaluateLayeredBRDF lives in MaterialEvaluation.js
 
 import {
 	Fn,

package/src/TSL/Common.js

@@ -126,19 +126,6 @@ export const applyDithering = wgslFn( `
 	}
 ` );
 
-// Firefly clamping — exact port of GLSL
-export const reduceFireflies = wgslFn( `
-	fn reduceFireflies( color: vec3f, maxValue: f32 ) -> vec3f {
-
-		let lum = dot( color, vec3f( 0.2126, 0.7152, 0.0722 ) );
-		if ( lum > maxValue ) {
-			return color * ( maxValue / lum );
-		}
-		return color;
-
-	}
-` );
-
 // Construct tangent-bitangent-normal matrix — exact port of GLSL
 export const constructTBN = wgslFn( `
 	fn constructTBN( N: vec3f ) -> mat3x3f {

package/src/TSL/EmissiveSampling.js

@@ -260,22 +260,6 @@ export const isEmissive = Fn( ( [ material ] ) => {
 
 } );
 
-// Calculate emissive power of a triangle
-export const calculateEmissivePower = Fn( ( [ material, area ] ) => {
-
-	const result = float( 0.0 ).toVar();
-
-	If( isEmissive( material ), () => {
-
-		const avgEmissive = material.emissive.x.add( material.emissive.y ).add( material.emissive.z ).div( 3.0 );
-		result.assign( avgEmissive.mul( material.emissiveIntensity ).mul( area ) );
-
-	} );
-
-	return result;
-
-} );
-
 // ================================================================================
 // TRIANGLE DATA ACCESS
 // ================================================================================

package/src/TSL/Environment.js

@@ -28,13 +28,6 @@ export const equirectUvToDirection = /*@__PURE__*/ wgslFn( `
 	}
 ` );
 
-// Sample environment map color in a given direction
-export const sampleEquirectColor = Fn( ( [ environment, direction, environmentMatrix ] ) => {
-
-	return texture( environment, equirectDirectionToUv( { direction, environmentMatrix } ), 0 ).rgb;
-
-} );
-
 // Calculate PDF for uniform sphere sampling with Jacobian
 export const equirectDirectionPdf = /*@__PURE__*/ wgslFn( `
 	fn equirectDirectionPdf( direction: vec3f, environmentMatrix: mat4x4f ) -> f32 {