@gnsx/three 0.185.16 → 0.186.0

package/examples/jsm/generators/TerrainGenerator.js

@@ -1,6 +1,6 @@
 import {
+	BufferAttribute,
 	BufferGeometry,
-	Float32BufferAttribute,
 	Group,
 	Mesh
 } from '@gnsx/three';
@@ -11,22 +11,12 @@ import { cameraPosition, color, float, Fn, If, mix, mx_noise_float, normalView,
 import { ImprovedNoise } from '../math/ImprovedNoise.js';
 
 /**
- * Bakes a procedural mountain range into a single {@link THREE.BufferGeometry} and
- * returns a `THREE.Group` ready to add to a scene.
+ * Bakes a procedural mountain range into a single mesh, returned in a `THREE.Group`.
+ * Domain-warped, derivative-damped noise shapes the ridges; thermal erosion relaxes
+ * steep slopes. A TSL material shades grass, rock and snow from altitude and slope.
  *
- * The heightfield is a derivative-damped fractal sum ( Quilez's fake erosion ): each
- * octave is suppressed where the running slope is already steep, concentrating detail
- * into weathered ridgelines, and a low-frequency domain warp makes those ridges
- * meander. A few passes of thermal ( talus ) erosion then relax any slope past the
- * angle of repose, settling the fractal's needle-spikes into real crests.
- *
- * The grid is triangulated with alternating quad diagonals ( a diamond pattern ), so a
- * coarse mesh holds its silhouette without a one-way grain. The surface shades itself
- * from altitude and slope in TSL — grass, forest, rock, scree and snow, with detail
- * normals and aerial perspective — so no material or textures are needed.
- *
- * The baked height grid is exposed through {@link TerrainGenerator#sampleHeight} so a
- * scattered forest ( or anything else ) can sit exactly on the surface.
+ * The baked grid is available through {@link TerrainGenerator#sampleHeight} for
+ * placing a forest or other objects on the terrain.
  *
  * ```js
  * const terrain = new TerrainGenerator( { seed: 1 } );
@@ -82,6 +72,8 @@ class TerrainGenerator {
 
 		// lay the grid out flat in the XZ plane ( Y-up ) and find the height range
 		const positions = new Float32Array( N * N * 3 );
+		const normals = new Float32Array( N * N * 3 );
+		const cellSize = p.size / p.segments;
 		let min = Infinity, max = - Infinity;
 
 		for ( let iz = 0; iz < N; iz ++ ) {
@@ -95,6 +87,16 @@ class TerrainGenerator {
 				positions[ o * 3 + 1 ] = y;
 				positions[ o * 3 + 2 ] = coord[ iz ];
 
+				// Sample the grid's gradient so alternating triangle fans have equal weight.
+				const left = Math.max( 0, ix - 1 ), right = Math.min( N - 1, ix + 1 );
+				const back = Math.max( 0, iz - 1 ), front = Math.min( N - 1, iz + 1 );
+				const nx = ( heights[ iz * N + left ] - heights[ iz * N + right ] ) / ( ( right - left ) * cellSize );
+				const nz = ( heights[ back * N + ix ] - heights[ front * N + ix ] ) / ( ( front - back ) * cellSize );
+				const length = Math.hypot( nx, 1, nz );
+				normals[ o * 3 ] = nx / length;
+				normals[ o * 3 + 1 ] = 1 / length;
+				normals[ o * 3 + 2 ] = nz / length;
+
 				if ( y < min ) min = y;
 				if ( y > max ) max = y;
 
@@ -104,25 +106,32 @@ class TerrainGenerator {
 
 		// flip the quad diagonal on every other quad, so the mesh reads as diamonds
 		// rather than a one-way grain
-		const indices = [];
+		const IndexArray = N * N > 65535 ? Uint32Array : Uint16Array;
+		const indices = new IndexArray( p.segments * p.segments * 6 );
+		let index = 0;
 
 		for ( let iz = 0; iz < p.segments; iz ++ ) {
 
 			for ( let ix = 0; ix < p.segments; ix ++ ) {
 
 				const a = iz * N + ix, b = a + 1, c = a + N, d = c + 1;
+				const even = ( ix + iz ) % 2 === 0;
 
-				if ( ( ix + iz ) % 2 === 0 ) indices.push( a, c, b, b, c, d );
-				else indices.push( a, c, d, a, d, b );
+				indices[ index ++ ] = a;
+				indices[ index ++ ] = c;
+				indices[ index ++ ] = even ? b : d;
+				indices[ index ++ ] = even ? b : a;
+				indices[ index ++ ] = even ? c : d;
+				indices[ index ++ ] = even ? d : b;
 
 			}
 
 		}
 
 		const geometry = new BufferGeometry();
-		geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
-		geometry.setIndex( indices );
-		geometry.computeVertexNormals();
+		geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+		geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+		geometry.setIndex( new BufferAttribute( indices, 1 ) );
 
 		this.heights = heights;
 		this.gridSize = N;
@@ -384,7 +393,7 @@ function thermalErode( h, N, cellSize, talus, passes ) {
 // method. the built-in bumpMap reads height by offsetting the UV — a no-op for a
 // world-keyed height — so the height's screen-space derivatives are fed in directly.
 // returns a view-space normal.
-function bumpNormal( height ) {
+function bumpNormal( height, strength ) {
 
 	const dpdx = positionView.dFdx();
 	const dpdy = positionView.dFdy();
@@ -393,7 +402,7 @@ function bumpNormal( height ) {
 	const det = dpdx.dot( r1 );
 	const grad = det.sign().mul( height.dFdx().mul( r1 ).add( height.dFdy().mul( r2 ) ) );
 
-	return det.abs().mul( normalView ).sub( grad ).normalize();
+	return det.abs().mul( normalView ).sub( grad.mul( strength ) ).normalize();
 
 }
 
@@ -420,7 +429,7 @@ function terrainMaterial( minHeight, maxHeight ) {
 	const grass = color( 0x6e7253 ); // dry sage-olive meadow ( not video-game green )
 	const dryGrass = color( 0x8a8550 );
 	const forest = color( 0x39402f ); // dark forested mid-slope band, under the trees
-	const rock = color( 0x736a5f ); // warm grey-brown rock
+	const rock = color( 0x716e68 ); // weathered grey-brown rock
 	const scree = color( 0x837a6f ); // brighter broken rock below the cliffs
 	const lichen = color( 0x6c7355 ); // muted green-grey, patched onto lower rock
 	const snow = color( 0xe9ecf0 ); // fresh snow; warm-sun / cool-sky cast is from the lighting
@@ -428,13 +437,13 @@ function terrainMaterial( minHeight, maxHeight ) {
 
 	// two band frequencies of lighter / darker stone, wobbled by noise, so cliff faces
 	// read as layered bedding instead of flat grey
-	const bandA = positionWorld.y.mul( 0.5 ).add( detail.mul( 3 ) ).add( macro.mul( 4 ) ).sin();
+	const bandA = positionWorld.y.mul( 0.5 ).add( positionWorld.x.mul( 0.08 ) ).add( positionWorld.z.mul( 0.05 ) ).add( detail.mul( 3 ) ).add( macro.mul( 4 ) ).sin();
 	const bandB = positionWorld.y.mul( 1.4 ).add( grain.mul( 2 ) ).sin();
 	const strata = bandA.mul( 0.6 ).add( bandB.mul( 0.4 ) ).mul( 0.5 ).add( 0.5 );
 
 	// lichen creeps onto the lower, gentler rock; cliffs and high ground stay bare grey
 	const lichenMask = smoothstep( 0.45, 0.72, grain ).mul( smoothstep( 0.62, 0.32, steep ) ).mul( smoothstep( 0.66, 0.34, altitude ) );
-	const rockShade = mix( rock, lichen, lichenMask.mul( 0.45 ) ).mul( strata.mul( 0.36 ).add( 0.8 ) );
+	const rockShade = mix( rock, lichen, lichenMask.mul( 0.45 ) ).mul( strata.mul( 0.36 ).add( 0.8 ) ).mul( grain.mul( 0.18 ).add( 1 ) );
 
 	// meadow, drifting to dry grass in macro-noise patches over a mid band
 	let surface = mix( grass, dryGrass, smoothstep( 0.15, 0.75, macro ).mul( smoothstep( 0.22, 0.5, altitude ) ) );
@@ -452,7 +461,7 @@ function terrainMaterial( minHeight, maxHeight ) {
 
 	// snow on high, flat ground; the grain noise breaks the line so rock pokes through
 	// near the snowline instead of stopping on a clean contour
-	const snowMask = smoothstep( 0.56, 0.78, altitude.add( detail.mul( 0.08 ) ).add( grain.mul( 0.05 ) ) ).mul( smoothstep( 0.3, 0.6, flatness ) );
+	const snowMask = smoothstep( 0.56, 0.78, altitude.add( detail.mul( 0.08 ) ).add( grain.mul( 0.05 ) ) ).mul( smoothstep( 0.45, 0.75, flatness ) );
 	const snowColor = mix( snow, snowDeep, smoothstep( 0.2, 0.7, grain ).mul( 0.6 ) ); // patchy, not a flat sheet
 	surface = mix( surface, snowColor, snowMask );
 
@@ -473,21 +482,23 @@ function terrainMaterial( minHeight, maxHeight ) {
 	material.colorNode = surface;
 	material.roughnessNode = mix( float( 0.95 ), float( 0.72 ), snowMask );
 
-	// detail normals: three octaves of world-space relief, faded out with distance so
-	// they can't alias into fireflies in the haze. gating the noise behind the fade ( a
-	// real branch ) lets the far majority of this fragment-bound terrain skip the taps.
+	// Volumetric noise keeps relief consistent on cliffs. Skip fine grain in the distance.
 	const detailFade = smoothstep( 420, 60, distance );
-	const reliefStrength = mix( float( 0.25 ), float( 0.55 ), steep ); // more on rock, less on grass
+	const grainFade = smoothstep( 180, 40, distance );
+	const reliefStrength = mix( mix( float( 0.25 ), float( 0.55 ), steep ), float( 0.04 ), snowMask );
 	const relief = Fn( () => {
 
 		const r = float( 0 ).toVar();
 
 		If( detailFade.greaterThan( 0.01 ), () => {
 
-			r.assign( mx_noise_float( positionWorld.xz.mul( 0.6 ) )
-				.add( mx_noise_float( positionWorld.xz.mul( 1.7 ) ).mul( 0.5 ) )
-				.add( mx_noise_float( positionWorld.xz.mul( 4.0 ) ).mul( 0.25 ) )
-				.mul( reliefStrength ).mul( detailFade ).mul( 0.25 ) );
+			r.assign( mx_noise_float( positionWorld.mul( 0.6 ) ) );
+
+			If( grainFade.greaterThan( 0.01 ), () => {
+
+				r.addAssign( mx_noise_float( positionWorld.mul( 1.7 ) ).mul( 0.5 ).mul( grainFade ) );
+
+			} );
 
 		} );
 
@@ -495,7 +506,8 @@ function terrainMaterial( minHeight, maxHeight ) {
 
 	} )();
 
-	material.normalNode = bumpNormal( relief );
+	// Apply strength after differentiating the noise; slope derivatives reveal triangles.
+	material.normalNode = bumpNormal( relief, reliefStrength.mul( detailFade ).mul( 0.25 ) );
 
 	return material;
 

package/examples/jsm/generators/TreeGenerator.js

@@ -17,12 +17,9 @@ const TAU = Math.PI * 2;
 const UP = /*@__PURE__*/ new Vector3( 0, 1, 0 );
 const _axis = /*@__PURE__*/ new Vector3();
 
-// reusable scratch for one tube's ring vertices ( grows to the largest tube seen )
-let _ring = new Float32Array( 0 );
-
 /**
  * Grows a procedural tree skeleton — trunk, branches and twigs, each swept as a tapered
- * tube — and bakes it into one non-indexed {@link BufferGeometry} (position and normal
+ * tube — and bakes it into one indexed {@link BufferGeometry} (position and normal
  * only), ready to instance into a forest. It produces *branches only*; add foliage as a
  * separate layer.
  *
@@ -58,26 +55,10 @@ class TreeGenerator {
 		const p = Object.assign( {}, TreeGenerator.defaults, this.parameters );
 		const random = createRandom( p.seed );
 
-		// grow the skeleton into a flat list of tubes, then size and fill the geometry in
-		// one pass — no per-vertex objects, no array growth
-
 		const tubes = [];
 		growBranch( tubes, new Vector3(), UP, p.trunkLength, p.trunkRadius, 0, p, random );
 
-		let vertexCount = 0;
-		for ( const tube of tubes ) vertexCount += ( tube.rings.length - 1 ) * tube.radial * 6;
-
-		const positions = new Float32Array( vertexCount * 3 );
-		const normals = new Float32Array( vertexCount * 3 );
-
-		let offset = 0;
-		for ( const tube of tubes ) offset = emitTube( positions, normals, offset, tube.rings, tube.radial );
-
-		const geometry = new BufferGeometry();
-		geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
-		geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
-		geometry.computeBoundingSphere();
-
+		const geometry = createGeometry( tubes );
 		const mesh = new Mesh( geometry, this.material || createTreeMaterial() );
 		mesh.name = 'Tree';
 
@@ -94,6 +75,8 @@ TreeGenerator.defaults = {
 	branchAngle: [ 38, 50, 58 ], // degrees a child tilts off its parent axis, per level
 	angleVariance: 14, // degrees of random jitter on the branch angle, breaks fractal regularity
 	lengthRatio: 0.62, // child length / parent length
+	lengthVariance: 0, // fractional variation in child length
+	branchLengthFalloff: 0, // shorten children toward the tip of their parent
 	trunkLength: 9, // trunk length in world units; sets the tree's height
 	trunkRadius: 0.42, // base radius of the trunk
 	taper: 0.55, // a branch thins to ( 1 - taper ) of its base radius along its own length
@@ -162,7 +145,6 @@ function growBranch( tubes, base, dir, length, baseRadius, level, p, random ) {
 			pos: pos.clone(),
 			tangent: tangent.clone(),
 			normal: normal.clone(),
-			binormal: new Vector3().crossVectors( tangent, normal ),
 			radius
 		} );
 
@@ -212,7 +194,10 @@ function growBranch( tubes, base, dir, length, baseRadius, level, p, random ) {
 		// the pipe-model drop, but never fatter than the wood it leaves nor below the floor
 		const childBase = Math.max( p.minRadius, Math.min( baseRadius * pipeDrop, ring.radius ) );
 
-		growBranch( tubes, ring.pos, childDir, length * p.lengthRatio, childBase, level + 1, p, random );
+		let childLength = length * p.lengthRatio * ( 1 - p.branchLengthFalloff * t );
+		if ( p.lengthVariance > 0 ) childLength *= 1 + ( random() * 2 - 1 ) * p.lengthVariance;
+
+		growBranch( tubes, ring.pos, childDir, childLength, childBase, level + 1, p, random );
 
 	}
 
@@ -244,7 +229,7 @@ function ringAt( rings, t ) {
 	const i = Math.floor( f );
 	const frac = f - i;
 	const a = rings[ i ];
-	const b = rings[ Math.min( i + 1, rings.length - 1 ) ];
+	const b = rings[ i + 1 ];
 
 	return {
 		pos: a.pos.clone().lerp( b.pos, frac ),
@@ -257,79 +242,87 @@ function ringAt( rings, t ) {
 
 // --- geometry ------------------------------------------------------------
 
-// Sweeps a tube through the rings: each ring is a loop of `radial` vertices in its
-// ( normal, binormal ) plane, the outward radial direction being the vertex normal.
-// Ring vertices are computed once into a reused scratch, then stitched straight into the
-// preallocated geometry arrays — no per-vertex objects.
-function emitTube( positions, normals, offset, rings, radial ) {
+// Write each ring vertex once, then join adjacent rings with indexed triangles.
+function createGeometry( tubes ) {
 
-	const stride = ( radial + 1 ) * 6; // one ring loop: ( position, normal ) per vertex
-	const needed = rings.length * stride;
-	if ( _ring.length < needed ) _ring = new Float32Array( needed );
+	let vertexCount = 0;
+	let indexCount = 0;
 
-	const ring = _ring;
+	for ( const { rings, radial } of tubes ) {
 
-	for ( let r = 0; r < rings.length; r ++ ) {
+		vertexCount += rings.length * radial;
+		indexCount += ( rings.length - 1 ) * radial * 6;
 
-		const { pos, normal, binormal, radius } = rings[ r ];
-		let o = r * stride;
+	}
 
-		for ( let j = 0; j <= radial; j ++ ) {
+	const positions = new Float32Array( vertexCount * 3 );
+	const normals = new Float32Array( vertexCount * 3 );
+	const indices = new ( vertexCount > 65535 ? Uint32Array : Uint16Array )( indexCount );
+	const binormal = new Vector3();
 
-			const a = j / radial * TAU;
-			const c = Math.cos( a );
-			const s = Math.sin( a );
-			const nx = c * normal.x + s * binormal.x;
-			const ny = c * normal.y + s * binormal.y;
-			const nz = c * normal.z + s * binormal.z;
+	let vertexOffset = 0;
+	let indexOffset = 0;
 
-			ring[ o ++ ] = pos.x + nx * radius;
-			ring[ o ++ ] = pos.y + ny * radius;
-			ring[ o ++ ] = pos.z + nz * radius;
-			ring[ o ++ ] = nx;
-			ring[ o ++ ] = ny;
-			ring[ o ++ ] = nz;
+	for ( const { rings, radial } of tubes ) {
 
-		}
+		let offset = vertexOffset * 3;
 
-	}
+		for ( const { pos, tangent, normal, radius } of rings ) {
 
-	// stitch consecutive rings into quads ( two triangles ), wound so normals face out
+			binormal.crossVectors( tangent, normal );
 
-	for ( let r = 0; r < rings.length - 1; r ++ ) {
+			for ( let j = 0; j < radial; j ++ ) {
 
-		const a = r * stride;
-		const b = ( r + 1 ) * stride;
+				const angle = j / radial * TAU;
+				const c = Math.cos( angle );
+				const s = Math.sin( angle );
+				const nx = c * normal.x + s * binormal.x;
+				const ny = c * normal.y + s * binormal.y;
+				const nz = c * normal.z + s * binormal.z;
 
-		for ( let j = 0; j < radial; j ++ ) {
+				positions[ offset ] = pos.x + nx * radius;
+				positions[ offset + 1 ] = pos.y + ny * radius;
+				positions[ offset + 2 ] = pos.z + nz * radius;
+				normals[ offset ] = nx;
+				normals[ offset + 1 ] = ny;
+				normals[ offset + 2 ] = nz;
+				offset += 3;
 
-			const aL = a + j * 6, aR = a + ( j + 1 ) * 6;
-			const bL = b + j * 6, bR = b + ( j + 1 ) * 6;
+			}
 
-			offset = copyVertex( positions, normals, offset, ring, aL );
-			offset = copyVertex( positions, normals, offset, ring, bR );
-			offset = copyVertex( positions, normals, offset, ring, bL );
+		}
 
-			offset = copyVertex( positions, normals, offset, ring, aL );
-			offset = copyVertex( positions, normals, offset, ring, aR );
-			offset = copyVertex( positions, normals, offset, ring, bR );
+		for ( let r = 0; r < rings.length - 1; r ++ ) {
 
-		}
+			const a = vertexOffset + r * radial;
+			const b = a + radial;
 
-	}
+			for ( let j = 0; j < radial; j ++ ) {
 
-	return offset;
+				const next = ( j + 1 ) % radial; // wrap the seam back to the first vertex
 
-}
+				indices[ indexOffset ++ ] = a + j;
+				indices[ indexOffset ++ ] = b + next;
+				indices[ indexOffset ++ ] = b + j;
+				indices[ indexOffset ++ ] = a + j;
+				indices[ indexOffset ++ ] = a + next;
+				indices[ indexOffset ++ ] = b + next;
+
+			}
 
-// copies one ( position, normal ) vertex from the ring scratch into the geometry arrays
-function copyVertex( positions, normals, offset, ring, i ) {
+		}
+
+		vertexOffset += rings.length * radial;
+
+	}
 
-	const o = offset * 3;
-	positions[ o ] = ring[ i ]; positions[ o + 1 ] = ring[ i + 1 ]; positions[ o + 2 ] = ring[ i + 2 ];
-	normals[ o ] = ring[ i + 3 ]; normals[ o + 1 ] = ring[ i + 4 ]; normals[ o + 2 ] = ring[ i + 5 ];
+	const geometry = new BufferGeometry();
+	geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+	geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+	geometry.setIndex( new BufferAttribute( indices, 1 ) );
+	geometry.computeBoundingSphere();
 
-	return offset + 1;
+	return geometry;
 
 }
 
@@ -356,7 +349,7 @@ function createRandom( seed ) {
  * A simple bark material for a {@link TreeGenerator} mesh: a low-saturation brown with a
  * faint, vertically-stretched grain, so trunks read near-black against bright fog.
  *
- * @param {Object} [parameters] - `barkColor` ( a hex, THREE.Color or TSL node ).
+ * @param {Object} [parameters] - `barkColor` ( a hex, THREE.Color or TSL node ) and `barkScale` ( a THREE.Vector3 ).
  * @return {MeshStandardNodeMaterial}
  */
 function createTreeMaterial( parameters = {} ) {
@@ -365,7 +358,8 @@ function createTreeMaterial( parameters = {} ) {
 	const barkColor = c === undefined ? color( 0x4b3a2b ) : ( c.isColor || typeof c === 'number' ? color( c ) : c );
 
 	const material = new MeshStandardNodeMaterial();
-	const grain = mx_fractal_noise_float( positionLocal.mul( vec3( 2.5, 0.4, 2.5 ) ), 3 ).mul( 0.18 );
+	const barkScale = parameters.barkScale ? vec3( parameters.barkScale ) : vec3( 2.5, 0.4, 2.5 );
+	const grain = mx_fractal_noise_float( positionLocal.mul( barkScale ), 3 ).mul( 0.18 );
 	material.colorNode = barkColor.mul( grain.add( 0.9 ) );
 	material.roughnessNode = float( 0.95 );
 	material.metalnessNode = float( 0 );

package/examples/jsm/generators/city/BenchGenerator.js

@@ -0,0 +1,127 @@
+import {
+	BoxGeometry,
+	InterpolationSamplingMode,
+	InterpolationSamplingType
+} from '@gnsx/three';
+
+import { MeshStandardNodeMaterial } from '@gnsx/three/webgpu';
+import { attribute, color, float, floor, fract, mix, mx_fractal_noise_float, positionGeometry, select, sin, varying, vec3 } from '@gnsx/three/tsl';
+
+import { mergeGeometries } from '../../utils/BufferGeometryUtils.js';
+
+import { InstancedMeshGenerator } from './InstancedMeshGenerator.js';
+import { part } from './CityGeneratorUtils.js';
+
+/**
+ * A public street bench: timber slats carried on two cast-iron end frames that
+ * curl into armrests, with a reclined slatted backrest. Built once and instanced
+ * across a list of placements, dressed with one cheap material that branches on a
+ * baked `partId` ( warm stained wood, dark iron ).
+ *
+ * The canonical model stands on `y = 0`, centred in X / Z, runs along X and seats
+ * toward `+Z`, so a placement whose local `+Z` faces the road sits a passer-by
+ * looking out over it.
+ *
+ * ```js
+ * const benches = new BenchGenerator();
+ * scene.add( benches.build( placements ) ); // placements: Matrix4[]
+ * ```
+ */
+class BenchGenerator extends InstancedMeshGenerator {
+
+	constructor( parameters = {} ) {
+
+		super( parameters, buildBenchGeometry, createBenchMaterial, 'Benches' );
+
+	}
+
+}
+
+BenchGenerator.defaults = {
+	length: 1.8, // spans X
+	depth: 0.55, // front-to-back
+	seatHeight: 0.45,
+	backHeight: 0.85
+};
+
+// material-zone codes baked per vertex
+const WOOD = 0, IRON = 1;
+
+function buildBenchGeometry( p ) {
+
+	const halfLength = p.length / 2;
+	const halfDepth = p.depth / 2;
+	const seatY = p.seatHeight;
+	const backY = p.backHeight;
+
+	const frontZ = halfDepth - 0.075; // legs set just inside the depth
+	const backZ = - frontZ;
+
+	const parts = [];
+
+	// two cast-iron end frames brace the slats and curl into armrests
+	for ( const side of [ - 1, 1 ] ) {
+
+		const x = side * ( halfLength - 0.07 );
+
+		const frontLeg = new BoxGeometry( 0.05, seatY, 0.06 ).translate( x, seatY / 2, frontZ );
+		const backLeg = new BoxGeometry( 0.05, backY, 0.06 ).translate( x, backY / 2, backZ ); // doubles as the backrest post
+		const seatRail = new BoxGeometry( 0.06, 0.05, frontZ - backZ + 0.1 ).translate( x, seatY - 0.04, 0 );
+		const armPost = new BoxGeometry( 0.05, 0.22, 0.05 ).translate( x, seatY + 0.11, frontZ );
+		const armRest = new BoxGeometry( 0.05, 0.05, frontZ - backZ + 0.06 ).translate( x, seatY + 0.22, 0 );
+		const armCurl = new BoxGeometry( 0.05, 0.16, 0.05 ).rotateX( - 0.6 ).translate( x, seatY + 0.18, frontZ + 0.07 ); // front scroll of the armrest
+
+		parts.push( part( frontLeg, IRON ), part( backLeg, IRON ), part( seatRail, IRON ), part( armPost, IRON ), part( armRest, IRON ), part( armCurl, IRON ) );
+
+	}
+
+	// timber seat slats spaced front-to-back
+	const slatLength = p.length - 0.1;
+	const z0 = backZ + 0.02, z1 = frontZ - 0.02;
+	for ( let i = 0; i < 5; i ++ ) {
+
+		const z = z0 + ( z1 - z0 ) * ( i / 4 );
+		parts.push( part( new BoxGeometry( slatLength, 0.03, 0.07 ).translate( 0, seatY, z ), WOOD ) );
+
+	}
+
+	// backrest slats climb the rear posts, reclined a touch
+	for ( let i = 0; i < 3; i ++ ) {
+
+		const t = i / 2;
+		const y = seatY + 0.13 + t * 0.27;
+		const z = backZ + 0.01 - t * 0.06;
+		parts.push( part( new BoxGeometry( slatLength, 0.09, 0.025 ).rotateX( 0.18 ).translate( 0, y, z ), WOOD ) );
+
+	}
+
+	return mergeGeometries( parts );
+
+}
+
+function createBenchMaterial() {
+
+	const partId = varying( attribute( 'partId', 'float' ) ).setInterpolation( InterpolationSamplingType.FLAT, InterpolationSamplingMode.EITHER );
+	const isWood = partId.equal( WOOD );
+
+	const p = positionGeometry;
+
+	// timber: grain streaks stretched along the slats, each slat cut from its own
+	// board ( a tone hashed from the slat's row position ) and greyed by weathering
+	const grain = mx_fractal_noise_float( p.mul( vec3( 3, 60, 60 ) ), 2 ).mul( 0.5 ).add( 0.5 );
+	const board = fract( sin( floor( p.z.mul( 10.5 ) ).add( floor( p.y.mul( 8.0 ) ).mul( 7.3 ) ).mul( 17.53 ) ).mul( 43758.5453 ) );
+	const weather = mx_fractal_noise_float( p.mul( 1.6 ), 2 ).mul( 0.5 ).add( 0.5 );
+
+	const stained = mix( color( 0x5e412a ), color( 0x8a6242 ), grain.mul( 0.7 ).add( board.mul( 0.3 ) ) );
+	const wood = mix( stained, color( 0x7c7468 ), weather.mul( 0.45 ) ); // sun-bleached grey where the stain has worn
+
+	const material = new MeshStandardNodeMaterial();
+	material.colorNode = select( isWood, wood, color( 0x232322 ) ); // weathered timber, dark cast iron
+	material.roughnessNode = select( isWood, grain.mul( 0.25 ).add( 0.65 ), float( 0.5 ) );
+	material.metalnessNode = select( isWood, float( 0 ), float( 0.6 ) );
+
+	return material;
+
+}
+
+export { BenchGenerator };