rayzee 7.31.0 → 8.0.0

package/src/Processor/PBRT/EqualAreaOctahedral.js

@@ -0,0 +1,173 @@
+/**
+ * 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 ) ];
+
+}
+
+/** 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 );
+	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 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;
+
+	}
+
+}
+
+/**
+ * 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, 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
+ * @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 table = src.srgb ? SRGB_TO_LINEAR : 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, table );
+
+			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/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

@@ -17,7 +17,35 @@ 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). */
+/** 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 ];