rayzee 6.5.0 → 7.1.0

package/src/Processor/VRAMTracker.js

@@ -0,0 +1,169 @@
+/**
+ * VRAMTracker.js — current/peak GPU memory accounting.
+ *
+ * Measures ACTUAL live bytes (attribute.array.byteLength, texture dims × format/type)
+ * rather than re-deriving allocation formulas, so it never drifts when strides,
+ * capacity rounding, or layouts change. Providers are thunks that read current state,
+ * so they survive reallocation (resize, scene/material/env reload). A per-pass WeakSet
+ * dedupes by resource identity, so overlapping registrations never double-count.
+ */
+
+import {
+	RGBAFormat, RGBFormat, RGFormat, RedFormat,
+	FloatType, HalfFloatType, UnsignedByteType, ByteType,
+	UnsignedShortType, ShortType, UnsignedIntType, IntType,
+} from 'three';
+
+const CHANNELS = { [ RGBAFormat ]: 4, [ RGBFormat ]: 3, [ RGFormat ]: 2, [ RedFormat ]: 1 };
+const TYPE_BYTES = {
+	[ FloatType ]: 4, [ HalfFloatType ]: 2,
+	[ UnsignedByteType ]: 1, [ ByteType ]: 1,
+	[ UnsignedShortType ]: 2, [ ShortType ]: 2,
+	[ UnsignedIntType ]: 4, [ IntType ]: 4,
+};
+
+function texelBytes( tex ) {
+
+	return ( CHANNELS[ tex.format ] ?? 4 ) * ( TYPE_BYTES[ tex.type ] ?? 4 );
+
+}
+
+/** Exact byte size of a storage/buffer attribute's backing typed array. */
+export function bufferBytes( attr ) {
+
+	return attr?.array?.byteLength || 0;
+
+}
+
+/** Estimated GPU byte size of a Texture/StorageTexture/DataArrayTexture/RenderTarget. */
+export function textureBytes( tex ) {
+
+	if ( ! tex ) return 0;
+
+	if ( tex.isRenderTarget ) {
+
+		const list = tex.textures?.length ? tex.textures : [ tex.texture ];
+		const w = tex.width || 0, h = tex.height || 0, d = tex.depth || 1;
+		let sum = 0;
+		for ( const t of list ) if ( t ) sum += w * h * d * texelBytes( t );
+		return sum;
+
+	}
+
+	const img = tex.image || {};
+	const w = img.width ?? tex.width ?? 0;
+	const h = img.height ?? tex.height ?? 0;
+	const d = img.depth ?? 1;
+	return w * h * d * texelBytes( tex );
+
+}
+
+export class VRAMTracker {
+
+	constructor() {
+
+		this._providers = [];
+		this.current = 0;
+		this.peak = 0;
+		this.byCategory = {};
+
+	}
+
+	/**
+	 * @param {string} category - grouping label in the report
+	 * @param {Function} fn - returns a resource or array of resources: buffer
+	 *   attributes (`.array`), textures/render targets (`.isTexture`/`.isRenderTarget`),
+	 *   or synthetic `{ bytes }` for sizes with no inspectable object. Return falsy to skip.
+	 */
+	register( category, fn ) {
+
+		this._providers.push( { category, fn } );
+
+	}
+
+	measure() {
+
+		const seen = new WeakSet();
+		const byCategory = {};
+		let total = 0;
+
+		for ( const { category, fn } of this._providers ) {
+
+			let resources;
+			try {
+
+				resources = fn();
+
+			} catch {
+
+				resources = null;
+
+			}
+
+			if ( ! resources ) continue;
+
+			let bytes = 0;
+			for ( const r of ( Array.isArray( resources ) ? resources : [ resources ] ) ) {
+
+				bytes += this._resourceBytes( r, seen );
+
+			}
+
+			byCategory[ category ] = ( byCategory[ category ] || 0 ) + bytes;
+			total += bytes;
+
+		}
+
+		this.byCategory = byCategory;
+		this.current = total;
+		if ( total > this.peak ) this.peak = total;
+
+		return { current: total, peak: this.peak, byCategory };
+
+	}
+
+	_resourceBytes( r, seen ) {
+
+		if ( ! r ) return 0;
+
+		// synthetic { bytes } (e.g. attributeArray-backed histograms)
+		if ( typeof r.bytes === 'number' && ! r.isTexture && ! r.isRenderTarget ) return r.bytes;
+
+		// buffer attribute — dedupe by backing array (rw/ro nodes share one buffer)
+		if ( r.array && r.array.byteLength != null ) {
+
+			if ( seen.has( r.array ) ) return 0;
+			seen.add( r.array );
+			return r.array.byteLength;
+
+		}
+
+		// texture / render target — dedupe by object identity
+		if ( r.isRenderTarget || r.isTexture ) {
+
+			if ( seen.has( r ) ) return 0;
+			seen.add( r );
+			return textureBytes( r );
+
+		}
+
+		return 0;
+
+	}
+
+	/** Drop the high-water mark to the current value (call when a new render begins). */
+	resetPeak() {
+
+		this.peak = this.current;
+
+	}
+
+	getReport() {
+
+		const mb = ( b ) => ( b / 1048576 ).toFixed( 1 );
+		const parts = Object.entries( this.byCategory ).map( ( [ k, v ] ) => `${k}=${mb( v )}` );
+		return `VRAM current=${mb( this.current )}MB peak=${mb( this.peak )}MB [${parts.join( ' ' )}]`;
+
+	}
+
+}

package/src/Processor/utils.js

@@ -27,21 +27,10 @@ export const updateStats = ( statsUpdate ) => {
 
 };
 
-/**
- * Convert raw frameCount to user-facing sample count.
- * In tiled mode, one "sample pass" spans all tiles.
- */
+// Raw frameCount is the user-facing sample count (one full-frame pass per frame).
 export function getDisplaySamples( pathTracerStage ) {
 
-	const frameCount = pathTracerStage.frameCount || 0;
-	if ( pathTracerStage.renderMode?.value === 1 && frameCount > 0 ) {
-
-		const totalTiles = pathTracerStage.tileManager?.totalTilesCache || 1;
-		return 1 + Math.floor( ( frameCount - 1 ) / totalTiles );
-
-	}
-
-	return frameCount;
+	return pathTracerStage.frameCount || 0;
 
 }
 
@@ -214,9 +203,9 @@ export function generateMaterialSpheres( rows = 5, columns = 5, spacing = 1.2 )
 
 // ── Path Tracer Utilities (formerly PathTracerUtils static class) ──
 
-export function updateCompletionThreshold( renderMode, maxFrames, totalTiles ) {
+export function updateCompletionThreshold( renderMode, maxFrames ) {
 
-	return renderMode === 1 ? totalTiles * maxFrames : maxFrames;
+	return maxFrames;
 
 }
 
@@ -335,33 +324,10 @@ export function areValuesEqual( a, b ) {
 
 }
 
-export function calculateAccumulationAlpha( frameValue, renderMode, totalTiles, isInteractionMode = false ) {
-
-	if ( isInteractionMode ) {
-
-		return 1.0;
-
-	}
-
-	if ( renderMode === 0 ) {
-
-		return 1.0 / ( frameValue + 1 );
-
-	} else {
-
-		if ( frameValue === 0 ) {
-
-			return 1.0;
-
-		} else {
-
-			const completedTileCycles = Math.floor( ( frameValue - 1 ) / totalTiles );
-			const totalSamples = 1 + completedTileCycles;
-			return 1.0 / ( totalSamples + 1 );
+export function calculateAccumulationAlpha( frameValue, isInteractionMode = false ) {
 
-		}
-
-	}
+	// Full-frame progressive accumulation: each frame is one complete pass.
+	return isInteractionMode ? 1.0 : 1.0 / ( frameValue + 1 );
 
 }
 
@@ -416,12 +382,6 @@ export function optimizeShaderDefines( defines, state ) {
 
 	const optimized = { ...defines };
 
-	if ( ! state.useAdaptiveSampling ) {
-
-		delete optimized.ENABLE_ADAPTIVE_SAMPLING;
-
-	}
-
 	if ( ! state.enableAccumulation ) {
 
 		delete optimized.ENABLE_ACCUMULATION;
@@ -438,49 +398,6 @@ export function optimizeShaderDefines( defines, state ) {
 
 }
 
-export function calculateSpiralOrder( tiles, center = null ) {
-
-	const totalTiles = tiles * tiles;
-	const centerPoint = center || new Vector2( ( tiles - 1 ) / 2, ( tiles - 1 ) / 2 );
-	const tilePositions = [];
-
-	for ( let i = 0; i < totalTiles; i ++ ) {
-
-		const x = i % tiles;
-		const y = Math.floor( i / tiles );
-		const distance = Math.sqrt(
-			Math.pow( x - centerPoint.x, 2 ) +
-			Math.pow( y - centerPoint.y, 2 )
-		);
-		const angle = Math.atan( y - centerPoint.y, x - centerPoint.x );
-
-		tilePositions.push( {
-			index: i,
-			x,
-			y,
-			distance,
-			angle
-		} );
-
-	}
-
-	tilePositions.sort( ( a, b ) => {
-
-		const distanceDiff = a.distance - b.distance;
-		if ( Math.abs( distanceDiff ) < 0.01 ) {
-
-			return a.angle - b.angle;
-
-		}
-
-		return distanceDiff;
-
-	} );
-
-	return tilePositions.map( pos => pos.index );
-
-}
-
 export function clamp( value, min, max ) {
 
 	return Math.min( Math.max( value, min ), max );
@@ -493,31 +410,15 @@ export function lerp( a, b, t ) {
 
 }
 
-export function isRenderComplete( frameValue, renderMode, maxFrames, totalTiles ) {
-
-	if ( renderMode === 0 ) {
-
-		return frameValue >= maxFrames;
-
-	} else {
-
-		return frameValue >= maxFrames * totalTiles;
+export function isRenderComplete( frameValue, renderMode, maxFrames ) {
 
-	}
+	return frameValue >= maxFrames;
 
 }
 
-export function getCurrentSampleCount( frameValue, renderMode, totalTiles ) {
-
-	if ( renderMode === 0 ) {
+export function getCurrentSampleCount( frameValue ) {
 
-		return frameValue;
-
-	} else {
-
-		return Math.floor( frameValue / totalTiles );
-
-	}
+	return frameValue;
 
 }
 

package/src/RenderSettings.js

@@ -40,8 +40,6 @@ const SETTING_ROUTES = {
 	emissiveBoost: { uniform: 'emissiveBoost', reset: true },
 	visMode: { uniform: 'visMode', reset: true },
 	debugVisScale: { uniform: 'debugVisScale', reset: true },
-	useAdaptiveSampling: { uniform: 'useAdaptiveSampling', reset: true },
-	adaptiveSamplingMax: { uniform: 'adaptiveSamplingMax', reset: true },
 
 	// ── Multi-stage / special handling ────────────────────────────
 
@@ -63,7 +61,6 @@ const SETTING_ROUTES = {
  */
 const DEFAULTS_KEY_MAP = {
 	bounces: 'maxBounces',
-	adaptiveSampling: 'useAdaptiveSampling',
 	debugMode: 'visMode',
 };