rayzee 7.31.1 → 8.0.0

package/src/Processor/PBRT/EqualAreaOctahedral.js

@@ -52,8 +52,26 @@ export function equalAreaSphereToSquare( dx, dy, dz ) {
 
 }
 
-/** Bilinear fetch from a tightly packed float image, clamped at the edges. */
-function sampleBilinear( data, width, height, channels, u, v, out ) {
+/** 8-bit sRGB → linear, tabulated so a per-tap decode costs a lookup rather than a pow(). */
+const SRGB_TO_LINEAR = ( () => {
+
+	const t = new Float32Array( 256 );
+	for ( let i = 0; i < 256; i ++ ) {
+
+		const c = i / 255;
+		t[ i ] = c <= 0.04045 ? c / 12.92 : Math.pow( ( c + 0.055 ) / 1.055, 2.4 );
+
+	}
+
+	return t;
+
+} )();
+
+/**
+ * Bilinear fetch from a tightly packed image, clamped at the edges.
+ * `table` maps stored values to linear before filtering; null reads them as-is.
+ */
+function sampleBilinear( data, width, height, channels, u, v, out, table ) {
 
 	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 );
@@ -68,8 +86,12 @@ function sampleBilinear( data, width, height, channels, u, v, out ) {
 
 	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;
+		const a = table ? table[ data[ i00 + c ] ] : data[ i00 + c ];
+		const b = table ? table[ data[ i10 + c ] ] : data[ i10 + c ];
+		const d = table ? table[ data[ i01 + c ] ] : data[ i01 + c ];
+		const e = table ? table[ data[ i11 + c ] ] : data[ i11 + c ];
+		const top = a * ( 1 - tx ) + b * tx;
+		const bottom = d * ( 1 - tx ) + e * tx;
 		out[ c ] = top * ( 1 - ty ) + bottom * ty;
 
 	}
@@ -83,9 +105,10 @@ function sampleBilinear( data, width, height, channels, u, v, out ) {
  * 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.
+ *   bottomUp?: boolean, srgb?: 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.
+ *   `srgb` when the samples are 8-bit sRGB, as a PNG read back through a canvas is.
  * @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
@@ -100,6 +123,7 @@ export function octahedralToEquirect( src, lightToWorld, scale = 1, outWidth = 0
 	// 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 table = src.srgb ? SRGB_TO_LINEAR : null;
 	const rgb = [ 0, 0, 0 ];
 
 	for ( let j = 0; j < height; j ++ ) {
@@ -132,7 +156,7 @@ export function octahedralToEquirect( src, lightToWorld, scale = 1, outWidth = 0
 			}
 
 			const [ su, sv ] = equalAreaSphereToSquare( dx, dy, dz );
-			sampleBilinear( src.data, src.width, src.height, src.channels, su, src.bottomUp ? 1 - sv : sv, rgb );
+			sampleBilinear( src.data, src.width, src.height, src.channels, su, src.bottomUp ? 1 - sv : sv, rgb, table );
 
 			const o = ( j * width + i ) * 4;
 			out[ o ] = rgb[ 0 ] * scale;

package/src/Processor/PBRT/PBRTCurves.js

@@ -0,0 +1,249 @@
+/**
+ * Tessellation for pbrt-v4's `Shape "curve"`.
+ *
+ * pbrt intersects curves analytically as swept cubic splines. The engine only traces
+ * triangles, so each curve becomes a strip: one ribbon for `flat`/`ribbon`, a crossed
+ * pair for `cylinder` (view-independent and a quarter the cost of a real tube), or a
+ * closed tube when asked for one.
+ *
+ * Cost is the whole story here — Moana's isMountainB ground cover alone declares 5.18
+ * million curve shapes, so `steps` and `sides` are the knobs that decide whether a
+ * scene is 20 million triangles or 200 million.
+ */
+
+const DEFAULT_STEPS = 2;
+
+/** Uniform cubic B-spline basis at t for the four control points of one span. */
+function bsplineWeights( t, out ) {
+
+	const t2 = t * t;
+	const t3 = t2 * t;
+	out[ 0 ] = ( 1 - 3 * t + 3 * t2 - t3 ) / 6;
+	out[ 1 ] = ( 4 - 6 * t2 + 3 * t3 ) / 6;
+	out[ 2 ] = ( 1 + 3 * t + 3 * t2 - 3 * t3 ) / 6;
+	out[ 3 ] = t3 / 6;
+
+}
+
+/** Cubic Bezier basis at t. */
+function bezierWeights( t, out ) {
+
+	const u = 1 - t;
+	out[ 0 ] = u * u * u;
+	out[ 1 ] = 3 * u * u * t;
+	out[ 2 ] = 3 * u * t * t;
+	out[ 3 ] = t * t * t;
+
+}
+
+function normalize( v ) {
+
+	const l = Math.hypot( v[ 0 ], v[ 1 ], v[ 2 ] );
+	if ( l > 0 ) {
+
+		v[ 0 ] /= l; v[ 1 ] /= l; v[ 2 ] /= l;
+
+	}
+
+	return v;
+
+}
+
+function cross( a, b, out ) {
+
+	out[ 0 ] = a[ 1 ] * b[ 2 ] - a[ 2 ] * b[ 1 ];
+	out[ 1 ] = a[ 2 ] * b[ 0 ] - a[ 0 ] * b[ 2 ];
+	out[ 2 ] = a[ 0 ] * b[ 1 ] - a[ 1 ] * b[ 0 ];
+	return out;
+
+}
+
+/**
+ * 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 );
+	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 ++ ) {
+
+		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 );
+
+		const base = basis === 'bspline' ? span : span * 3;
+		let x = 0, y = 0, z = 0;
+		for ( let k = 0; k < 4; k ++ ) {
+
+			const o = ( base + k ) * 3;
+			x += w[ k ] * P[ o ];
+			y += w[ k ] * P[ o + 1 ];
+			z += w[ k ] * P[ o + 2 ];
+
+		}
+
+		points[ i * 3 ] = x; points[ i * 3 + 1 ] = y; points[ i * 3 + 2 ] = z;
+
+	}
+
+	return { points, count: total + 1 };
+
+}
+
+/**
+ * @param {object} spec
+ * @param {ArrayLike<number>} spec.P - control points, 3 floats each
+ * @param {string} [spec.basis='bezier'] - 'bezier' | 'bspline'
+ * @param {number} [spec.width0=1]
+ * @param {number} [spec.width1=1]
+ * @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
+ * @returns {{positions: Float32Array, indices: Uint32Array}|null}
+ */
+export function tessellateCurve( spec ) {
+
+	const { P, basis = 'bezier', width0 = 1, width1 = 1, N = null } = spec;
+	const steps = Math.max( 1, Math.round( spec.steps ?? DEFAULT_STEPS ) );
+	const sides = Math.max( 1, Math.round( spec.sides ?? 1 ) );
+
+	if ( ! P || P.length < 12 ) return null;
+
+	const line = sampleCenterline( P, basis, steps );
+	if ( ! line ) return null;
+
+	const { points, count } = line;
+	const rings = sides >= 3 ? sides : sides * 2;
+	const positions = new Float32Array( count * 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;
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		const a = Math.max( 0, i - 1 ), b = Math.min( count - 1, i + 1 );
+		tangent[ 0 ] = points[ b * 3 ] - points[ a * 3 ];
+		tangent[ 1 ] = points[ b * 3 + 1 ] - points[ a * 3 + 1 ];
+		tangent[ 2 ] = points[ b * 3 + 2 ] - points[ a * 3 + 2 ];
+		normalize( tangent );
+
+		if ( ! haveSide ) {
+
+			// Seed from the ribbon normal when the scene gives one, else from whichever
+			// axis the tangent leans on least.
+			if ( N && N.length >= 3 ) {
+
+				side[ 0 ] = N[ 0 ]; side[ 1 ] = N[ 1 ]; side[ 2 ] = N[ 2 ];
+				cross( tangent, side, tmp );
+				side[ 0 ] = tmp[ 0 ]; side[ 1 ] = tmp[ 1 ]; side[ 2 ] = tmp[ 2 ];
+
+			} else {
+
+				const ax = Math.abs( tangent[ 0 ] ), ay = Math.abs( tangent[ 1 ] ), az = Math.abs( tangent[ 2 ] );
+				const ref = ax < ay && ax < az ? [ 1, 0, 0 ] : ay < az ? [ 0, 1, 0 ] : [ 0, 0, 1 ];
+				cross( tangent, ref, side );
+
+			}
+
+			if ( Math.hypot( side[ 0 ], side[ 1 ], side[ 2 ] ) < 1e-9 ) cross( tangent, [ 0, 1, 0 ], side );
+			normalize( side );
+			haveSide = true;
+
+		} else {
+
+			// Rotation-minimising: drop the previous side back onto the new normal plane,
+			// so a coiled curve does not twist its ribbon.
+			const d = side[ 0 ] * tangent[ 0 ] + side[ 1 ] * tangent[ 1 ] + side[ 2 ] * tangent[ 2 ];
+			side[ 0 ] -= d * tangent[ 0 ];
+			side[ 1 ] -= d * tangent[ 1 ];
+			side[ 2 ] -= d * tangent[ 2 ];
+			if ( Math.hypot( side[ 0 ], side[ 1 ], side[ 2 ] ) < 1e-9 ) cross( tangent, [ 0, 1, 0 ], side );
+			normalize( side );
+
+		}
+
+		cross( tangent, side, up );
+		normalize( up );
+
+		const u = i / ( count - 1 || 1 );
+		const radius = ( width0 + ( width1 - width0 ) * u ) * 0.5;
+		const cx = points[ i * 3 ], cy = points[ i * 3 + 1 ], cz = points[ i * 3 + 2 ];
+
+		for ( let r = 0; r < rings; r ++ ) {
+
+			let dx, dy, dz;
+			if ( sides >= 3 ) {
+
+				const a2 = ( r / sides ) * Math.PI * 2;
+				const c = Math.cos( a2 ), s = Math.sin( a2 );
+				dx = side[ 0 ] * c + up[ 0 ] * s;
+				dy = side[ 1 ] * c + up[ 1 ] * s;
+				dz = side[ 2 ] * c + up[ 2 ] * s;
+
+			} else {
+
+				// Ribbon r spans -1..+1 along its own axis: `side` first, `up` for the cross.
+				const axis = r < 2 ? side : up;
+				const sign = r % 2 === 0 ? - 1 : 1;
+				dx = axis[ 0 ] * sign; dy = axis[ 1 ] * sign; dz = axis[ 2 ] * sign;
+
+			}
+
+			const o = ( i * rings + r ) * 3;
+			positions[ o ] = cx + dx * radius;
+			positions[ o + 1 ] = cy + dy * radius;
+			positions[ o + 2 ] = cz + dz * radius;
+
+		}
+
+	}
+
+	const quads = sides >= 3 ? sides : sides;
+	const indices = new Uint32Array( ( count - 1 ) * quads * 6 );
+	let w = 0;
+
+	for ( let i = 0; i < count - 1; i ++ ) {
+
+		for ( let q = 0; q < quads; q ++ ) {
+
+			const r0 = sides >= 3 ? q : q * 2;
+			const r1 = sides >= 3 ? ( q + 1 ) % sides : q * 2 + 1;
+			const a = i * rings + r0, b = i * rings + r1;
+			const c = ( i + 1 ) * rings + r1, d = ( i + 1 ) * rings + r0;
+			indices[ w ++ ] = a; indices[ w ++ ] = b; indices[ w ++ ] = c;
+			indices[ w ++ ] = a; indices[ w ++ ] = c; indices[ w ++ ] = d;
+
+		}
+
+	}
+
+	return { positions, indices: w === indices.length ? indices : indices.slice( 0, w ) };
+
+}
+
+/** Triangles `tessellateCurve` would produce, without building anything. */
+export function curveTriangleCount( controlPoints, basis, steps, sides ) {
+
+	const cps = controlPoints / 3;
+	const spans = basis === 'bspline' ? cps - 3 : Math.max( 1, ( cps - 1 ) / 3 );
+	if ( spans < 1 ) return 0;
+	const segments = Math.max( 1, Math.round( Math.max( 1, steps ) * spans ) );
+	return segments * Math.max( 1, Math.round( sides ) ) * 2;
+
+}

package/src/Processor/PBRT/PBRTMath.js

@@ -27,6 +27,25 @@ export function determinant3( m ) {
 }
 
 /** Matrix product a*b (applies b first, then a, to a column vector). */
+/** a*b written into `out`, so a hot loop over millions of placements allocates nothing. */
+export function multiplyInto( out, a, aOff, b ) {
+
+	for ( let c = 0; c < 4; c ++ ) {
+
+		const b0 = b[ c * 4 ], b1 = b[ c * 4 + 1 ], b2 = b[ c * 4 + 2 ], b3 = b[ c * 4 + 3 ];
+		for ( let r = 0; r < 4; r ++ ) {
+
+			out[ c * 4 + r ] = a[ aOff + r ] * b0 + a[ aOff + 4 + r ] * b1
+				+ a[ aOff + 8 + r ] * b2 + a[ aOff + 12 + r ] * b3;
+
+		}
+
+	}
+
+	return out;
+
+}
+
 export function multiply( a, b ) {
 
 	const a11 = a[ 0 ], a21 = a[ 1 ], a31 = a[ 2 ], a41 = a[ 3 ];