rayzee 7.30.2 → 7.31.1

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -15,10 +15,12 @@
 
 import {
 	Group, Mesh, PerspectiveCamera, Matrix4, Vector3,
-	BufferGeometry, Float32BufferAttribute, SphereGeometry,
+	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute, SphereGeometry,
 	DataTexture, FloatType, RGBAFormat, LinearFilter, EquirectangularReflectionMapping
 } from 'three';
 import { buildMaterial, pFloat, pString, resolveSpectrum } from './PBRTMaterials.js';
+import { loopSubdivide } from './LoopSubdivision.js';
+import { octahedralToEquirect } from './EqualAreaOctahedral.js';
 import * as M from './PBRTMath.js';
 
 const FLIP_Z = [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, - 1, 0, 0, 0, 0, 1 ];
@@ -187,6 +189,7 @@ export class PBRTSceneBuilder {
 
 			case 'trianglemesh': return this._triangleMesh( shape.params );
 			case 'bilinearmesh': return this._bilinearMesh( shape.params );
+			case 'loopsubdiv': return this._loopSubdiv( shape.params );
 			case 'plymesh': return this._plyMesh( shape.params );
 			case 'sphere': return this._sphere( shape.params );
 			case 'disk': return this._disk( shape.params );
@@ -224,6 +227,33 @@ export class PBRTSceneBuilder {
 
 	}
 
+	_loopSubdiv( params ) {
+
+		const P = params.P?.value;
+		const indices = params.indices?.value;
+		if ( ! P || P.length < 9 || ! indices || indices.length < 3 ) {
+
+			this.warn( 'loopsubdiv missing P/indices' ); return null;
+
+		}
+
+		// pbrt's default is 3; each level quadruples the face count, so a deep level on
+		// a dense cage is worth refusing rather than stalling the import.
+		const requested = Math.max( 0, Math.min( 6, Math.round( pFloat( params, 'levels', 3 ) ) ) );
+		const { positions, indices: faces, levels } = loopSubdivide( P, indices, requested );
+
+		if ( levels < requested ) this.warn(
+			`loopsubdiv refined ${levels}/${requested} levels — the control mesh is too dense for the triangle budget`
+		);
+
+		const geo = new BufferGeometry();
+		geo.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+		geo.setIndex( new Uint32BufferAttribute( faces, 1 ) );
+		geo.computeVertexNormals();
+		return geo;
+
+	}
+
 	// Bilinear patch mesh → triangulate each quad (P + indices in quads of 4).
 	_bilinearMesh( params ) {
 
@@ -487,6 +517,16 @@ export class PBRTSceneBuilder {
 		camera.up.copy( up.normalize() );
 		camera.position.copy( eye );
 		camera.lookAt( target );
+
+		// pbrt's camera space is left-handed: image-right is cameraToWorld's first column,
+		// = cross(up, dir). three's lookAt() builds cross(up, -dir) — the opposite — so a
+		// plain pbrt scene imports left-right flipped against pbrt's own render. An
+		// exported scene's `Scale -1 1 1` already negates that column (det < 0), and then
+		// lookAt() happens to agree and no correction is wanted. Hence: mirror exactly when
+		// the scene does NOT. Verified against the reference images for contemporary-bathroom
+		// (has the Scale) and killeroos/killeroo-simple (does not).
+		if ( ( M.determinant3( cam.cameraToWorld ) > 0 ) !== this.convertHandedness ) camera.scale.x = - 1;
+
 		camera.updateMatrixWorld( true );
 		return camera;
 
@@ -506,6 +546,44 @@ export class PBRTSceneBuilder {
 
 	// ── lights / environment ───────────────────────────────────────
 
+	/**
+	 * A square infinite-light image is pbrt's equal-area octahedral layout, not a
+	 * lat-long panorama — resample it, folding in the light's transform and `scale`.
+	 * Returns null when the image is not square (nothing to convert) or its pixels are
+	 * not readable, leaving the caller's equirectangular path in place.
+	 */
+	_equirectFromInfiniteLight( tex, inf, scale, filename ) {
+
+		const image = tex.image;
+		const data = image?.data;
+		if ( ! data || ! image.width || image.width !== image.height ) {
+
+			if ( image?.width !== image?.height ) this.warn(
+				`infinite-light image "${filename}" is ${image?.width}x${image?.height}, not square — ` +
+				'read as equirectangular, but pbrt would read it as equal-area octahedral'
+			);
+			return null;
+
+		}
+
+		const channels = data.length / ( image.width * image.height );
+		if ( ! Number.isInteger( channels ) || channels < 3 ) return null;
+
+		// three's EXR/HDR loaders fill DataTexture rows bottom-up; pbrt reads the square top-down.
+		const { data: pixels, width, height } = octahedralToEquirect(
+			{ data, width: image.width, height: image.height, channels, bottomUp: true },
+			inf.ctm, scale
+		);
+
+		const out = new DataTexture( pixels, width, height, RGBAFormat, FloatType );
+		out.mapping = EquirectangularReflectionMapping;
+		out.minFilter = LinearFilter;
+		out.magFilter = LinearFilter;
+		out.needsUpdate = true;
+		return out;
+
+	}
+
 	async _buildEnvironment( lights ) {
 
 		const inf = lights.find( l => l.type === 'infinite' );
@@ -521,6 +599,9 @@ export class PBRTSceneBuilder {
 				const tex = await this.resolveEnvironment( filename );
 				if ( tex ) {
 
+					const converted = this._equirectFromInfiniteLight( tex, inf, scale, filename );
+					if ( converted ) return { texture: converted };
+
 					tex.mapping = EquirectangularReflectionMapping;
 					return { texture: tex };
 

package/src/Processor/PBRT/index.js

@@ -91,24 +91,78 @@ class VirtualFS {
 
 }
 
-/** Pick the top-level .pbrt entry: shallowest path, preferring scene/main names. */
-export function pickEntryPath( entries ) {
+/** Decoded text of a zip entry, or '' when the value is not decodable bytes. */
+function entryText( bytes ) {
+
+	try {
+
+		return decoder.decode( bytes );
+
+	} catch {
+
+		return '';
+
+	}
+
+}
+
+/**
+ * Rank every .pbrt in the archive that could be a top-level scene, best first.
+ *
+ * Name shape alone is not enough: a scene's `geometry.pbrt` fragment carries a shorter
+ * name than the real entry and would win on sort, loading every shape with an unresolved
+ * NamedMaterial and no camera or lights. Content decides first — a fragment has no
+ * `WorldBegin` and is named by someone else's Include — and the name only breaks ties.
+ *
+ * More than one survivor is a real archive shape, not an error: transparent-machines
+ * ships five independent frames side by side. Callers should say which one they took.
+ */
+export function listEntryPaths( entries ) {
 
 	const pbrts = Object.keys( entries ).filter( k => k.toLowerCase().endsWith( '.pbrt' ) );
-	if ( pbrts.length === 0 ) return null;
+	if ( pbrts.length <= 1 ) return pbrts;
+
+	const texts = new Map( pbrts.map( k => [ k, entryText( entries[ k ] ) ] ) );
 
-	const preferred = pbrts.filter( k => /(^|\/)(scene|main)\.pbrt$/i.test( k ) );
-	const pool = preferred.length ? preferred : pbrts;
+	const included = new Set();
+	for ( const text of texts.values() ) {
 
-	// Shallowest (fewest path segments), then shortest name.
-	pool.sort( ( a, b ) => {
+		for ( const m of text.matchAll( /^[ \t]*(?:Include|Import)[ \t]+"([^"]+)"/gm ) ) {
+
+			included.add( normalizePath( m[ 1 ] ).toLowerCase().split( '/' ).pop() );
+
+		}
+
+	}
+
+	const narrow = ( candidates, keep ) => {
+
+		const kept = candidates.filter( keep );
+		return kept.length ? kept : candidates;
+
+	};
+
+	let pool = narrow( pbrts, k => /^[ \t]*WorldBegin\b/m.test( texts.get( k ) ) );
+	pool = narrow( pool, k => ! included.has( k.toLowerCase().split( '/' ).pop() ) );
+	pool = narrow( pool, k => /(^|\/)(scene|main)\.pbrt$/i.test( k ) );
+
+	// Shallowest, then shortest name, then the path itself — the last key keeps the
+	// order independent of however the zip happened to enumerate its entries.
+	return pool.sort( ( a, b ) => {
 
 		const da = a.split( '/' ).length, db = b.split( '/' ).length;
-		return da !== db ? da - db : a.length - b.length;
+		if ( da !== db ) return da - db;
+		if ( a.length !== b.length ) return a.length - b.length;
+		return a < b ? - 1 : a > b ? 1 : 0;
 
 	} );
 
-	return pool[ 0 ];
+}
+
+/** Best top-level .pbrt entry, or null when the archive has none. */
+export function pickEntryPath( entries ) {
+
+	return listEntryPaths( entries )[ 0 ] || null;
 
 }
 

package/src/Processor/SceneProcessor.js

@@ -931,11 +931,27 @@ export class SceneProcessor {
 		this._linearTexPacked = new Map();
 
 		let bucketOverflowReported = false;
+		let undecodedReported = false;
 
 		// Assign one texture to its (bucket, layer) within a pool; dedup by source uuid.
 		const assign = ( tex, lists, dedup, flat, shapes ) => {
 
-			if ( ! tex || ! tex.image ) return - 1;
+			if ( ! tex ) return - 1;
+
+			// A map whose image has not landed yet is indistinguishable here from no map at
+			// all, and the material would render untextured with nothing in the log.
+			if ( ! tex.image ) {
+
+				if ( ! undecodedReported ) this.config.issues?.record(
+					ISSUE_CODES.TEXTURE_BUILD_FAILED,
+					'a material map had not finished decoding when the scene was packed; it renders untextured',
+					{ texture: tex.name || tex.source?.uuid || tex.uuid }
+				);
+				undecodedReported = true;
+				return - 1;
+
+			}
+
 			const bucket = getTextureBucketId( tex.image.width, tex.image.height, shapes );
 			const uuid = tex.source?.uuid ?? tex.uuid;
 			const seen = dedup[ bucket ].get( uuid );

package/src/Processor/ToneMapWGSL.js

@@ -0,0 +1,162 @@
+/**
+ * WGSL tone mapping, a transcription of ToneMapCPU.js.
+ *
+ * The two must stay identical: the same image is produced on the CPU by `toneMapToRGBA8`
+ * (renderToBuffer, upscaler) and on the GPU by this (the OIDN output pack). Order is part of
+ * the contract — exposure, saturation, clamp-negative, curve, sRGB OETF — and moving any step
+ * shifts every mid-tone.
+ */
+import {
+	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
+	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
+} from 'three';
+
+const SUPPORTED = new Set( [
+	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
+	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
+] );
+
+/**
+ * Three.js ToneMapping constant → shader mode. Anything unsupported falls back to ACES,
+ * matching `TONE_MAP_FNS.get( x ) || TONE_MAP_FNS.get( ACESFilmicToneMapping )`.
+ * @param {number} toneMapping
+ * @returns {number}
+ */
+export function toneMapMode( toneMapping ) {
+
+	return SUPPORTED.has( toneMapping ) ? toneMapping : ACESFilmicToneMapping;
+
+}
+
+/**
+ * Prelude defining `toneMapPixel( linear, gain, saturation, mode ) -> vec3f` (sRGB, [0,1]).
+ * Concatenate ahead of a kernel that wants it.
+ */
+export const TONE_MAP_WGSL = /* wgsl */`
+fn tmSaturation( c: vec3f, saturation: f32 ) -> vec3f {
+	if ( saturation == 1.0 ) { return c; }
+	let luma = dot( c, vec3f( 0.2126, 0.7152, 0.0722 ) );
+	return vec3f( luma ) + ( c - vec3f( luma ) ) * saturation;
+}
+
+fn tmSrgb1( c: f32 ) -> f32 {
+	if ( c <= 0.0031308 ) { return 12.92 * c; }
+	return 1.055 * pow( c, 1.0 / 2.4 ) - 0.055;
+}
+
+fn tmSrgb( c: vec3f ) -> vec3f {
+	return vec3f( tmSrgb1( c.r ), tmSrgb1( c.g ), tmSrgb1( c.b ) );
+}
+
+fn tmReinhard( c: vec3f ) -> vec3f {
+	return clamp( c / ( c + vec3f( 1.0 ) ), vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmCineon1( x: f32 ) -> f32 {
+	let c = max( x - 0.004, 0.0 );
+	return pow( ( c * ( 6.2 * c + 0.5 ) ) / ( c * ( 6.2 * c + 1.7 ) + 0.06 ), 2.2 );
+}
+
+fn tmCineon( c: vec3f ) -> vec3f {
+	return vec3f( tmCineon1( c.r ), tmCineon1( c.g ), tmCineon1( c.b ) );
+}
+
+fn tmAcesFit( c: f32 ) -> f32 {
+	return ( c * ( c + 0.0245786 ) - 0.000090537 ) / ( c * ( 0.983729 * c + 0.4329510 ) + 0.238081 );
+}
+
+fn tmAces( cIn: vec3f ) -> vec3f {
+	let c = cIn / 0.6;
+	var i = vec3f(
+		0.59719 * c.r + 0.35458 * c.g + 0.04823 * c.b,
+		0.07600 * c.r + 0.90834 * c.g + 0.01566 * c.b,
+		0.02840 * c.r + 0.13383 * c.g + 0.83777 * c.b
+	);
+	i = vec3f( tmAcesFit( i.r ), tmAcesFit( i.g ), tmAcesFit( i.b ) );
+	let o = vec3f(
+		 1.60475 * i.r - 0.53108 * i.g - 0.07367 * i.b,
+		-0.10208 * i.r + 1.10813 * i.g - 0.00605 * i.b,
+		-0.00327 * i.r - 0.07276 * i.g + 1.07602 * i.b
+	);
+	return clamp( o, vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmAgxApprox( x: f32 ) -> f32 {
+	let x2 = x * x;
+	let x4 = x2 * x2;
+	return 15.5 * x4 * x2 - 40.14 * x4 * x + 31.96 * x4 - 6.868 * x2 * x + 0.4298 * x2 + 0.1191 * x - 0.00232;
+}
+
+fn tmAgx( r: vec3f ) -> vec3f {
+	let c = vec3f(
+		0.6274 * r.r + 0.3293 * r.g + 0.0433 * r.b,
+		0.0691 * r.r + 0.9195 * r.g + 0.0113 * r.b,
+		0.0164 * r.r + 0.0880 * r.g + 0.8956 * r.b
+	);
+	var a = vec3f(
+		0.856627153315983 * c.r + 0.0951212405381588 * c.g + 0.0482516061458583 * c.b,
+		0.137318972929847 * c.r + 0.761241990602591  * c.g + 0.101439036467562  * c.b,
+		0.11189821299995  * c.r + 0.0767994186031903 * c.g + 0.811302368396859  * c.b
+	);
+
+	let agxMinEv = -12.47393;
+	let agxMaxEv = 4.026069;
+	let range = agxMaxEv - agxMinEv;
+	a = clamp( ( log2( max( a, vec3f( 1e-10 ) ) ) - vec3f( agxMinEv ) ) / range, vec3f( 0.0 ), vec3f( 1.0 ) );
+	a = vec3f( tmAgxApprox( a.r ), tmAgxApprox( a.g ), tmAgxApprox( a.b ) );
+
+	var o = vec3f(
+		 1.1271005818144368  * a.r - 0.11060664309660323 * a.g - 0.016493938717834573 * a.b,
+		-0.1413297634984383  * a.r + 1.157823702216272   * a.g - 0.016493938717834257 * a.b,
+		-0.14132976349843826 * a.r - 0.11060664309660294 * a.g + 1.2519364065950405   * a.b
+	);
+	o = pow( max( o, vec3f( 0.0 ) ), vec3f( 2.2 ) );
+
+	return clamp( vec3f(
+		 1.6605 * o.r - 0.5876 * o.g - 0.0728 * o.b,
+		-0.1246 * o.r + 1.1329 * o.g - 0.0083 * o.b,
+		-0.0182 * o.r - 0.1006 * o.g + 1.1187 * o.b
+	), vec3f( 0.0 ), vec3f( 1.0 ) );
+}
+
+fn tmNeutral( cIn: vec3f ) -> vec3f {
+	let startCompression = 0.8 - 0.04;
+	let desaturation = 0.15;
+
+	let x = min( cIn.r, min( cIn.g, cIn.b ) );
+	var offset = 0.04;
+	if ( x < 0.08 ) { offset = x - 6.25 * x * x; }
+
+	var c = cIn - vec3f( offset );
+	let peak = max( c.r, max( c.g, c.b ) );
+	if ( peak < startCompression ) { return c; }
+
+	let d = 1.0 - startCompression;
+	let newPeak = 1.0 - d * d / ( peak + d - startCompression );
+	c = c * ( newPeak / peak );
+	let gFactor = 1.0 - 1.0 / ( desaturation * ( peak - newPeak ) + 1.0 );
+
+	return c + ( vec3f( newPeak ) - c ) * gFactor;
+}
+
+fn tmCurve( cIn: vec3f, mode: u32 ) -> vec3f {
+	// Three.js clamps the fragment output before tone mapping ("force unsigned floats"), and
+	// AgX/Neutral mix negatives across channels rather than clipping them.
+	let c = max( cIn, vec3f( 0.0 ) );
+	switch mode {
+		case 0u, 1u: { return clamp( c, vec3f( 0.0 ), vec3f( 1.0 ) ); }
+		case 2u: { return tmReinhard( c ); }
+		case 3u: { return tmCineon( c ); }
+		case 6u: { return tmAgx( c ); }
+		case 7u: { return tmNeutral( c ); }
+		default: { return tmAces( c ); }
+	}
+}
+
+fn toneMapPixel( linear: vec3f, gain: f32, saturation: f32, mode: u32 ) -> vec3f {
+	var c = linear * gain;
+	c = tmSaturation( c, saturation );
+	c = tmCurve( c, mode );
+	return tmSrgb( c );
+}
+`;

package/src/managers/CameraManager.js

@@ -3,6 +3,8 @@ import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { EngineEvents, } from '../EngineEvents.js';
 import { AF_DEFAULTS } from '../EngineDefaults.js';
 
+const DEFAULT_CAMERA_SCALE = Object.freeze( new Vector3( 1, 1, 1 ) );
+
 /**
  * Manages camera creation, switching, auto-focus, and AF point placement.
  *
@@ -83,6 +85,7 @@ export class CameraManager extends EventDispatcher {
 		const cam = new PerspectiveCamera( src.fov, src.aspect, src.near, src.far );
 		cam.position.copy( src.position );
 		cam.quaternion.copy( src.quaternion );
+		cam.scale.copy( src.scale );
 		cam.updateMatrixWorld( true );
 
 		cam.userData.__rayzeeUserCamera = true;
@@ -259,6 +262,7 @@ export class CameraManager extends EventDispatcher {
 			this._defaultCameraState = {
 				position: this.camera.position.clone(),
 				quaternion: this.camera.quaternion.clone(),
+				scale: this.camera.scale.clone(),
 				fov: this.camera.fov,
 				near: this.camera.near,
 				far: this.camera.far,
@@ -275,6 +279,9 @@ export class CameraManager extends EventDispatcher {
 			const s = this._defaultCameraState;
 			this.camera.position.copy( s.position );
 			this.camera.quaternion.copy( s.quaternion );
+			// Clears a mirror picked up from an imported camera; older saved states
+			// predate the field and are unmirrored by definition.
+			this.camera.scale.copy( s.scale ?? DEFAULT_CAMERA_SCALE );
 			this.camera.fov = s.fov;
 			this.camera.near = s.near;
 			this.camera.far = s.far;
@@ -294,6 +301,10 @@ export class CameraManager extends EventDispatcher {
 
 			this.camera.position.copy( sourceCamera.position );
 			this.camera.quaternion.copy( sourceCamera.quaternion );
+			// An imported camera can carry a mirror (a negative axis scale) that no
+			// quaternion can express — a pbrt scene's `Scale -1 1 1`, for one. Copying
+			// pose alone would silently un-mirror the view.
+			this.camera.scale.copy( sourceCamera.scale );
 			this.camera.fov = sourceCamera.fov;
 			this.camera.near = sourceCamera.near;
 			this.camera.far = sourceCamera.far;