rayzee 7.30.2 → 7.31.1

package/src/PathTracerApp.js

@@ -404,6 +404,7 @@ export class PathTracerApp extends EventDispatcher {
 			if ( ! this.stages.pathTracer.isComplete ) {
 
 				this.completion.updateTime();
+				this.denoisingManager?.tickContinuousDenoise( this.stages.pathTracer.frameCount );
 
 			}
 
@@ -1096,7 +1097,14 @@ export class PathTracerApp extends EventDispatcher {
 			timer.start( 'Environment CDF build (worker)' );
 			this.stages.pathTracer.scene.environment = environmentTexture;
 			cdfPromise = this.stages.pathTracer.environment.buildEnvironmentCDF()
-				.then( () => timer.end( 'Environment CDF build (worker)' ) );
+				.then( () => {
+
+					timer.end( 'Environment CDF build (worker)' );
+					// A loader can install the environment itself and still author how it should
+					// be read — a pbrt scene bakes the light's transform in and needs rotation 0.
+					if ( this._applySceneMetadataEnabled ) this._applySceneMetadataSettings( environmentTexture );
+
+				} );
 
 		}
 
@@ -1797,8 +1805,11 @@ export class PathTracerApp extends EventDispatcher {
 		if ( denoiser ) {
 
 			denoiser.abort();
-			denoiser.enabled = config.enableOIDN;
-			denoiser.updateQuality( config.oidnQuality );
+			// Through the manager both times: `denoiser.enabled` is the union of its two jobs and
+			// `denoiser.quality` dips to a cheaper model between refreshes, so neither is the
+			// record of what the host asked for.
+			this.denoisingManager.applyOIDNEnabled( config.enableOIDN );
+			this.denoisingManager.applyOIDNQuality( config.oidnQuality );
 
 		}
 
@@ -1933,6 +1944,7 @@ export class PathTracerApp extends EventDispatcher {
 					dynamicDispatch: stage._useDynamicDispatch,
 					autoFocusMode: this.cameraManager?.autoFocusMode,
 					autoExposure: this.stages.autoExposure?.enabled,
+					continuousDenoise: this.denoisingManager?.continuousDenoise,
 				};
 
 			}
@@ -1966,6 +1978,8 @@ export class PathTracerApp extends EventDispatcher {
 
 			this.cameraManager?.setAutoFocusMode( 'manual' );
 			if ( this.stages.autoExposure ) this.stages.autoExposure.enabled = false;
+			// Cadence denoising is wall-clock driven, so which frame it lands on is not reproducible.
+			this.denoisingManager?.setContinuousDenoise( false );
 
 			// The seed axis free-runs across accumulation resets so a camera drag gets fresh
 			// sequences; offline rendering needs the opposite. Pinning it makes seedFrame track
@@ -1990,6 +2004,12 @@ export class PathTracerApp extends EventDispatcher {
 
 			}
 
+			if ( prev.continuousDenoise !== undefined ) {
+
+				this.denoisingManager?.setContinuousDenoise( prev.continuousDenoise );
+
+			}
+
 			stage._pinSeedToFrame = false;
 
 			this._deterministicRestore = null;

package/src/Processor/AssetLoader.js

@@ -14,9 +14,9 @@ import { unzipSync, zipSync, strFromU8 } from 'three/addons/libs/fflate.module.j
 import { disposeEngineOwnedResources, disposeObjectFromMemory, updateLoading } from './utils';
 import { BuildTimer } from './BuildTimer.js';
 import { getAssetConfig } from '../AssetConfig.js';
-import { loadPBRTScene, pickEntryPath } from './PBRT/index.js';
+import { loadPBRTScene, pickEntryPath, listEntryPaths } from './PBRT/index.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
-import { ISSUE_CODES } from '../EngineIssues.js';
+import { ISSUE_CODES, ISSUE_SEVERITY } from '../EngineIssues.js';
 import { getRenderProfile } from '../EngineDefaults.js';
 
 // Define supported file formats
@@ -39,6 +39,7 @@ const SUPPORTED_FORMATS = {
 // layers and the image assets they reference.
 const USD_LAYER_RE = /\.(usd|usda|usdc)$/i;
 const USD_IMAGE_RE = /\.(png|jpg|jpeg|avif)$/i;
+const MTL_TEXTURE_TIMEOUT_MS = 30000;
 // A throwaway stand-in for a geometry the engine must not mutate: the split's mergeGroups()
 // reorders and disposes what it is given, but never writes the attributes.
 function standInForSplit( source ) {
@@ -482,7 +483,13 @@ export class AssetLoader extends EventDispatcher {
 	}
 
 	// Archive handling
-	async loadArchiveFromFile( file, filename ) {
+	/**
+	 * @param {File|Blob} file
+	 * @param {string} filename
+	 * @param {{pbrtEntry?: string}} [options] - `pbrtEntry` names which .pbrt to load when the
+	 *   archive holds several independent scenes; the issue log lists what else was available.
+	 */
+	async loadArchiveFromFile( file, filename, { pbrtEntry = null } = {} ) {
 
 		try {
 
@@ -490,7 +497,7 @@ export class AssetLoader extends EventDispatcher {
 			const zip = unzipSync( new Uint8Array( arrayBuffer ) );
 
 			// A pbrt scene archive takes priority — it owns its own geometry/texture refs.
-			if ( pickEntryPath( zip ) ) return await this.loadPBRTFromZip( zip, filename );
+			if ( pickEntryPath( zip ) ) return await this.loadPBRTFromZip( zip, filename, pbrtEntry );
 
 			const result = await this.processObjMtlPairsInZip( zip, filename );
 			if ( result ) return result;
@@ -512,7 +519,7 @@ export class AssetLoader extends EventDispatcher {
 	 * @param {Object<string, Uint8Array>} zip - unzipped entries (path → bytes)
 	 * @param {string} filename - original archive name (for display/events)
 	 */
-	async loadPBRTFromZip( zip, filename ) {
+	async loadPBRTFromZip( zip, filename, entryPath = null ) {
 
 		updateLoading( { isLoading: true, status: 'Parsing PBRT scene...', progress: 5 } );
 
@@ -546,14 +553,34 @@ export class AssetLoader extends EventDispatcher {
 
 		};
 
-		const { group, environment, report, warnings, entryPath } = await loadPBRTScene( {
-			vfs: zip, plyParser, imageFromBytes, envFromBytes
+		const requested = entryPath && listEntryPaths( zip ).includes( entryPath ) ? entryPath : null;
+		if ( entryPath && ! requested ) console.warn( `PBRT entry "${entryPath}" is not a scene in this archive — auto-detecting instead` );
+
+		const { group, environment, report, warnings, entryPath: loadedEntry } = await loadPBRTScene( {
+			vfs: zip, entryPath: requested, plyParser, imageFromBytes, envFromBytes
 		} );
 
+		// An archive can hold several independent scenes (transparent-machines ships five
+		// animation frames). Only one is loaded, so name it and the alternatives rather
+		// than leave the user comparing against a reference of a different scene.
+		const candidates = listEntryPaths( zip );
+		if ( candidates.length > 1 ) {
+
+			const others = candidates.filter( p => p !== loadedEntry );
+			console.warn( `PBRT archive holds ${candidates.length} scenes; loaded "${loadedEntry}". Others: ${others.join( ', ' )}` );
+			this._issues?.record(
+				ISSUE_CODES.ASSET_AMBIGUOUS_ENTRY,
+				`archive holds ${candidates.length} pbrt scenes; loaded "${loadedEntry}"`,
+				{ loaded: loadedEntry, alternatives: others },
+				ISSUE_SEVERITY.WARNING
+			);
+
+		}
+
 		// Diagnostics — surface what each mesh resolved to (helps debug black/wrong materials).
 		if ( report && report.length && typeof console.table === 'function' ) {
 
-			console.groupCollapsed( `PBRT loader: ${report.length} mesh(es) from "${entryPath}"` );
+			console.groupCollapsed( `PBRT loader: ${report.length} mesh(es) from "${loadedEntry}"` );
 			console.table( report );
 			console.groupEnd();
 
@@ -561,7 +588,7 @@ export class AssetLoader extends EventDispatcher {
 
 		if ( warnings && warnings.length ) {
 
-			console.warn( `PBRT loader: ${warnings.length} warning(s) parsing "${entryPath}"` );
+			console.warn( `PBRT loader: ${warnings.length} warning(s) parsing "${loadedEntry}"` );
 			warnings.forEach( w => console.warn( '  •', w ) );
 
 		}
@@ -574,14 +601,19 @@ export class AssetLoader extends EventDispatcher {
 
 		}
 
-		group.name = entryPath || filename;
+		group.name = loadedEntry || filename;
 		this.releaseTargetModel();
 		this.targetModel = group;
 
+		// The light's own orientation and `scale` are already baked into the texture, so the
+		// scene is only correct at rotation 0 / intensity 1. Without this the viewer profile's
+		// default 270° rotation lands on top and the sky sits 90° from where pbrt puts it.
+		if ( environment?.texture ) this.sceneMetadata = { environment: { rotation: 0, intensity: 1 } };
+
 		updateLoading( { isLoading: true, status: 'Processing PBRT geometry...', progress: 10 } );
 		await this.onModelLoad( this.targetModel );
 
-		this.dispatchEvent( { type: 'load', model: group, filename: `${entryPath} (from ZIP)` } );
+		this.dispatchEvent( { type: 'load', model: group, filename: `${loadedEntry} (from ZIP)` } );
 		return group;
 
 	}
@@ -932,6 +964,56 @@ export class AssetLoader extends EventDispatcher {
 
 	}
 
+	// MTLLoader returns Texture objects whose `.image` only lands on a later tick, and
+	// SceneProcessor._bucketTextures drops any texture without one — so handing the model
+	// over before the maps decode renders the whole scene untextured. Replaces preload().
+	async preloadMtlTextures( materials ) {
+
+		const pending = [];
+		const loadTexture = materials.loadTexture.bind( materials );
+
+		materials.loadTexture = ( url, mapping, onLoad, onProgress, onError ) => {
+
+			let settle;
+			pending.push( new Promise( resolve => ( settle = resolve ) ) );
+			return loadTexture( url, mapping,
+				texture => {
+
+					settle();
+					onLoad?.( texture );
+
+				},
+				onProgress,
+				error => {
+
+					settle();
+					onError?.( error );
+
+				}
+			);
+
+		};
+
+		materials.preload();
+		if ( pending.length === 0 ) return materials;
+
+		let timer;
+		const decoded = await Promise.race( [
+			Promise.all( pending ).then( () => true ),
+			new Promise( resolve => ( timer = setTimeout( () => resolve( false ), MTL_TEXTURE_TIMEOUT_MS ) ) )
+		] );
+		clearTimeout( timer );
+
+		if ( ! decoded ) this._issues?.record(
+			ISSUE_CODES.TEXTURE_BUILD_FAILED,
+			`MTL textures did not decode within ${MTL_TEXTURE_TIMEOUT_MS}ms; affected materials render untextured`,
+			{ pending: pending.length }
+		);
+
+		return materials;
+
+	}
+
 	async loadMtlFromZip( mtlFilename, objPath, zipContents ) {
 
 		const objDir = objPath.split( '/' ).slice( 0, - 1 ).join( '/' );
@@ -951,7 +1033,7 @@ export class AssetLoader extends EventDispatcher {
 				manager.setURLModifier( url => this.resolveZipResource( url, objDir, zipContents ) );
 				const mtlLoader = new MTLLoader( manager );
 				const materials = mtlLoader.parse( mtlContent, objDir );
-				materials.preload();
+				await this.preloadMtlTextures( materials );
 				return materials;
 
 			}
@@ -999,7 +1081,7 @@ export class AssetLoader extends EventDispatcher {
 		manager.setURLModifier( url => this.resolveTextureInZip( url, objDir, mtlDir, mtlFile, zip, createdUrls ) );
 		const mtlContent = this.prepareFixedMtlContent( mtlFile );
 		const materials = new MTLLoader( manager ).parse( mtlContent, mtlDir );
-		materials.preload();
+		await this.preloadMtlTextures( materials );
 
 		const objLoader = new OBJLoader( manager );
 		objLoader.setMaterials( materials );
@@ -1712,6 +1794,17 @@ export class AssetLoader extends EventDispatcher {
 				object.getWorldPosition( camera.position );
 				object.getWorldQuaternion( camera.quaternion );
 
+				// Keep only the sign of the world scale. A camera has no meaningful
+				// size, but a negative axis is a mirror — a pbrt scene's `Scale -1 1 1`
+				// lives here — and dropping it silently un-flips the view. decompose()
+				// parks any mirror on x, so this lands as (±1, 1, 1).
+				object.getWorldScale( camera.scale );
+				camera.scale.set(
+					Math.sign( camera.scale.x ) || 1,
+					Math.sign( camera.scale.y ) || 1,
+					Math.sign( camera.scale.z ) || 1
+				);
+
 				// Set a meaningful name
 				if ( ! camera.name || camera.name === '' ) {
 

package/src/Processor/PBRT/EqualAreaOctahedral.js

@@ -0,0 +1,149 @@
+/**
+ * Equal-area octahedral environment maps, as pbrt-v4 stores them.
+ *
+ * `LightSource "infinite" "string filename"` does NOT take a lat-long panorama.
+ * pbrt-v4's ImageInfiniteLight reads a square image through EqualAreaSphereToSquare:
+ * the upper hemisphere fills a centre diamond and the lower hemisphere the four
+ * corner triangles (`imgtool makeequiarea` / `makesky` write this). Sampling one as
+ * equirectangular smears the black corners over the whole sphere and puts the sun
+ * in the wrong place — the scene goes dark.
+ *
+ * The engine's environment path (CDF build, importance sampling, background) is
+ * equirectangular throughout, so convert once at load rather than teach every
+ * consumer a second projection. The light's own transform folds into the same
+ * resample, which is also how the engine gets a rotation it cannot otherwise
+ * express (its environmentRotation is a single Y angle; pbrt lights carry a full
+ * matrix).
+ */
+
+import * as M from './PBRTMath.js';
+
+/**
+ * pbrt-v4 `EqualAreaSphereToSquare`: unit direction → [0,1]² in the octahedral map.
+ * Uses Math.atan where pbrt uses a polynomial approximation — this runs once on the
+ * CPU, so take the exact value.
+ */
+export function equalAreaSphereToSquare( dx, dy, dz ) {
+
+	const x = Math.abs( dx ), y = Math.abs( dy ), z = Math.abs( dz );
+	const r = Math.sqrt( Math.max( 0, 1 - z ) );
+
+	const a = Math.max( x, y );
+	const b = a === 0 ? 0 : Math.min( x, y ) / a;
+
+	let phi = Math.atan( b ) * ( 2 / Math.PI );
+	if ( x < y ) phi = 1 - phi;
+
+	let v = phi * r;
+	let u = r - v;
+
+	if ( dz < 0 ) {
+
+		const prevU = u;
+		u = 1 - v;
+		v = 1 - prevU;
+
+	}
+
+	if ( dx < 0 ) u = - u;
+	if ( dy < 0 ) v = - v;
+
+	return [ 0.5 * ( u + 1 ), 0.5 * ( v + 1 ) ];
+
+}
+
+/** Bilinear fetch from a tightly packed float image, clamped at the edges. */
+function sampleBilinear( data, width, height, channels, u, v, out ) {
+
+	const fx = Math.min( Math.max( u * width - 0.5, 0 ), width - 1 );
+	const fy = Math.min( Math.max( v * height - 0.5, 0 ), height - 1 );
+	const x0 = Math.floor( fx ), y0 = Math.floor( fy );
+	const x1 = Math.min( x0 + 1, width - 1 ), y1 = Math.min( y0 + 1, height - 1 );
+	const tx = fx - x0, ty = fy - y0;
+
+	const i00 = ( y0 * width + x0 ) * channels;
+	const i10 = ( y0 * width + x1 ) * channels;
+	const i01 = ( y1 * width + x0 ) * channels;
+	const i11 = ( y1 * width + x1 ) * channels;
+
+	for ( let c = 0; c < 3; c ++ ) {
+
+		const top = data[ i00 + c ] * ( 1 - tx ) + data[ i10 + c ] * tx;
+		const bottom = data[ i01 + c ] * ( 1 - tx ) + data[ i11 + c ] * tx;
+		out[ c ] = top * ( 1 - ty ) + bottom * ty;
+
+	}
+
+}
+
+/**
+ * Resample a square equal-area octahedral map into an equirectangular RGBA float image.
+ *
+ * The output uses the engine's own mapping (Environment.js): u = atan2(z,x)/2pi + 0.5,
+ * v = 1 - acos(y)/pi, with row 0 at v = 1 so "up" lands at the top like any other HDRI.
+ *
+ * @param {{data: ArrayLike<number>, width: number, height: number, channels: number,
+ *   bottomUp?: boolean}} src - `bottomUp` when row 0 holds the BOTTOM of the image, which is
+ *   what three's EXR/HDR loaders produce; pbrt indexes the square top-down, and reading it
+ *   the wrong way round turns out to rotate the sky 180° about the light's z axis.
+ * @param {number[]} lightToWorld - the light's pbrt CTM (column-major 16), or null
+ * @param {number} scale - the light's `scale` parameter, baked into the output
+ * @param {number} [outWidth] - defaults to the source width, capped at 4096
+ * @returns {{data: Float32Array, width: number, height: number}}
+ */
+export function octahedralToEquirect( src, lightToWorld, scale = 1, outWidth = 0 ) {
+
+	const width = outWidth || Math.min( src.width, 4096 );
+	const height = Math.max( 1, width >> 1 );
+	const out = new Float32Array( width * height * 4 );
+
+	// Directions go world → light, the opposite of the CTM, matching pbrt's
+	// renderFromLight.ApplyInverse(ray.d) before the square lookup.
+	const worldToLight = lightToWorld ? M.invert( lightToWorld ) : null;
+	const rgb = [ 0, 0, 0 ];
+
+	for ( let j = 0; j < height; j ++ ) {
+
+		// Row index IS the v axis the engine samples on, so row 0 is v = 0 (straight down)
+		// and the last row is v = 1 (up). Verified against a rendered frame — inverting
+		// this turns the sky upside down with no other visible symptom.
+		const v = ( j + 0.5 ) / height;
+		const polar = ( 1 - v ) * Math.PI;
+		const sinPolar = Math.sin( polar ), cosPolar = Math.cos( polar );
+
+		for ( let i = 0; i < width; i ++ ) {
+
+			const u = ( i + 0.5 ) / width;
+			const azimuth = ( u - 0.5 ) * 2 * Math.PI;
+
+			let dx = sinPolar * Math.cos( azimuth );
+			let dy = cosPolar;
+			let dz = sinPolar * Math.sin( azimuth );
+
+			if ( worldToLight ) {
+
+				const m = worldToLight;
+				const tx = m[ 0 ] * dx + m[ 4 ] * dy + m[ 8 ] * dz;
+				const ty = m[ 1 ] * dx + m[ 5 ] * dy + m[ 9 ] * dz;
+				const tz = m[ 2 ] * dx + m[ 6 ] * dy + m[ 10 ] * dz;
+				const len = Math.hypot( tx, ty, tz ) || 1;
+				dx = tx / len; dy = ty / len; dz = tz / len;
+
+			}
+
+			const [ su, sv ] = equalAreaSphereToSquare( dx, dy, dz );
+			sampleBilinear( src.data, src.width, src.height, src.channels, su, src.bottomUp ? 1 - sv : sv, rgb );
+
+			const o = ( j * width + i ) * 4;
+			out[ o ] = rgb[ 0 ] * scale;
+			out[ o + 1 ] = rgb[ 1 ] * scale;
+			out[ o + 2 ] = rgb[ 2 ] * scale;
+			out[ o + 3 ] = 1;
+
+		}
+
+	}
+
+	return { data: out, width, height };
+
+}

package/src/Processor/PBRT/LoopSubdivision.js

@@ -0,0 +1,240 @@
+/**
+ * Loop subdivision for pbrt's `loopsubdiv` shape.
+ *
+ * Mirrors pbrt-v4's loopsubdiv.cpp: Warren's simplified beta for the even-vertex
+ * one-ring rule, 1/8 for the boundary rule, 3/8–1/8 for interior edge points, and a
+ * final push onto the limit surface. Scenes use this shape for exactly the objects
+ * that read wrong as a coarse cage — a tub, a cushion, a curtain — so approximating
+ * it by its control mesh is visibly not the same model.
+ *
+ * Topology is rebuilt per level from the index buffer alone; no half-edge structure,
+ * since the meshes involved are control cages (thousands of faces, not millions).
+ */
+
+/** pbrt: Beta(valence) — the one-ring weight for an interior even vertex. */
+function beta( valence ) {
+
+	return valence === 3 ? 3 / 16 : 3 / ( 8 * valence );
+
+}
+
+/** pbrt: LoopGamma(valence) — the one-ring weight for the limit-surface push. */
+function loopGamma( valence ) {
+
+	return 1 / ( valence + 3 / ( 8 * beta( valence ) ) );
+
+}
+
+/**
+ * Edge records plus per-vertex neighbour rings.
+ *
+ * A vertex is on the boundary when it touches an edge with a single adjacent face;
+ * `boundaryRing` keeps only those neighbours, because the boundary rule weights the
+ * two vertices along the boundary curve, not the whole ring.
+ */
+function buildTopology( nv, indices ) {
+
+	const edgeIndex = new Map();
+	const edgeV0 = [], edgeV1 = [], edgeOpp0 = [], edgeOpp1 = [], edgeFaces = [];
+	const faceCount = indices.length / 3;
+
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		for ( let e = 0; e < 3; e ++ ) {
+
+			const a = indices[ f * 3 + e ];
+			const b = indices[ f * 3 + ( e + 1 ) % 3 ];
+			const opposite = indices[ f * 3 + ( e + 2 ) % 3 ];
+			const lo = a < b ? a : b;
+			const hi = a < b ? b : a;
+			const key = lo * nv + hi;
+
+			const existing = edgeIndex.get( key );
+			if ( existing === undefined ) {
+
+				edgeIndex.set( key, edgeV0.length );
+				edgeV0.push( lo );
+				edgeV1.push( hi );
+				edgeOpp0.push( opposite );
+				edgeOpp1.push( - 1 );
+				edgeFaces.push( 1 );
+
+			} else {
+
+				if ( edgeOpp1[ existing ] < 0 ) edgeOpp1[ existing ] = opposite;
+				edgeFaces[ existing ] ++;
+
+			}
+
+		}
+
+	}
+
+	const ring = Array.from( { length: nv }, () => [] );
+	const boundaryRing = Array.from( { length: nv }, () => [] );
+
+	for ( let i = 0; i < edgeV0.length; i ++ ) {
+
+		const v0 = edgeV0[ i ], v1 = edgeV1[ i ];
+		ring[ v0 ].push( v1 );
+		ring[ v1 ].push( v0 );
+
+		if ( edgeFaces[ i ] === 1 ) {
+
+			boundaryRing[ v0 ].push( v1 );
+			boundaryRing[ v1 ].push( v0 );
+
+		}
+
+	}
+
+	return { edgeIndex, edgeV0, edgeV1, edgeOpp0, edgeOpp1, edgeFaces, ring, boundaryRing };
+
+}
+
+/**
+ * Reposition every vertex by a one-ring weighting: (1 - n·w)·v + w·Σring for an
+ * interior vertex, (1 - 2w)·v + w·(both boundary neighbours) on a boundary. Used for
+ * both the even-vertex step and the limit push, which differ only in the weights.
+ */
+function weightVertices( P, topology, nv, interiorWeight, boundaryWeight ) {
+
+	const out = new Float64Array( P.length );
+
+	for ( let v = 0; v < nv; v ++ ) {
+
+		const base = v * 3;
+		const boundary = topology.boundaryRing[ v ];
+
+		// Anything other than a clean two-neighbour boundary (a wire edge, a
+		// non-manifold fan) has no defined rule — leave the vertex where it is.
+		if ( boundary.length === 2 ) {
+
+			const a = boundary[ 0 ] * 3, b = boundary[ 1 ] * 3;
+			const centre = 1 - 2 * boundaryWeight;
+			for ( let k = 0; k < 3; k ++ ) {
+
+				out[ base + k ] = centre * P[ base + k ] + boundaryWeight * ( P[ a + k ] + P[ b + k ] );
+
+			}
+
+			continue;
+
+		}
+
+		const ring = topology.ring[ v ];
+		const n = ring.length;
+		if ( n === 0 || boundary.length > 0 ) {
+
+			for ( let k = 0; k < 3; k ++ ) out[ base + k ] = P[ base + k ];
+			continue;
+
+		}
+
+		const w = interiorWeight( n );
+		let sx = 0, sy = 0, sz = 0;
+		for ( let i = 0; i < n; i ++ ) {
+
+			const r = ring[ i ] * 3;
+			sx += P[ r ];
+			sy += P[ r + 1 ];
+			sz += P[ r + 2 ];
+
+		}
+
+		const centre = 1 - n * w;
+		out[ base ] = centre * P[ base ] + w * sx;
+		out[ base + 1 ] = centre * P[ base + 1 ] + w * sy;
+		out[ base + 2 ] = centre * P[ base + 2 ] + w * sz;
+
+	}
+
+	return out;
+
+}
+
+/** One subdivision step: 4 faces per face, one new vertex per edge. */
+function subdivideOnce( P, indices ) {
+
+	const nv = P.length / 3;
+	const topology = buildTopology( nv, indices );
+	const edgeCount = topology.edgeV0.length;
+
+	const even = weightVertices( P, topology, nv, beta, 1 / 8 );
+	const out = new Float64Array( ( nv + edgeCount ) * 3 );
+	out.set( even );
+
+	for ( let i = 0; i < edgeCount; i ++ ) {
+
+		const v0 = topology.edgeV0[ i ] * 3;
+		const v1 = topology.edgeV1[ i ] * 3;
+		const dst = ( nv + i ) * 3;
+		const opp1 = topology.edgeOpp1[ i ];
+
+		if ( opp1 < 0 ) {
+
+			for ( let k = 0; k < 3; k ++ ) out[ dst + k ] = 0.5 * ( P[ v0 + k ] + P[ v1 + k ] );
+
+		} else {
+
+			const o0 = topology.edgeOpp0[ i ] * 3, o1 = opp1 * 3;
+			for ( let k = 0; k < 3; k ++ ) {
+
+				out[ dst + k ] = 0.375 * ( P[ v0 + k ] + P[ v1 + k ] ) + 0.125 * ( P[ o0 + k ] + P[ o1 + k ] );
+
+			}
+
+		}
+
+	}
+
+	const faceCount = indices.length / 3;
+	const outIndices = new Int32Array( faceCount * 12 );
+	const midpoint = ( a, b ) => nv + topology.edgeIndex.get( ( a < b ? a : b ) * nv + ( a < b ? b : a ) );
+
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const a = indices[ f * 3 ], b = indices[ f * 3 + 1 ], c = indices[ f * 3 + 2 ];
+		const ab = midpoint( a, b ), bc = midpoint( b, c ), ca = midpoint( c, a );
+		const o = f * 12;
+
+		outIndices[ o ] = a; outIndices[ o + 1 ] = ab; outIndices[ o + 2 ] = ca;
+		outIndices[ o + 3 ] = ab; outIndices[ o + 4 ] = b; outIndices[ o + 5 ] = bc;
+		outIndices[ o + 6 ] = ca; outIndices[ o + 7 ] = bc; outIndices[ o + 8 ] = c;
+		outIndices[ o + 9 ] = ab; outIndices[ o + 10 ] = bc; outIndices[ o + 11 ] = ca;
+
+	}
+
+	return { positions: out, indices: outIndices };
+
+}
+
+/**
+ * @param {ArrayLike<number>} P - control-cage positions, 3 per vertex
+ * @param {ArrayLike<number>} indices - control-cage triangles, 3 per face
+ * @param {number} levels - refinement steps; each multiplies face count by 4
+ * @param {number} [maxTriangles=2000000] - stop refining early rather than exhaust memory
+ * @returns {{positions: Float32Array, indices: Uint32Array, levels: number}} levels actually applied
+ */
+export function loopSubdivide( P, indices, levels, maxTriangles = 2000000 ) {
+
+	let positions = Float64Array.from( P );
+	let faces = Int32Array.from( indices );
+	let applied = 0;
+
+	for ( let i = 0; i < levels; i ++ ) {
+
+		if ( faces.length / 3 * 4 > maxTriangles ) break;
+		const step = subdivideOnce( positions, faces );
+		positions = step.positions;
+		faces = step.indices;
+		applied ++;
+
+	}
+
+	const nv = positions.length / 3;
+	const limit = weightVertices( positions, buildTopology( nv, faces ), nv, loopGamma, 1 / 5 );
+
+	return { positions: Float32Array.from( limit ), indices: Uint32Array.from( faces ), levels: applied };
+
+}

package/src/Processor/PBRT/PBRTMath.js

@@ -17,6 +17,15 @@ export function identity() {
 
 }
 
+/** Determinant of the upper-left 3x3 basis. Negative means the transform mirrors. */
+export function determinant3( m ) {
+
+	return m[ 0 ] * ( m[ 5 ] * m[ 10 ] - m[ 6 ] * m[ 9 ] )
+		- m[ 4 ] * ( m[ 1 ] * m[ 10 ] - m[ 2 ] * m[ 9 ] )
+		+ m[ 8 ] * ( m[ 1 ] * m[ 6 ] - m[ 2 ] * m[ 5 ] );
+
+}
+
 /** Matrix product a*b (applies b first, then a, to a column vector). */
 export function multiply( a, b ) {