rayzee 11.13.0 → 11.15.0

package/src/{Processor → scene}/GeometryExtractor.js

@@ -1,14 +1,55 @@
-import { BufferAttribute, Vector3, Vector2, Color, Matrix3, Matrix4, FrontSide, BackSide, DoubleSide, RGBAFormat } from "three";
+import { Box3, BufferAttribute, Vector3, Vector2, Color, Matrix3, Matrix4, FrontSide, BackSide, DoubleSide, RGBAFormat } from "three";
 import { MATERIAL_DEFAULTS } from '../EngineDefaults.js';
 import { TRIANGLE_DATA_LAYOUT, packNormalOct, packTriangleFlags } from './BufferLayout.js';
-import { TEXTURE_CONSTANTS } from './TextureBuckets.js';
+import { TEXTURE_CONSTANTS } from '../materials/TextureBuckets.js';
 import { ISSUE_CODES } from '../EngineIssues.js';
-import { ChunkedRecords, SHARED_MEMORY_AVAILABLE } from './ChunkedRecords.js';
-import { createLogger, fmt, warnOnce } from '../utils/Logger.js';
-import { GeometrySpill } from '../Storage/GeometrySpill.js';
+import { ChunkedRecords, SHARED_MEMORY_AVAILABLE } from '../memory/ChunkedRecords.js';
+import { createLogger, fmt, warnOnce } from '../Logger.js';
+import { GeometrySpill } from '../storage/GeometrySpill.js';
 
 const log = createLogger( 'geometry' );
 
+/** InstancedMesh.computeBoundingBox, bit for bit, for each instanced mesh under `object` without a box yet. */
+export function computeInstanceBoundingBoxes( object ) {
+
+	object.traverse( mesh => {
+
+		if ( ! mesh.isInstancedMesh || mesh.boundingBox !== null ) return;
+		const geometry = mesh.geometry;
+		if ( geometry.boundingBox === null ) geometry.computeBoundingBox();
+		const box = mesh.boundingBox = new Box3();
+		const local = geometry.boundingBox;
+		if ( local.isEmpty() ) return;
+
+		const xs = [ local.min.x, local.max.x ], ys = [ local.min.y, local.max.y ], zs = [ local.min.z, local.max.z ];
+		const m = mesh.instanceMatrix.array;
+		let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = - Infinity, y1 = - Infinity, z1 = - Infinity;
+		for ( let i = 0, o = 0; i < mesh.count; i ++, o += 16 ) {
+
+			const e0 = m[ o ], e1 = m[ o + 1 ], e2 = m[ o + 2 ], e3 = m[ o + 3 ], e4 = m[ o + 4 ], e5 = m[ o + 5 ], e6 = m[ o + 6 ], e7 = m[ o + 7 ];
+			const e8 = m[ o + 8 ], e9 = m[ o + 9 ], e10 = m[ o + 10 ], e11 = m[ o + 11 ], e12 = m[ o + 12 ], e13 = m[ o + 13 ], e14 = m[ o + 14 ], e15 = m[ o + 15 ];
+			for ( let c = 0; c < 8; c ++ ) {
+
+				const x = xs[ c >> 2 ], y = ys[ ( c >> 1 ) & 1 ], z = zs[ c & 1 ];
+				// Vector3.applyMatrix4's operations, in its order.
+				const w = 1 / ( e3 * x + e7 * y + e11 * z + e15 );
+				const px = ( e0 * x + e4 * y + e8 * z + e12 ) * w;
+				const py = ( e1 * x + e5 * y + e9 * z + e13 ) * w;
+				const pz = ( e2 * x + e6 * y + e10 * z + e14 ) * w;
+				x0 = Math.min( x0, px ); y0 = Math.min( y0, py ); z0 = Math.min( z0, pz );
+				x1 = Math.max( x1, px ); y1 = Math.max( y1, py ); z1 = Math.max( z1, pz );
+
+			}
+
+		}
+
+		box.min.set( x0, y0, z0 );
+		box.max.set( x1, y1, z1 );
+
+	} );
+
+}
+
 const MAX_TEXTURES_LIMIT = TEXTURE_CONSTANTS.MAX_TEXTURES_LIMIT;
 
 const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor', 'diffuseTransmissionColor' ] );
@@ -1062,7 +1103,6 @@ export class GeometryExtractor {
 
 	}
 
-
 	getMaterialType( material ) {
 
 		// Detect material type for appropriate property mapping

package/src/scene/SceneEdits.js

@@ -0,0 +1,260 @@
+import { SRGBColorSpace, LinearSRGBColorSpace } from 'three/webgpu';
+import { ISSUE_CODES } from '../EngineIssues.js';
+import { TRIANGLE_PATCH_PROPERTIES } from '../materials/MaterialDataManager.js';
+import { usesTextureCoordinates } from './GeometryExtractor.js';
+import { scheduleRespill } from '../memory/SceneSpill.js';
+
+export async function refitBVH( app, newPositions, newNormals ) {
+
+	await app.ensureSceneResident();
+	const { triRanges, bvhRanges, ...result } = await app._sdf.refitBVH( newPositions, newNormals );
+
+	app.stages.pathTracer.updateTriangleData( app._sdf.triangles, triRanges );
+	app.stages.pathTracer.updateBVHData( app._sdf.bvh, bvhRanges );
+	app.reset( false, { motion: true } );
+
+	return result;
+
+}
+
+export function refitBLASes( app, affectedMeshIndices, newPositions, newNormals ) {
+
+	if ( app._sdf?.spilled ) throw new Error( 'refitBLASes: the scene is spilled to disk — await app.ensureSceneResident() first' );
+	const result = app._sdf.refitBLASes( affectedMeshIndices, newPositions, newNormals );
+
+	const { triRanges, bvhRanges } = app._sdf.computeBLASDirtyRanges( affectedMeshIndices );
+	app.stages.pathTracer.updateBufferRanges( triRanges, bvhRanges );
+	app.reset( false, { motion: true } );
+
+	// Kick off background rebuild for optimal SAH quality
+	app._sdf.scheduleBackgroundRebuild( affectedMeshIndices, ( meshIndex ) => {
+
+		// Swap complete — upload just that mesh's triangles and nodes, plus the TLAS. A whole
+		// re-upload here is gigabytes on a large scene, for one mesh's worth of change.
+		const dirty = app._sdf.computeBLASDirtyRanges( [ meshIndex ] );
+		app.stages.pathTracer.updateBufferRanges( dirty.triRanges, dirty.bvhRanges );
+		app.reset( false, { motion: true } );
+
+	} );
+
+	return result;
+
+}
+
+export function updateMeshTransforms( app, meshIndices ) {
+
+	// A spilled scene's matrix lists, TLAS or copy records are on disk: the move lands once they are back.
+	if ( app._sdf?.needsPageInForMove( meshIndices ) ) {
+
+		app._sdf.ensureMovable( meshIndices )
+			.then( () => app.updateMeshTransforms( meshIndices ) )
+			.catch( error => app._issues.warn( ISSUE_CODES.STORAGE_READ_FAILED, `reading instance matrices back failed: ${error.message}` ) );
+		return null;
+
+	}
+
+	app._notePlacementsMoving( meshIndices );
+	const result = app._sdf.updateMeshTransforms( meshIndices );
+
+	app.stages.pathTracer.updateBufferRanges( [], app._sdf.takeMoveRanges() );
+	app.reset( false, { motion: true } );
+	scheduleRespill( app );
+
+	return result;
+
+}
+
+export function getMaterialProperty( app, materialIndex, property ) {
+
+	return app.stages.pathTracer?.materialData.getMaterialProperty( materialIndex, property );
+
+}
+
+export function getMaterialPropertySource( app, materialIndex, property ) {
+
+	return app.stages.pathTracer?.materialData.getMaterialPropertySource( materialIndex, property );
+
+}
+
+export function setMaterialProperty( app, materialIndex, property, value ) {
+
+	// These rewrite triangle records, which a spilled scene has to read back first.
+	if ( app._sdf?.spilled && TRIANGLE_PATCH_PROPERTIES.has( property ) ) {
+
+		app.ensureSceneResident().then( () => app.setMaterialProperty( materialIndex, property, value ) );
+		return;
+
+	}
+
+	app.stages.pathTracer?.materialData.updateMaterialProperty( materialIndex, property, value );
+
+	// Keep the emissive-NEE structure in sync unconditionally (not gated on the
+	// sampling toggle) so edits made while NEE is off aren't lost on re-enable.
+	const emissiveAffectingProps = [ 'emissive', 'emissiveIntensity' ];
+	if ( emissiveAffectingProps.includes( property ) && app._sdf ) {
+
+		app._uploadEmissivePayload( app._sdf.updateMaterialEmissive( materialIndex, property, value ) );
+
+	}
+
+	app.reset();
+
+}
+
+/**
+ * Upload a rebuilt emissive-NEE payload (sorted emissive data + Light BVH +
+ * bit-trail map) to the path tracer stage. No-op for a null payload.
+ * @param {object|null} payload
+ */
+export function uploadEmissivePayload( app, payload ) {
+
+	if ( ! payload || ! app.stages.pathTracer ) return;
+
+	app.stages.pathTracer.setEmissiveTriangleData(
+		payload.rawData, payload.emissiveCount, payload.totalPower, payload.bitTrailMap,
+	);
+	if ( payload.lightBVHNodeData ) {
+
+		app.stages.pathTracer.setLightBVHData( payload.lightBVHNodeData, payload.lightBVHNodeCount );
+
+	}
+
+}
+
+/**
+ * Re-derive the emissive-NEE sampled set from current per-mesh world-visibility
+ * (InstanceTable is the source of truth — patched by the stage's visibility API).
+ * Hidden meshes' triangles are dropped from the Light BVH so they stop casting
+ * NEE light; the shadow ray can't do it (a hidden mesh no longer self-occludes).
+ */
+export function refreshEmissiveForVisibility( app ) {
+
+	const table = app._sdf?.instanceTable;
+	if ( ! table ) return;
+
+	// The emitter list names meshes, the table placements.
+	const hidden = new Set();
+	for ( let i = 0; i < table.count; i ++ ) {
+
+		if ( table.isSet[ i ] && ! table.visible[ i ] ) hidden.add( table.sourceMesh[ i ] );
+
+	}
+
+	app._uploadEmissivePayload( app._sdf.rebuildEmissiveForVisibility( hidden ) );
+
+}
+
+export function setEmissiveTriangleSampling( app, enabled ) {
+
+	app._emissiveSamplingUserSet = true;
+	app.settings.set( 'enableEmissiveTriangleSampling', enabled );
+
+}
+
+export function hasEmissiveGeometry( app ) {
+
+	return ( app._sdf?.emissiveTriangleBuilder?.emissiveTriangles?.length
+		?? app._sdf?.emissiveTriangleCount ?? 0 ) > 0;
+
+}
+
+export function setMeshVisibility( app, meshIndex, visible ) {
+
+	whenTLASEditable( app, () => app.stages.pathTracer?.updateMeshVisibility( meshIndex, visible ) );
+
+}
+
+export function updateAllMeshVisibility( app ) {
+
+	whenTLASEditable( app, () => app.stages.pathTracer?.updateAllMeshVisibility() );
+
+}
+
+/** Applies a visibility edit, then resets — once a spilled TLAS is back in memory. @private */
+function whenTLASEditable( app, edit ) {
+
+	const apply = () => {
+
+		edit();
+		app._refreshEmissiveForVisibility();
+		app.reset();
+		scheduleRespill( app );
+
+	};
+
+	const ready = app._sdf?.whenTLASEditable();
+	if ( ! ready ) return apply();
+	ready.then( apply ).catch( error => app._issues.warn( ISSUE_CODES.STORAGE_READ_FAILED, `reading the TLAS back failed: ${error.message}` ) );
+
+}
+
+export function setMeshVisibilityByUuid( app, uuid, visible ) {
+
+	const object = app.getScene()?.getObjectByProperty( 'uuid', uuid );
+	if ( ! object ) return null;
+	const next = typeof visible === 'function' ? !! visible( object.visible ) : !! visible;
+	object.visible = next;
+	app.updateAllMeshVisibility();
+	return next;
+
+}
+
+export function setTextureTransform( app, materialIndex, textureName, transform ) {
+
+	app.stages.pathTracer?.materialData.updateTextureTransform( materialIndex, textureName, transform );
+	app.reset();
+
+}
+
+export async function setTextureColorSpace( app, texture, choice ) {
+
+	if ( ! texture?.isTexture ) throw new Error( 'setTextureColorSpace wants a three.js texture' );
+
+	const ud = texture.userData ?? ( texture.userData = {} );
+	if ( ud.__rayzeeOriginalColorSpace === undefined ) ud.__rayzeeOriginalColorSpace = texture.colorSpace;
+	const original = ud.__rayzeeOriginalColorSpace;
+
+	delete ud.ocioColorSpace;
+	delete ud.__rayzeeColorSpaceChoice;
+
+	if ( choice === null || choice === undefined ) {
+
+		texture.colorSpace = original;
+		delete ud.__rayzeeOriginalColorSpace;
+
+	} else if ( choice === 'srgb' || choice === 'linear' ) {
+
+		texture.colorSpace = choice === 'srgb' ? SRGBColorSpace : LinearSRGBColorSpace;
+		ud.__rayzeeColorSpaceChoice = choice;
+
+	} else {
+
+		if ( ! app.color?.hasConfig ) throw new Error( `"${choice}" needs a colour config loaded` );
+		ud.ocioColorSpace = choice;
+		texture.colorSpace = SRGBColorSpace;
+
+	}
+
+	texture.needsUpdate = true;
+	if ( app.stages.pathTracer?.sdfs ) await app.rebuildMaterials();
+
+}
+
+export async function rebuildMaterials( app, scene ) {
+
+	await app.ensureSceneResident();
+	const stage = app.stages.pathTracer;
+	await stage?.rebuildMaterials( scene || app.meshScene );
+
+	// Loaded without texture coordinates, and a material has a texture now: they go up again from the records.
+	if ( stage?.triangleStorageNode?.withoutUV && app._sdf?.triangles && usesTextureCoordinates( scene || app.meshScene ) ) {
+
+		app._sdf.textureCoordinates = true;
+		stage.setTriangleData( app._sdf.triangles, app._sdf.triangleCount, { textureCoordinates: true } );
+		stage.setupMaterial();
+
+	}
+
+	app.reset();
+
+}