rayzee 8.8.2 → 9.1.0

package/src/Processor/PBRT/PBRTCurves.js

@@ -11,6 +11,8 @@
  * scene is 20 million triangles or 200 million.
  */
 
+import { resized } from './buffers.js';
+
 const DEFAULT_STEPS = 2;
 
 /** Uniform cubic B-spline basis at t for the four control points of one span. */
@@ -58,48 +60,111 @@ function cross( a, b, out ) {
 
 }
 
+function spanCount( P, basis ) {
+
+	const cps = P.length / 3;
+	// bspline: every window of 4 control points is one span. bezier: 4 points per span,
+	// sharing an endpoint between consecutive spans.
+	return basis === 'bspline' ? cps - 3 : Math.max( 1, ( cps - 1 ) / 3 );
+
+}
+
+/** The centreline at spline parameter u in [0, spans], written to out[o..o+2]. */
+function pointAt( P, basis, spans, u, w, out, o ) {
+
+	let span = Math.floor( u );
+	if ( span >= spans ) span = spans - 1;
+	const t = u - span;
+
+	if ( basis === 'bspline' ) bsplineWeights( t, w );
+	else bezierWeights( t, w );
+
+	const base = basis === 'bspline' ? span : span * 3;
+	let x = 0, y = 0, z = 0;
+	for ( let k = 0; k < 4; k ++ ) {
+
+		const c = ( base + k ) * 3;
+		x += w[ k ] * P[ c ];
+		y += w[ k ] * P[ c + 1 ];
+		z += w[ k ] * P[ c + 2 ];
+
+	}
+
+	out[ o ] = x; out[ o + 1 ] = y; out[ o + 2 ] = z;
+
+}
+
 /**
  * Sample a curve's centreline.
  * @returns {{points: Float64Array, count: number}} count points, 3 floats each
  */
 function sampleCenterline( P, basis, steps ) {
 
-	const cps = P.length / 3;
-	// bspline: every window of 4 control points is one span. bezier: 4 points per span,
-	// sharing an endpoint between consecutive spans.
-	const spans = basis === 'bspline' ? cps - 3 : Math.max( 1, ( cps - 1 ) / 3 );
+	const spans = spanCount( P, basis );
 	if ( spans < 1 ) return null;
 
 	const total = Math.max( 1, Math.round( steps * spans ) );
 	const points = new Float64Array( ( total + 1 ) * 3 );
 	const w = [ 0, 0, 0, 0 ];
+	for ( let i = 0; i <= total; i ++ ) pointAt( P, basis, spans, ( i / total ) * spans, w, points, i * 3 );
 
-	for ( let i = 0; i <= total; i ++ ) {
+	return { points, count: total + 1, spans };
 
-		const u = ( i / total ) * spans;
-		let span = Math.floor( u );
-		if ( span >= spans ) span = spans - 1;
-		const t = u - span;
+}
 
-		if ( basis === 'bspline' ) bsplineWeights( t, w );
-		else bezierWeights( t, w );
+/** Distance from point a (in pa) to the segment from b to c (in pb). */
+function segmentDistance( pa, a, pb, b, c ) {
 
-		const base = basis === 'bspline' ? span : span * 3;
-		let x = 0, y = 0, z = 0;
-		for ( let k = 0; k < 4; k ++ ) {
+	const ax = pa[ a * 3 ], ay = pa[ a * 3 + 1 ], az = pa[ a * 3 + 2 ];
+	const bx = pb[ b * 3 ], by = pb[ b * 3 + 1 ], bz = pb[ b * 3 + 2 ];
+	const dx = pb[ c * 3 ] - bx, dy = pb[ c * 3 + 1 ] - by, dz = pb[ c * 3 + 2 ] - bz;
+	const len2 = dx * dx + dy * dy + dz * dz;
+	let t = len2 > 0 ? ( ( ax - bx ) * dx + ( ay - by ) * dy + ( az - bz ) * dz ) / len2 : 0;
+	t = t < 0 ? 0 : t > 1 ? 1 : t;
+	return Math.hypot( ax - bx - t * dx, ay - by - t * dy, az - bz - t * dz );
 
-			const o = ( base + k ) * 3;
-			x += w[ k ] * P[ o ];
-			y += w[ k ] * P[ o + 1 ];
-			z += w[ k ] * P[ o + 2 ];
+}
 
-		}
+/**
+ * Which uniform samples an adaptive strip keeps. A segment may stray by `tolerance` of the
+ * half-width, or by the uniform strip's own worst error on this curve if that is larger.
+ * @returns {Int32Array|null} kept sample indices, or null when every sample is kept
+ */
+function adaptiveSamples( P, basis, line, tolerance, width0, width1 ) {
+
+	const { points, count, spans } = line;
+	if ( count < 3 ) return null;
 
-		points[ i * 3 ] = x; points[ i * 3 + 1 ] = y; points[ i * 3 + 2 ] = z;
+	const mids = new Float64Array( ( count - 1 ) * 3 );
+	const w = [ 0, 0, 0, 0 ];
+	const total = count - 1;
+	for ( let k = 0; k < total; k ++ ) pointAt( P, basis, spans, ( ( k + 0.5 ) / total ) * spans, w, mids, k * 3 );
+
+	let worst = 0;
+	for ( let k = 0; k < total; k ++ ) worst = Math.max( worst, segmentDistance( mids, k, points, k, k + 1 ) );
+
+	const allowed = x => Math.max( worst, tolerance * 0.5 * ( width0 + ( width1 - width0 ) * ( x / total ) ) );
+	const fits = ( i, j ) => {
+
+		for ( let k = i + 1; k < j; k ++ ) if ( segmentDistance( points, k, points, i, j ) > allowed( k ) ) return false;
+		for ( let k = i; k < j; k ++ ) if ( segmentDistance( mids, k, points, i, j ) > allowed( k + 0.5 ) ) return false;
+		return true;
+
+	};
+
+	const kept = new Int32Array( count );
+	let n = 0;
+	kept[ n ++ ] = 0;
+	for ( let i = 0; i < total; ) {
+
+		let j = i + 1;
+		while ( j < total && fits( i, j + 1 ) ) j ++;
+		kept[ n ++ ] = j;
+		i = j;
 
 	}
 
-	return { points, count: total + 1 };
+	return n === count ? null : kept.subarray( 0, n );
 
 }
 
@@ -112,6 +177,9 @@ function sampleCenterline( P, basis, steps ) {
  * @param {ArrayLike<number>} [spec.N] - ribbon normals (start, end), 3 floats each
  * @param {number} [spec.steps] - samples per spline span
  * @param {number} [spec.sides=1] - 1 ribbon, 2 crossed ribbons, >=3 closed tube
+ * @param {number} [spec.tolerance=0] - how far a segment may stray from the curve, as a fraction
+ *   of the strip's half-width; `steps` then caps the resolution rather than fixing it. 0 keeps
+ *   every sample.
  * @returns {{positions: Float32Array, indices: Uint32Array}|null}
  */
 export function tessellateCurve( spec ) {
@@ -126,15 +194,20 @@ export function tessellateCurve( spec ) {
 	if ( ! line ) return null;
 
 	const { points, count } = line;
+	const kept = spec.tolerance > 0 ? adaptiveSamples( P, basis, line, spec.tolerance, width0, width1 ) : null;
+	const rows = kept ? kept.length : count;
 	const rings = sides >= 3 ? sides : sides * 2;
-	const positions = new Float32Array( count * rings * 3 );
+	const positions = new Float32Array( rows * rings * 3 );
 
 	const tangent = [ 0, 0, 0 ];
 	const side = [ 0, 0, 0 ];
 	const up = [ 0, 0, 0 ];
 	const tmp = [ 0, 0, 0 ];
 	let haveSide = false;
+	let row = 0;
 
+	// The frame is carried through every sample, kept or not, so a kept ring faces exactly
+	// as it does in the uniform strip.
 	for ( let i = 0; i < count; i ++ ) {
 
 		const a = Math.max( 0, i - 1 ), b = Math.min( count - 1, i + 1 );
@@ -178,6 +251,8 @@ export function tessellateCurve( spec ) {
 
 		}
 
+		if ( kept && kept[ row ] !== i ) continue;
+
 		cross( tangent, side, up );
 		normalize( up );
 
@@ -205,20 +280,22 @@ export function tessellateCurve( spec ) {
 
 			}
 
-			const o = ( i * rings + r ) * 3;
+			const o = ( row * rings + r ) * 3;
 			positions[ o ] = cx + dx * radius;
 			positions[ o + 1 ] = cy + dy * radius;
 			positions[ o + 2 ] = cz + dz * radius;
 
 		}
 
+		row ++;
+
 	}
 
 	const quads = sides >= 3 ? sides : sides;
-	const indices = new Uint32Array( ( count - 1 ) * quads * 6 );
+	const indices = new Uint32Array( ( rows - 1 ) * quads * 6 );
 	let w = 0;
 
-	for ( let i = 0; i < count - 1; i ++ ) {
+	for ( let i = 0; i < rows - 1; i ++ ) {
 
 		for ( let q = 0; q < quads; q ++ ) {
 
@@ -233,11 +310,11 @@ export function tessellateCurve( spec ) {
 
 	}
 
-	return { positions, indices: w === indices.length ? indices : indices.slice( 0, w ) };
+	return { positions, indices: w === indices.length ? indices : resized( indices, w ) };
 
 }
 
-/** Triangles `tessellateCurve` would produce, without building anything. */
+/** Triangles a uniform `tessellateCurve` would produce (an adaptive one's upper bound), without building anything. */
 export function curveTriangleCount( controlPoints, basis, steps, sides ) {
 
 	const cps = controlPoints / 3;

package/src/Processor/PBRT/PBRTParser.js

@@ -28,6 +28,7 @@
  * recorded as `ctmEnd` / `cameraToWorldEnd` / `matricesEnd` only where it differs.
  */
 
+import { resized } from './buffers.js';
 import { TokenStream, TokenType } from './PBRTTokenizer.js';
 import * as M from './PBRTMath.js';
 
@@ -39,6 +40,15 @@ const TYPED_ARRAY_THRESHOLD = 8;
 
 const START = 1, END = 2, BOTH = 3;
 
+// Directives whose effect outlives the file that holds them, or that tie its shapes to
+// something other than the transform it was included under. A file containing none of them
+// builds the same shapes wherever it is included, so a repeat is placed rather than re-read.
+const INCLUDE_SIDE_EFFECTS = new Set( [
+	'Identity', 'Transform', 'CoordinateSystem', 'CoordSysTransform', 'ActiveTransform', 'TransformTimes',
+	'Camera', 'Film', 'WorldBegin', 'MakeNamedMaterial', 'Texture', 'MakeNamedMedium',
+	'LightSource', 'AreaLightSource', 'ObjectBegin', 'ObjectEnd', 'ObjectInstance'
+] );
+
 function sameMatrix( a, b ) {
 
 	if ( a === b ) return true;
@@ -58,20 +68,14 @@ const NUMERIC_STORAGE = {
 	rgb: Float32Array
 };
 
-function growFloat32( array, length ) {
-
-	const grown = new Float32Array( length );
-	grown.set( array );
-	return grown;
-
-}
-
 export class PBRTParser {
 
 	/**
 	 * @param {object} [opts]
 	 * @param {(path:string)=>string} [opts.resolveInclude] - returns the text of
 	 *        an Include/Import target, resolved relative to the current file.
+	 * @param {boolean} [opts.instanceIncludes=true] - a file included again under the same
+	 *        material becomes placements of one template instead of a second copy.
 	 */
 	constructor( opts = {} ) {
 
@@ -85,7 +89,12 @@ export class PBRTParser {
 		// Placements past this are counted and dropped as they are read, not after: the peak
 		// is the parse itself, so a limit applied later saves nothing.
 		this.maxPlacements = opts.maxPlacements ?? Infinity;
-
+		this.instanceIncludes = opts.instanceIncludes !== false;
+		this._includes = new Map();
+		this._stateIds = new WeakMap();
+		this._nextStateId = 1;
+		this._effects = 0;
+		this._movedShapes = false;
 
 		// IR accumulators
 		this.ir = {
@@ -143,6 +152,15 @@ export class PBRTParser {
 
 		this.dirStack = [ baseDir ];
 		await this._run( new TokenStream( src ) );
+		if ( this._movedShapes ) this.ir.shapes = this.ir.shapes.filter( Boolean );
+		// Grown by doubling: up to half of every list is spare, 240 MB at 9M placements.
+		for ( const list of this.ir.instances.values() ) {
+
+			list.matrices = resized( list.matrices, list.count * 16 );
+			if ( list.matricesEnd ) list.matricesEnd = resized( list.matricesEnd, list.count * 16 );
+
+		}
+
 		return this.ir;
 
 	}
@@ -150,7 +168,7 @@ export class PBRTParser {
 	// ── token helpers ──────────────────────────────────────────────
 
 	/** Record one placement, copying the CTM straight into the template's matrix buffer. */
-	_addInstance( name ) {
+	_addInstance( name, m = this.ctm ) {
 
 		if ( this.ir.instanceCount >= this.maxPlacements ) {
 
@@ -166,13 +184,12 @@ export class PBRTParser {
 		if ( need > list.matrices.length ) {
 
 			const length = Math.max( need, list.matrices.length * 2 );
-			list.matrices = growFloat32( list.matrices, length );
-			if ( list.matricesEnd ) list.matricesEnd = growFloat32( list.matricesEnd, length );
+			list.matrices = resized( list.matrices, length );
+			if ( list.matricesEnd ) list.matricesEnd = resized( list.matricesEnd, length );
 
 		}
 
 		const o = list.count * 16;
-		const m = this.ctm;
 		for ( let i = 0; i < 16; i ++ ) list.matrices[ o + i ] = m[ i ];
 
 		// Allocated once a placement of this template moves.
@@ -412,20 +429,14 @@ export class PBRTParser {
 
 				const t = this._next();
 				if ( t.type !== TokenType.NUMBER ) return this._finishMixedValue( buf, n, t );
-				if ( n === buf.length ) {
-
-					const grown = new Storage( buf.length * 2 );
-					grown.set( buf );
-					buf = grown;
-
-				}
+				if ( n === buf.length ) buf = resized( buf, buf.length * 2 );
 
 				buf[ n ++ ] = t.value;
 
 			}
 
 			this._next(); // ]
-			return n === buf.length ? buf : buf.slice( 0, n );
+			return n === buf.length ? buf : resized( buf, n );
 
 		}
 
@@ -486,6 +497,8 @@ export class PBRTParser {
 
 			}
 
+			if ( INCLUDE_SIDE_EFFECTS.has( t.value ) ) this._effects ++;
+
 			// Only Include suspends; every other directive returns undefined and the loop
 			// stays synchronous, so an await per token is not paid.
 			const pending = this._directive( t.value );
@@ -826,6 +839,9 @@ export class PBRTParser {
 	async _include( path ) {
 
 		const dir = this.dirStack[ this.dirStack.length - 1 ];
+		const key = this._includeKey( path, dir );
+		if ( key !== null && this._placeRepeat( key, path ) ) return;
+
 		const source = await this.resolveInclude( path, dir );
 		if ( source == null ) {
 
@@ -834,6 +850,7 @@ export class PBRTParser {
 
 		}
 
+		const before = key === null ? null : this._includeState();
 		const childDir = path.includes( '/' ) ? path.slice( 0, path.lastIndexOf( '/' ) ) : '';
 		this.dirStack.push( childDir );
 		try {
@@ -846,10 +863,103 @@ export class PBRTParser {
 			// Depth-first, so only the open chain is live. Releasing here is what keeps a
 			// multi-gigabyte scene's text from all being resident at once; a file included
 			// again is simply resolved again.
-			this.releaseInclude?.( path, dir );
+			this.releaseInclude?.( path, dir, source );
+
+		}
+
+		if ( before && this._sameIncludeState( before ) && ! this._includes.has( key ) ) {
+
+			this._includes.set( key, { start: before.shapes, end: this.ir.shapes.length, ctm: before.ctm.slice(), template: null } );
+
+		}
+
+	}
+
+	/** Null when this include cannot be reused: inside an object, moving, or emitting light. */
+	_includeKey( path, dir ) {
+
+		if ( ! this.instanceIncludes || this.currentObject !== null ) return null;
+		if ( this.ctmEnd !== null || this.activeTransform !== BOTH || this.state.areaLight ) return null;
+		return `${dir}\0${path}\0${this._stateId( this.state.material )}\0${this.state.reverseOrientation}`;
+
+	}
+
+	_stateId( object ) {
+
+		if ( ! object ) return 0;
+		let id = this._stateIds.get( object );
+		if ( id === undefined ) this._stateIds.set( object, id = this._nextStateId ++ );
+		return id;
+
+	}
+
+	_includeState() {
+
+		return {
+			shapes: this.ir.shapes.length,
+			effects: this._effects,
+			ctm: this.ctm,
+			attributes: this.attributeStack.length,
+			transforms: this.transformStack.length,
+			material: this.state.material,
+			reverseOrientation: this.state.reverseOrientation
+		};
+
+	}
+
+	_sameIncludeState( before ) {
+
+		return this._effects === before.effects && this.ctmEnd === null && this.activeTransform === BOTH &&
+			sameMatrix( this.ctm, before.ctm ) && this.attributeStack.length === before.attributes &&
+			this.transformStack.length === before.transforms && this.state.material === before.material &&
+			this.state.areaLight === null && this.state.reverseOrientation === before.reverseOrientation;
+
+	}
+
+	/**
+	 * Place a repeated include as another instance of the shapes its first reading made,
+	 * turning those into a template the first time. False when they can no longer be moved.
+	 */
+	_placeRepeat( key, path ) {
+
+		const record = this._includes.get( key );
+		if ( ! record ) return false;
+
+		if ( record.template === null ) {
+
+			const { start, end } = record;
+			if ( end === start || this.ir.instanceCount + 2 > this.maxPlacements ) return false;
+			for ( let k = start; k < end; k ++ ) if ( ! this.ir.shapes[ k ] ) {
+
+				this._includes.delete( key );
+				return false;
+
+			}
+
+			const name = `${path}#${this.ir.objects.size}`;
+			const inverse = M.invert( record.ctm );
+			const template = [];
+			let ctm = null, relative = null;
+			for ( let k = start; k < end; k ++ ) {
+
+				const shape = this.ir.shapes[ k ];
+				if ( shape.ctm !== ctm ) relative = M.multiply( inverse, ctm = shape.ctm );
+				shape.relativeCTM = relative;
+				template.push( shape );
+				this.ir.shapes[ k ] = null;
+
+			}
+
+			this.ir.objects.set( name, template );
+			this._addInstance( name, record.ctm );
+			record.template = name;
+			this._movedShapes = true;
 
 		}
 
+		this._addInstance( record.template );
+		return true;
+
 	}
 
 	_skipTypeAndParams() {