rayzee 11.2.1 → 11.3.0

package/src/Processor/PBRT/PBRTCurves.js

@@ -94,6 +94,24 @@ function pointAt( P, basis, spans, u, w, out, o ) {
 
 }
 
+/** Width at x in [0, 1] along a curve from a width per control point, weighted as the points are. */
+function widthAlong( widths, basis, spans ) {
+
+	const w = [ 0, 0, 0, 0 ];
+	return x => {
+
+		const u = x * spans;
+		let span = Math.floor( u );
+		if ( span >= spans ) span = spans - 1;
+		if ( basis === 'bspline' ) bsplineWeights( u - span, w );
+		else bezierWeights( u - span, w );
+		const base = basis === 'bspline' ? span : span * 3;
+		return w[ 0 ] * widths[ base ] + w[ 1 ] * widths[ base + 1 ] + w[ 2 ] * widths[ base + 2 ] + w[ 3 ] * widths[ base + 3 ];
+
+	};
+
+}
+
 /**
  * Sample a curve's centreline.
  * @returns {{points: Float64Array, count: number}} count points, 3 floats each
@@ -130,7 +148,7 @@ function segmentDistance( pa, a, pb, b, c ) {
  * 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 ) {
+function adaptiveSamples( P, basis, line, tolerance, widthOf ) {
 
 	const { points, count, spans } = line;
 	if ( count < 3 ) return null;
@@ -143,7 +161,7 @@ function adaptiveSamples( P, basis, line, tolerance, width0, width1 ) {
 	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 allowed = x => Math.max( worst, tolerance * 0.5 * widthOf( 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;
@@ -174,6 +192,8 @@ function adaptiveSamples( P, basis, line, tolerance, width0, width1 ) {
  * @param {string} [spec.basis='bezier'] - 'bezier' | 'bspline'
  * @param {number} [spec.width0=1]
  * @param {number} [spec.width1=1]
+ * @param {ArrayLike<number>} [spec.widths] - a width per control point, following the curve's basis like the points;
+ *   overrides width0 / width1
  * @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
@@ -193,8 +213,9 @@ export function tessellateCurve( spec ) {
 	const line = sampleCenterline( P, basis, steps );
 	if ( ! line ) return null;
 
-	const { points, count } = line;
-	const kept = spec.tolerance > 0 ? adaptiveSamples( P, basis, line, spec.tolerance, width0, width1 ) : null;
+	const { points, count, spans } = line;
+	const widthOf = spec.widths ? widthAlong( spec.widths, basis, spans ) : x => width0 + ( width1 - width0 ) * x;
+	const kept = spec.tolerance > 0 ? adaptiveSamples( P, basis, line, spec.tolerance, widthOf ) : null;
 	const rows = kept ? kept.length : count;
 	const rings = sides >= 3 ? sides : sides * 2;
 	const positions = new Float32Array( rows * rings * 3 );
@@ -256,8 +277,7 @@ export function tessellateCurve( spec ) {
 		cross( tangent, side, up );
 		normalize( up );
 
-		const u = i / ( count - 1 || 1 );
-		const radius = ( width0 + ( width1 - width0 ) * u ) * 0.5;
+		const radius = widthOf( i / ( count - 1 || 1 ) ) * 0.5;
 		const cx = points[ i * 3 ], cy = points[ i * 3 + 1 ], cz = points[ i * 3 + 2 ];
 
 		for ( let r = 0; r < rings; r ++ ) {
@@ -324,3 +344,201 @@ export function curveTriangleCount( controlPoints, basis, steps, sides ) {
 	return segments * Math.max( 1, Math.round( sides ) ) * 2;
 
 }
+
+const lerp3 = ( out, o, P, a, b, t ) => {
+
+	for ( let k = 0; k < 3; k ++ ) out[ o + k ] = P[ a * 3 + k ] + ( P[ b * 3 + k ] - P[ a * 3 + k ] ) * t;
+
+};
+
+/** Linear or Catmull-Rom spans as cubic Bézier ones (exact for both), with widths carried the same way. */
+function bezierSpans( P, widths, segments, ends ) {
+
+	const out = new Float64Array( ( segments.length * 3 + 1 ) * 3 );
+	const w = widths ? new Float64Array( segments.length * 3 + 1 ) : null;
+	let o = 0;
+	for ( let s = 0; s < segments.length; s ++ ) {
+
+		const [ a, b, prev, next ] = segments[ s ];
+		if ( s === 0 ) {
+
+			for ( let k = 0; k < 3; k ++ ) out[ k ] = P[ a * 3 + k ];
+			if ( w ) w[ 0 ] = widths[ a ];
+
+		}
+
+		if ( ends === 'linear' ) {
+
+			lerp3( out, ( o + 1 ) * 3, P, a, b, 1 / 3 );
+			lerp3( out, ( o + 2 ) * 3, P, a, b, 2 / 3 );
+
+		} else {
+
+			for ( let k = 0; k < 3; k ++ ) {
+
+				out[ ( o + 1 ) * 3 + k ] = P[ a * 3 + k ] + ( P[ b * 3 + k ] - P[ prev * 3 + k ] ) / 6;
+				out[ ( o + 2 ) * 3 + k ] = P[ b * 3 + k ] - ( P[ next * 3 + k ] - P[ a * 3 + k ] ) / 6;
+
+			}
+
+		}
+
+		for ( let k = 0; k < 3; k ++ ) out[ ( o + 3 ) * 3 + k ] = P[ b * 3 + k ];
+		if ( w ) {
+
+			w[ o + 1 ] = widths[ a ] + ( widths[ b ] - widths[ a ] ) / 3;
+			w[ o + 2 ] = widths[ a ] + ( widths[ b ] - widths[ a ] ) * 2 / 3;
+			w[ o + 3 ] = widths[ b ];
+
+		}
+
+		o += 3;
+
+	}
+
+	return { P: out, widths: w, basis: 'bezier' };
+
+}
+
+/** One USD curve as the cubic B-spline or Bézier controls tessellateCurve takes, or null. */
+function cubicControls( P, widths, type, basis, wrap ) {
+
+	const n = P.length / 3;
+	const periodic = wrap === 'periodic';
+	if ( type === 'linear' ) {
+
+		if ( n < 2 ) return null;
+		const segments = [];
+		for ( let i = 0; i + 1 < n; i ++ ) segments.push( [ i, i + 1 ] );
+		if ( periodic && n > 2 ) segments.push( [ n - 1, 0 ] );
+		return bezierSpans( P, widths, segments, 'linear' );
+
+	}
+
+	if ( basis === 'bspline' ) {
+
+		if ( wrap === 'pinned' ) {
+
+			const index = [ 0, 0, ...Array.from( { length: n }, ( _, i ) => i ), n - 1, n - 1 ];
+			return withIndex( P, widths, index, 'bspline' );
+
+		}
+
+		if ( periodic ) return withIndex( P, widths, [ ...Array.from( { length: n }, ( _, i ) => i ), 0, 1, 2 ], 'bspline' );
+		return n >= 4 ? { P, widths, basis: 'bspline' } : null;
+
+	}
+
+	if ( basis === 'bezier' ) {
+
+		if ( periodic ) return withIndex( P, widths, [ ...Array.from( { length: n }, ( _, i ) => i ), 0 ], 'bezier' );
+		return n >= 4 ? { P, widths, basis: 'bezier' } : null;
+
+	}
+
+	if ( basis === 'catmullRom' ) {
+
+		const segments = [];
+		const at = i => ( periodic ? ( i + n ) % n : Math.min( n - 1, Math.max( 0, i ) ) );
+		const first = periodic || wrap === 'pinned' ? 0 : 1;
+		const last = periodic ? n : wrap === 'pinned' ? n - 1 : n - 2;
+		for ( let i = first; i < last; i ++ ) segments.push( [ at( i ), at( i + 1 ), at( i - 1 ), at( i + 2 ) ] );
+		return segments.length ? bezierSpans( P, widths, segments, 'catmullRom' ) : null;
+
+	}
+
+	return null;
+
+}
+
+function withIndex( P, widths, index, basis ) {
+
+	const out = new Float64Array( index.length * 3 );
+	const w = widths ? new Float64Array( index.length ) : null;
+	index.forEach( ( v, i ) => {
+
+		for ( let k = 0; k < 3; k ++ ) out[ i * 3 + k ] = P[ v * 3 + k ];
+		if ( w ) w[ i ] = widths[ v ];
+
+	} );
+	return { P: out, widths: w, basis };
+
+}
+
+/**
+ * A USD BasisCurves prim's curves (one point array, a count per curve) as one strip mesh. Modes and types are USD's;
+ * the first normal of a curve orients its ribbon.
+ */
+export function tessellateCurves( spec ) {
+
+	const { P, counts, widths = null, widthMode = 'constant', N = null, normalMode = 'vertex', type = 'cubic', basis = 'bspline', wrap = 'nonperiodic' } = spec;
+	const pieces = [];
+	let vertices = 0, indexCount = 0, skipped = 0, start = 0, varying = 0;
+
+	for ( let c = 0; c < counts.length; c ++ ) {
+
+		const n = counts[ c ];
+		const points = P.subarray ? P.subarray( start * 3, ( start + n ) * 3 ) : P.slice( start * 3, ( start + n ) * 3 );
+		let curveWidths = null, width = 1;
+		if ( widths?.length ) {
+
+			if ( widthMode === 'vertex' ) curveWidths = Float64Array.from( { length: n }, ( _, i ) => widths[ start + i ] );
+			else if ( widthMode === 'uniform' ) width = widths[ c ] ?? widths[ 0 ];
+			else if ( widthMode === 'varying' ) {
+
+				const spans = type === 'linear' ? n - 1 : basis === 'bezier' ? ( n - 1 ) / 3 : n - 3;
+				const k = Math.max( 1, Math.round( spans ) + 1 );
+				const values = Array.from( { length: k }, ( _, i ) => widths[ varying + i ] ?? widths[ widths.length - 1 ] );
+				varying += k;
+				curveWidths = Float64Array.from( { length: n }, ( _, i ) => values[ Math.min( k - 1, Math.round( i / Math.max( 1, n - 1 ) * ( k - 1 ) ) ) ] );
+
+			} else width = widths[ 0 ];
+
+		}
+
+		let seed = null;
+		if ( N?.length ) {
+
+			const at = normalMode === 'uniform' ? c : normalMode === 'constant' ? 0 : start;
+			seed = [ N[ at * 3 ], N[ at * 3 + 1 ], N[ at * 3 + 2 ] ];
+
+		}
+
+		const cubic = cubicControls( points, curveWidths, type, basis, wrap );
+		const built = cubic && tessellateCurve( {
+			P: cubic.P, basis: cubic.basis, widths: cubic.widths, width0: width, width1: width, N: seed,
+			steps: spec.steps, sides: spec.sides, tolerance: spec.tolerance,
+		} );
+
+		if ( built ) {
+
+			pieces.push( built );
+			vertices += built.positions.length / 3;
+			indexCount += built.indices.length;
+
+		} else {
+
+			skipped ++;
+
+		}
+
+		start += n;
+
+	}
+
+	if ( pieces.length === 0 ) return null;
+	const positions = new Float32Array( vertices * 3 );
+	const indices = new Uint32Array( indexCount );
+	let v = 0, i = 0;
+	for ( const piece of pieces ) {
+
+		positions.set( piece.positions, v * 3 );
+		for ( let k = 0; k < piece.indices.length; k ++ ) indices[ i + k ] = piece.indices[ k ] + v;
+		v += piece.positions.length / 3;
+		i += piece.indices.length;
+
+	}
+
+	return { positions, indices, skipped };
+
+}

package/src/Processor/PBRT/PBRTMaterials.js

@@ -348,6 +348,9 @@ async function applyConductorColor( mat, params, ctx, prefix, applyAlbedo, setCo
  */
 export async function buildMaterial( def, ctx ) {
 
+	// Built already, by the USD importer.
+	if ( def?.material ) return def.material;
+
 	const type = def?.type || 'diffuse';
 	const params = def?.params || {};
 	const mat = new MeshPhysicalMaterial( { side: DoubleSide, roughness: 1, metalness: 0 } );

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -17,7 +17,7 @@
 import { freeNow, resized } from './buffers.js';
 import {
 	Group, Mesh, InstancedMesh, PerspectiveCamera, OrthographicCamera, Matrix4, Vector3, Quaternion,
-	BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute,
+	BufferGeometry, BufferAttribute, Float32BufferAttribute, Uint32BufferAttribute,
 	DataTexture, FloatType, RGBAFormat, LinearFilter, EquirectangularReflectionMapping,
 	SRGBColorSpace, NoColorSpace, AnimationClip, VectorKeyframeTrack, QuaternionKeyframeTrack,
 	NumberKeyframeTrack, BooleanKeyframeTrack, DirectionalLight, PointLight, SpotLight, FrontSide, DoubleSide,
@@ -27,8 +27,9 @@ import { buildMaterial, pBool, pFloat, pString, resolveSpectrum } from './PBRTMa
 import { makeLayer, layerMean, bake, mixOf, srgbToLinear, linearToSRGB, hasAlpha } from './PBRTTextureBake.js';
 import { loopSubdivide } from './LoopSubdivision.js';
 import { octahedralToEquirect } from './EqualAreaOctahedral.js';
-import { tessellateCurve } from './PBRTCurves.js';
+import { tessellateCurve, tessellateCurves } from './PBRTCurves.js';
 import * as M from './PBRTMath.js';
+import { packUnitAttribute } from '../GeometryExtractor.js';
 
 const LAMP_TYPES = new Set( [ 'distant', 'point', 'spot' ] );
 
@@ -107,7 +108,7 @@ const DEFAULT_CURVE_SIDES = { flat: 1, ribbon: 1, cylinder: 2 };
 const DEFAULT_CURVE_TOLERANCE = 0.05;
 
 /** Bumped whenever the same scene files build a different graph, so a stored graph is not reused. */
-export const PBRT_BUILD_REVISION = 9;
+export const PBRT_BUILD_REVISION = 10;
 
 function samePlacements( a, b ) {
 
@@ -445,7 +446,7 @@ function rasterize( width, height, colorAt ) {
 }
 
 // A clone that keeps the engine's own material properties, which three.js's copy() does not know.
-function cloneMaterial( material ) {
+export function cloneMaterial( material ) {
 
 	const out = material.clone();
 	for ( const key of Object.keys( material ) ) if ( ! ( key in out ) ) out[ key ] = material[ key ];
@@ -617,14 +618,14 @@ export class PBRTSceneBuilder {
 
 			const shape = ir.shapes[ i ];
 			const [ geometry, surface ] = await Promise.all( [
-				this._batches ? this._createGeometry( shape ) : this._buildGeometry( shape ),
+				this._batches && ! shape.shared ? this._createGeometry( shape ) : this._buildGeometry( shape ),
 				this._getMaterial( shape )
 			] );
 			if ( ! geometry ) continue;
 			const sharedMaterial = shape.areaLight ? this._poweredMaterial( shape, geometry, surface ) : surface;
 
 			// A moving shape needs a node of its own to move.
-			if ( this._batches && ! shape.motion && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
+			if ( this._batches && ! shape.motion && ! shape.shared && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
 
 				this._mergeShape( shape, geometry, sharedMaterial, group );
 				ir.shapes[ i ] = null; // its parsed arrays are copied out; let them go
@@ -738,30 +739,45 @@ export class PBRTSceneBuilder {
 
 		const scratch = new Float64Array( 16 );
 		const matrix = new Matrix4();
+		// A template's shapes at the same relative transform share one matrix attribute, which the
+		// engine places as one object: one TLAS entry a copy, not one a shape.
+		const sharedMatrices = new Map();
 
 		const place = ( list, geometry, material, rel, shapeType, materialType, tris ) => {
 
+			const relKey = rel ? Array.prototype.join.call( rel, ',' ) : '';
+			let byRel = sharedMatrices.get( list );
+			if ( ! byRel ) sharedMatrices.set( list, byRel = new Map() );
+			const shared = byRel.get( relKey );
+
 			const affordable = Math.max( 0, this.maxPlacements - this.placementCount );
-			const count = Math.min( list.count, affordable );
-			if ( count < list.count ) this.skippedForBudget += list.count - count;
+			const count = shared ? shared.count : Math.min( list.count, affordable );
+			if ( ! shared && count < list.count ) this.skippedForBudget += list.count - count;
 			if ( count === 0 ) return;
 
 			const mesh = new InstancedMesh( geometry, material, count );
 			mesh.name = `instance_${n ++}`;
 			mesh.frustumCulled = false;
 
-			for ( let i = 0; i < count; i ++ ) {
+			if ( shared ) mesh.instanceMatrix = shared.attribute;
+			else {
+
+				for ( let i = 0; i < count; i ++ ) {
+
+					if ( rel ) M.multiplyInto( scratch, list.matrices, i * 16, rel );
+					else for ( let e = 0; e < 16; e ++ ) scratch[ e ] = list.matrices[ i * 16 + e ];
+					mesh.setMatrixAt( i, matrix.fromArray( this.convertHandedness ? M.multiply( FLIP_Z, scratch ) : scratch ) );
+
+				}
 
-				if ( rel ) M.multiplyInto( scratch, list.matrices, i * 16, rel );
-				else for ( let e = 0; e < 16; e ++ ) scratch[ e ] = list.matrices[ i * 16 + e ];
-				mesh.setMatrixAt( i, matrix.fromArray( this.convertHandedness ? M.multiply( FLIP_Z, scratch ) : scratch ) );
+				mesh.instanceMatrix.needsUpdate = true;
+				byRel.set( relKey, { attribute: mesh.instanceMatrix, count } );
+				this.placementCount += count;
 
 			}
 
-			mesh.instanceMatrix.needsUpdate = true;
 			group.add( mesh );
 
-			this.placementCount += count;
 			this.reportedMeshes += count;
 			if ( this.report.length < MAX_REPORT_ROWS ) this.report.push( {
 				mesh: `${mesh.name} ×${count}`,
@@ -800,7 +816,7 @@ export class PBRTSceneBuilder {
 			// eight Pandanus trees in Moana hold 22,965 leaves each. A .ply may be shared with
 			// other templates and stays whole.
 			let inline = 0;
-			for ( const shape of template ) if ( shape.type !== 'plymesh' ) inline ++;
+			for ( const shape of template ) if ( shape.type !== 'plymesh' && ! shape.shared ) inline ++;
 			const batches = inline >= 2 ? new Map() : null;
 
 			for ( const shape of template ) {
@@ -818,7 +834,7 @@ export class PBRTSceneBuilder {
 				] );
 				if ( ! geometry ) continue;
 
-				if ( batches && shape.type !== 'plymesh' && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
+				if ( batches && shape.type !== 'plymesh' && ! shape.shared && geometry.getAttribute( 'position' ).count <= MERGE_VERTEX_LIMIT ) {
 
 					this._geometryCache.delete( shape );
 					const full = this._appendToBatch( batches, shape, geometry, sharedMaterial, shape.relativeCTM || shape.ctm );
@@ -1253,11 +1269,12 @@ export class PBRTSceneBuilder {
 	/** A batch's triangles as one geometry; the batch's own arrays are released. @private */
 	_batchGeometry( batch ) {
 
+		// The batch's arrays cut to size, not copied: Float32BufferAttribute copies whatever it is given.
 		const geometry = new BufferGeometry();
-		geometry.setAttribute( 'position', new Float32BufferAttribute( resized( batch.positions, batch.vertexCount * 3 ), 3 ) );
-		geometry.setAttribute( 'normal', new Float32BufferAttribute( resized( batch.normals, batch.vertexCount * 3 ), 3 ) );
-		if ( batch.uvs ) geometry.setAttribute( 'uv', new Float32BufferAttribute( resized( batch.uvs, batch.vertexCount * 2 ), 2 ) );
-		geometry.setIndex( new Uint32BufferAttribute( resized( batch.indices, batch.indexCount ), 1 ) );
+		geometry.setAttribute( 'position', new BufferAttribute( resized( batch.positions, batch.vertexCount * 3 ), 3 ) );
+		geometry.setAttribute( 'normal', new BufferAttribute( resized( batch.normals, batch.vertexCount * 3 ), 3 ) );
+		if ( batch.uvs ) geometry.setAttribute( 'uv', new BufferAttribute( resized( batch.uvs, batch.vertexCount * 2 ), 2 ) );
+		geometry.setIndex( new BufferAttribute( resized( batch.indices, batch.indexCount ), 1 ) );
 		batch.positions = batch.normals = batch.uvs = batch.indices = null;
 		return geometry;
 
@@ -1294,9 +1311,11 @@ export class PBRTSceneBuilder {
 
 		// An ObjectInstance template is built once per placement, and the Moana palm debris
 		// alone places one 208-triangle leaf 2.25 million times. three.js is happy to share
-		// one BufferGeometry across meshes; only the per-mesh matrix differs.
-		let pending = this._geometryCache.get( shape );
-		if ( ! pending ) this._geometryCache.set( shape, pending = this._createGeometry( shape ) );
+		// one BufferGeometry across meshes; only the per-mesh matrix differs. Shapes of one
+		// `geometryKey` (a USD mesh read again elsewhere) share it the same way.
+		const key = shape.geometryKey ?? shape;
+		let pending = this._geometryCache.get( key );
+		if ( ! pending ) this._geometryCache.set( key, pending = this._createGeometry( shape ) );
 		return pending;
 
 	}
@@ -1361,6 +1380,7 @@ export class PBRTSceneBuilder {
 			case 'bilinearmesh': return this._bilinearMesh( shape.params );
 			case 'loopsubdiv': return this._loopSubdiv( shape.params );
 			case 'curve': return this._curve( shape.params );
+			case 'curves': return this._curves( shape.params );
 			case 'plymesh': return this._plyMesh( shape.params );
 			case 'sphere': return this._sphere( shape.params );
 			case 'disk': return this._disk( shape.params );
@@ -1439,10 +1459,47 @@ export class PBRTSceneBuilder {
 
 		}
 
+		// The tessellation's own arrays, not copies; normals at 16 bits from the start, as extraction would store them.
+		const geo = new BufferGeometry();
+		geo.setAttribute( 'position', new BufferAttribute( built.positions, 3 ) );
+		geo.setIndex( new BufferAttribute( built.indices, 1 ) );
+		geo.computeVertexNormals();
+		packUnitAttribute( geo, 'normal' );
+		return geo;
+
+	}
+
+	/** Many curves on one point array, as USD writes them. */
+	_curves( params ) {
+
+		const built = tessellateCurves( {
+			P: params.P.value,
+			counts: params.counts.value,
+			widths: params.widths?.value ?? null,
+			widthMode: pString( params, 'widthMode', 'constant' ),
+			N: params.N?.value ?? null,
+			normalMode: pString( params, 'normalMode', 'vertex' ),
+			type: pString( params, 'type', 'cubic' ),
+			basis: pString( params, 'basis', 'bspline' ),
+			wrap: pString( params, 'wrap', 'nonperiodic' ),
+			steps: this.curveSteps,
+			sides: this.curveSides ?? 1,
+			tolerance: this.curveTolerance,
+		} );
+
+		if ( ! built ) {
+
+			this.warn( 'curves could not be tessellated' ); return null;
+
+		}
+
+		if ( built.skipped > 0 ) this.warn( `${built.skipped} curve(s) of an unsupported basis or too few points skipped` );
+		// The tessellation's own arrays, not copies; normals at 16 bits from the start, as extraction would store them.
 		const geo = new BufferGeometry();
-		geo.setAttribute( 'position', new Float32BufferAttribute( built.positions, 3 ) );
-		geo.setIndex( new Uint32BufferAttribute( built.indices, 1 ) );
+		geo.setAttribute( 'position', new BufferAttribute( built.positions, 3 ) );
+		geo.setIndex( new BufferAttribute( built.indices, 1 ) );
 		geo.computeVertexNormals();
+		packUnitAttribute( geo, 'normal' );
 		return geo;
 
 	}

package/src/Processor/PackedRayBuffer.js

@@ -57,6 +57,8 @@ export const LIGHT_VERTEX_STRIDE = 4;
 // SoA region stride, baked into the shader graph at build time; single instance, rebuilt on resize.
 let _cap = 0;
 let _lightVertexBase = 0;
+// The G-buffer is the hit buffer's last region, one uvec4 a path: in a buffer of its own it took Shade's tenth binding.
+let _gBufferBase = 0;
 
 const soa = ( id, slot ) => ( slot === 0 ? id : id.add( slot * _cap ) );
 
@@ -104,6 +106,7 @@ export class PackedRayBuffer {
 		_cap = capacity;
 		const hitSlots = lightVertices > 0 ? HIT_STRIDE_BIDIRECTIONAL : HIT_STRIDE;
 		_lightVertexBase = capacity * hitSlots;
+		_gBufferBase = _lightVertexBase + lightVertices * LIGHT_VERTEX_STRIDE;
 
 		// count=0 so StorageBufferNode.getHash() shares the buffer → RW and RO nodes bind the same GPU data.
 		const rayCount = capacity * RAY_STRIDE;
@@ -114,7 +117,7 @@ export class PackedRayBuffer {
 			ro: storage( rayAttr, 'vec4' ).toReadOnly(),
 		};
 
-		const hitCount = capacity * hitSlots + lightVertices * LIGHT_VERTEX_STRIDE;
+		const hitCount = _gBufferBase + capacity * GBUFFER_STRIDE;
 		const hitAttr = gpuOnlyStorageAttribute( hitCount, 4, Uint32Array );
 		this._attrs.hit = hitAttr;
 		this.hitBuffer = {
@@ -178,7 +181,7 @@ export const readRayRadiance = ( buf, id ) =>
 // normal: raw unit vec3; depth: linear [0,1]; albedo: vec3 [0,1]. Packed values live in u32 lanes
 // verbatim (no f32 bitcast) so NaN-range bit patterns (snorm ±1 → 0x7FFF) survive store/load intact.
 // One uvec4 per pixel (stride 1); AoS base = pixelIndex * GBUFFER_STRIDE.
-const gbLane = ( pixelIndex ) => uint( pixelIndex ).mul( GBUFFER_STRIDE );
+const gbLane = ( pixelIndex ) => uint( pixelIndex ).mul( GBUFFER_STRIDE ).add( _gBufferBase );
 
 // hitDist = null keeps the lane's current normHitDist.
 export const writeGBuffer = ( buf, pixelIndex, normal, depth, albedo, hitDist = null ) => {