super-three 0.181.0 → 0.185.0

package/examples/jsm/tsl/utils/SpecularHelpers.js

@@ -0,0 +1,325 @@
+import { Fn, If, PI, clamp, cos, cross, dot, equirectUV, float, log, max, mix, normalize, pow, reflect, sin, sqrt, struct, vec3 } from 'three/tsl';
+
+/**
+ * Specular / microfacet BRDF helpers: VNDF sampling, GTR distribution, Smith geometry,
+ * Fresnel, reflection importance sampling, parallax-corrected ray-length terms, and
+ * equirectangular environment sampling / MIS helpers.
+ * Pure TSL functions of their inputs (no scene/camera state).
+ */
+
+/**
+ * Sentinel ray length the SSR pass writes for environment misses (no screen-space hit), set far above
+ * any real hit distance so a single magnitude test separates misses from hits and survives `.max( 0 )`.
+ *
+ * @type {number}
+ */
+export const ENV_RAY_LENGTH = 1e4;
+
+/**
+ * Classification threshold for {@link ENV_RAY_LENGTH}: above this is an env miss, below a real hit.
+ * An order of magnitude under the sentinel, robust to fp16 storage and bilinear blending at borders.
+ *
+ * @type {number}
+ */
+export const ENV_RAY_LENGTH_THRESHOLD = 1e3;
+
+// Bounded-VNDF sampler (Eto & Tokuyoshi 2023; spherical-cap form, Dupuy & Benyoub 2023)
+const SampleGGXVNDF = Fn( ( [ V, ax, ay, r1, r2 ] ) => {
+
+	// Warp the view direction to the hemisphere ("standard") configuration.
+	const wiStd = normalize( vec3( ax.mul( V.x ), ay.mul( V.y ), V.z ) ).toVar();
+
+	// Isotropic bound on the spherical cap (Eto & Tokuyoshi eq. 5). alpha ∈ [0,1] here,
+	// so the sign term in `s` is always +1 and is dropped.
+	const a = ax.min( ay ).toVar();
+	const s = float( 1.0 ).add( V.xy.length() ).toVar();
+	const a2 = a.mul( a ).toVar();
+	const s2 = s.mul( s ).toVar();
+	const k = a2.oneMinus().mul( s2 ).div( s2.add( a2.mul( V.z ).mul( V.z ) ) ).toVar();
+
+	// Tighten the cap with the bound (upper hemisphere; N·V ≥ 0 in our usage).
+	const b = wiStd.z.mul( k ).toVar();
+
+	// Sample the (bounded) spherical cap.
+	const phi = float( 6.283185307179586 ).mul( r1 ).toVar(); // 2*pi
+	const z = r2.oneMinus().mul( float( 1.0 ).add( b ) ).sub( b ).toVar();
+	const sinTheta = sqrt( max( float( 0.0 ), float( 1.0 ).sub( z.mul( z ) ) ) ).toVar();
+	const c = vec3( sinTheta.mul( cos( phi ) ), sinTheta.mul( sin( phi ) ), z ).toVar();
+
+	// Microfacet normal in the standard config, then warp back to the ellipsoid (unstretch).
+	const wmStd = c.add( wiStd ).toVar();
+	const Ne = normalize( vec3(
+		ax.mul( wmStd.x ),
+		ay.mul( wmStd.y ),
+		max( float( 0.0 ), wmStd.z )
+	) ).toVar();
+
+	return Ne;
+
+}, {
+	name: 'SampleGGXVNDF',
+	type: 'vec3',
+	inputs: [
+		{ name: 'V', type: 'vec3' },
+		{ name: 'ax', type: 'float' },
+		{ name: 'ay', type: 'float' },
+		{ name: 'r1', type: 'float' },
+		{ name: 'r2', type: 'float' },
+	]
+} );
+
+// Generalized Trowbridge-Reitz (GTR). For GGX set k=2.
+// D_GTR(roughness, NoH, k) where roughness = α (not α²).
+export const D_GTR = Fn( ( [ roughness, NoH, k ] ) => {
+
+	// see: Filament - Normal distribution function (specular D) - 4.4.1
+	const a2 = roughness.mul( roughness ).toVar(); // α²
+	const NoH2 = NoH.mul( NoH ).toVar();
+	const base = NoH2.mul( a2.sub( float( 1.0 ) ) ).add( float( 1.0 ) ).toVar();
+	// a² / (π * base^k)
+	return a2.div( PI.mul( pow( base, k ) ) ).toVar(); // float
+
+} );
+
+// Smith G1 (Heitz): expects alpha (not squared); it squares internally
+export const SmithG = Fn( ( [ NDotX, alpha ] ) => {
+
+	// see: Filament - Geometric shadowing (specular G) - 4.4.2
+
+	const a2 = alpha.mul( alpha ).toVar(); // α²
+	const NDotX2 = NDotX.mul( NDotX ).toVar(); // (N·X)²
+	return float( 2.0 ).mul( NDotX ).div(
+		NDotX.add( sqrt(
+			a2.add( a2.oneMinus().mul( NDotX2 ) )
+		) )
+	);
+
+} );
+
+// Geometry term G = G1(N·L, α_G) * G1(N·V, α_G)  (α_G is NOT squared here)
+export const GeometryTerm = Fn( ( [ NoL, NoV, alphaG ] ) => {
+
+	const G1v = SmithG( NoV, alphaG ).toVar();
+	const G1l = SmithG( NoL, alphaG ).toVar();
+	return G1v.mul( G1l ).toVar();
+
+} );
+
+// Bounded VNDF direction PDF (reflection mapping), matching SampleGGXVNDF above.
+// p(L) = D_GTR(roughness, NoH, 2) / ( 2 * (k * N·V + t) )   (Eto & Tokuyoshi eq. 8)
+// with the isotropic cap bound k and t = ‖(α·V.xy, V.z)‖. Here 'roughness' is α, not α².
+const GGXVNDFPdf = Fn( ( [ NoH, NoV, roughness ] ) => {
+
+	const D = D_GTR( roughness, NoH, float( 2.0 ) ).toVar();
+	const a2 = roughness.mul( roughness ).toVar();
+	const sinV2 = max( float( 0.0 ), float( 1.0 ).sub( NoV.mul( NoV ) ) ).toVar(); // ‖V.xy‖²
+	const s = float( 1.0 ).add( sqrt( sinV2 ) ).toVar();
+	const s2 = s.mul( s ).toVar();
+	const k = float( 1.0 ).sub( a2 ).mul( s2 ).div( s2.add( a2.mul( NoV ).mul( NoV ) ) ).toVar();
+	const t = sqrt( a2.mul( sinV2 ).add( NoV.mul( NoV ) ) ).toVar();
+	return D.div( max( float( 1e-6 ), float( 2.0 ).mul( k.mul( NoV ).add( t ) ) ) ).toVar();
+
+} );
+
+/**
+ * Fresnel reflectance for the Schlick approximation.
+ */
+export const F_Schlick = Fn( ( [ f0, theta ] ) => {
+
+	const oneMinus = float( 1.0 ).sub( theta ).toVar();
+	const oneMinus2 = oneMinus.mul( oneMinus ).toVar();
+	const oneMinus5 = oneMinus2.mul( oneMinus2 ).mul( oneMinus ).toVar();
+	return f0.add( vec3( 1.0 ).sub( f0 ).mul( oneMinus5 ) ).toVar(); // vec3
+
+} );
+
+/**
+ * Specular dominant factor for parallax-corrected ray length.
+ * From REBLUR: A Hierarchical Recurrent Denoiser (NRD).
+ */
+export const getSpecularDominantFactor = Fn( ( [ NoV, roughness ] ) => {
+
+	const a = float( 0.298475 ).mul(
+		log( float( 39.4115 ).sub( float( 39.0029 ).mul( roughness ) ) )
+	);
+	const f = float( 1.0 ).sub( NoV ).pow( 10.8649 )
+		.mul( float( 1.0 ).sub( a ) )
+		.add( a );
+	return clamp( f );
+
+} ).setLayout( {
+	name: 'getSpecularDominantFactor',
+	type: 'float',
+	inputs: [
+		{ name: 'NoV', type: 'float' },
+		{ name: 'roughness', type: 'float' }
+	]
+} );
+
+/**
+ * Everything a single GGX reflection sample produces. `reflectDir` and `sampleWeight`
+ * drive the SSR ray-march and compositing; `pdf`, `NdotV`, `alpha` and `f0` are the GGX
+ * terms the env-miss MIS fallback needs so the caller never re-derives microfacet math.
+ */
+const ggxReflectionStruct = struct( {
+	reflectDir: 'vec3', // view-space reflected ray direction
+	sampleWeight: 'vec3', // chromatic weight (incl. Fresnel tint) to multiply gathered radiance by
+	pdf: 'float', // VNDF direction pdf (for MIS against the env CDF)
+	NdotV: 'float',
+	alpha: 'float', // GGX alpha (roughness²), clamped
+	f0: 'vec3' // Fresnel reflectance at normal incidence
+} );
+
+/**
+ * Importance-samples the GGX/VNDF specular lobe for one pixel and returns the reflected
+ * ray direction plus the Monte-Carlo weight to apply to the gathered radiance, along with
+ * the GGX terms the SSR env-miss MIS fallback needs.
+ *
+ * @param {Node<vec3>} N - View-space shading normal (normalized).
+ * @param {Node<vec3>} V - View-space surface→camera direction (normalized).
+ * @param {Node<float>} roughness - Perceptual roughness in `[0,1]`.
+ * @param {Node<float>} metalness - Metalness in `[0,1]`.
+ * @param {Node<vec3>} albedo - Surface base color; tints the metal Fresnel reflectance (`f0`).
+ * @param {Node<vec4>} Xi - Per-pixel random numbers; only `.xy` are used.
+ * @return {ggxReflectionStruct}
+ */
+export const ggxReflectionSample = Fn( ( [ N, V, roughness, metalness, albedo, Xi ] ) => {
+
+	// GGX alpha (use r^2, clamp to avoid degenerate)
+	const a = roughness.mul( roughness ).max( 0.001 ).toVar();
+	const ax = a.toVar();
+	const ay = a.toVar();
+
+	// TBN from view-space normal
+	const up = vec3( 0, 0, 1 );
+	let T = cross( up, N ).toVar();
+	T = T.normalize().toVar();
+	If( T.length().lessThan( 1e-3 ), () => {
+
+		T.assign( cross( vec3( 0, 1, 0 ), N ).normalize() );
+
+	} );
+	const B = cross( N, T ).normalize().toVar();
+
+	// transform V to LOCAL frame (N = +Z)
+	const Vlocal = vec3( dot( T, V ), dot( B, V ), dot( N, V ) ).toVar();
+
+	// VNDF sample **in local frame**
+	const Hlocal = SampleGGXVNDF( Vlocal, ax, ay, Xi.x, Xi.y ).toVar();
+	If( Hlocal.z.lessThan( 0 ), () => {
+
+		Hlocal.assign( Hlocal.negate() );
+
+	} );
+
+	// transform H back to VIEW space
+	const h = normalize( T.mul( Hlocal.x ).add( B.mul( Hlocal.y ) ).add( N.mul( Hlocal.z ) ) ).toVar();
+
+	// reflect with V (surface->camera) and H
+	const viewReflectDir = reflect( V.negate(), h ).normalize().toVar();
+
+	// BRDF/PDF evaluation for the sampled direction
+	// V: surface -> camera, L: reflected direction, N: normal, H: half-vector
+	const L = viewReflectDir.toVar();
+	const H = normalize( V.add( L ) ).toVar(); // ~h; recomputed for robustness
+
+	const NdotV = max( float( 0.0 ), dot( N, V ) ).toVar();
+	const NdotL = max( float( 0.0 ), dot( N, L ) ).toVar();
+	const NdotH = max( float( 0.0 ), dot( N, H ) ).toVar();
+	const VdotH = max( float( 0.0 ), dot( V, H ) ).toVar();
+
+	const f0 = mix( vec3( 0.04 ), albedo, metalness ).toVar();
+	// Chromatic Fresnel reflectance: for metals f0 = albedo, so the reflection is tinted and desaturates
+	// toward white at grazing angles. Kept as vec3 so colored metals reflect with the correct chroma.
+	const fresnelWeight = F_Schlick( f0, VdotH ).toVar(); // vec3
+
+	// Bounded-VNDF direction pdf — still needed for the env-miss MIS path.
+	const pdf = GGXVNDFPdf( NdotH, NdotV, ax ).toVar();
+
+	// Numerically stable importance weight: brdf·NdotL/pdf ≡ fresnel·G2·(k·NdotV + t)/(2·NdotV), which
+	// cancels the GGX D analytically. Evaluating D explicitly is catastrophic at low roughness
+	// (D → 3e5 at α = 0.001 wrecks f32 precision); the cancelled form stays stable down to a mirror.
+	// (k·NdotV + t) is the bounded-cap normalization; k shrinks the cap to drop below-horizon samples.
+	const a2 = ax.mul( ax ).toVar();
+	const sinV2 = NdotV.mul( NdotV ).oneMinus().max( 0.0 ).toVar(); // ‖V.xy‖²
+	const sB = float( 1.0 ).add( sqrt( sinV2 ) ).toVar();
+	const s2B = sB.mul( sB ).toVar();
+	const kB = a2.oneMinus().mul( s2B ).div( s2B.add( a2.mul( NdotV ).mul( NdotV ) ) ).toVar();
+	const tB = sqrt( a2.mul( sinV2 ).add( NdotV.mul( NdotV ) ) ).toVar();
+	const glossyWeight = fresnelWeight
+		.mul( GeometryTerm( NdotL, NdotV, ax ) )
+		.mul( kB.mul( NdotV ).add( tB ) )
+		.div( float( 2.0 ).mul( NdotV ).max( 1e-4 ) ).toVar();
+
+	return ggxReflectionStruct( viewReflectDir, glossyWeight, pdf, NdotV, ax, f0 );
+
+} );
+
+// Equirectangular environment sampling
+
+/**
+ * Equirectangular direction / UV / PDF helpers and MIS weighting shared by environment sampling code.
+ * Env-miss MIS integration lives in {@link ImportanceSampledEnvironment}.
+ *
+ * Equirectangular parameterization helpers used with CDF importance sampling are adapted from
+ * [three-gpu-pathtracer](https://github.com/gkjohnson/three-gpu-pathtracer).
+ *
+ * @see {@link https://github.com/gkjohnson/three-gpu-pathtracer}
+ */
+
+// uv -> direction (equirectangular)
+export const equirectUvToDir = Fn( ( [ uvIn ] ) => {
+
+	const phi = uvIn.x.mul( Math.PI * 2 ).sub( Math.PI );
+	const lat = uvIn.y.sub( 0.5 ).mul( Math.PI );
+	const cosLat = cos( lat );
+	return normalize( vec3(
+		cosLat.mul( cos( phi ) ),
+		sin( lat ),
+		cosLat.mul( sin( phi ) )
+	) );
+
+} ).setLayout( {
+	name: 'equirectUvToDir',
+	type: 'vec3',
+	inputs: [ { name: 'uv', type: 'vec2' } ]
+} );
+
+// Solid-angle PDF of a direction under equirectangular parameterization.
+export const equirectDirPdf = Fn( ( [ direction ] ) => {
+
+	const uvDir = equirectUV( direction );
+	const sinTheta = sin( uvDir.y.mul( Math.PI ) );
+	return sinTheta.abs().lessThan( float( 1e-6 ) ).select(
+		float( 0 ),
+		float( 1 ).div( float( 2 * Math.PI * Math.PI ).mul( sinTheta ) )
+	);
+
+} ).setLayout( {
+	name: 'equirectDirPdf',
+	type: 'float',
+	inputs: [ { name: 'direction', type: 'vec3' } ]
+} );
+
+/**
+ * MIS power heuristic with β = 2: `pdfA² / (pdfA² + pdfB²)`.
+ * Weights the contribution of the strategy that produced `pdfA` against the other strategy.
+ *
+ * @see Eric Veach, *Optimally Combining Sampling Techniques for Monte Carlo Rendering*
+ * @tsl
+ */
+export const misPowerHeuristic = Fn( ( [ pdfA, pdfB ] ) => {
+
+	const pdfASq = pdfA.mul( pdfA );
+	const pdfBSq = pdfB.mul( pdfB );
+	return pdfASq.div( pdfASq.add( pdfBSq ) );
+
+} ).setLayout( {
+	name: 'misPowerHeuristic',
+	type: 'float',
+	inputs: [
+		{ name: 'pdfA', type: 'float' },
+		{ name: 'pdfB', type: 'float' }
+	]
+} );
+

package/examples/jsm/utils/BufferGeometryUtils.js

@@ -39,13 +39,13 @@ function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
 
 	if ( ! MikkTSpace || ! MikkTSpace.isReady ) {
 
-		throw new Error( 'BufferGeometryUtils: Initialized MikkTSpace library required.' );
+		throw new Error( 'THREE.BufferGeometryUtils: Initialized MikkTSpace library required.' );
 
 	}
 
 	if ( ! geometry.hasAttribute( 'position' ) || ! geometry.hasAttribute( 'normal' ) || ! geometry.hasAttribute( 'uv' ) ) {
 
-		throw new Error( 'BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' );
+		throw new Error( 'THREE.BufferGeometryUtils: Tangents require "position", "normal", and "uv" attributes.' );
 
 	}
 
@@ -286,8 +286,7 @@ function mergeGeometries( geometries, useGroups = false ) {
 	for ( const name in morphAttributes ) {
 
 		const numMorphTargets = morphAttributes[ name ][ 0 ].length;
-
-		if ( numMorphTargets === 0 ) break;
+		if ( numMorphTargets === 0 ) continue;
 
 		mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
 		mergedGeometry.morphAttributes[ name ] = [];
@@ -1021,7 +1020,7 @@ function computeMorphedAttributes( object ) {
 	const morphPosition = geometry.morphAttributes.position;
 	const morphTargetsRelative = geometry.morphTargetsRelative;
 	const normalAttribute = geometry.attributes.normal;
-	const morphNormal = geometry.morphAttributes.position;
+	const morphNormal = geometry.morphAttributes.normal;
 
 	const groups = geometry.groups;
 	const drawRange = geometry.drawRange;
@@ -1315,105 +1314,172 @@ function mergeGroups( geometry ) {
  */
 function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */ ) {
 
+	// BufferGeometry.toNonIndexed() warns if the geometry is non-indexed
+	// and returns the original geometry
+	const resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry;
+	const posAttr = resultGeometry.attributes.position;
+	const vertexCount = posAttr.count;
+
+	let positions;
+
+	if ( posAttr.isBufferAttribute === true && posAttr.itemSize === 3 && posAttr.normalized === false ) {
+
+		positions = posAttr.array;
+
+	} else {
+
+		// flatten the position buffer so the math below operates on plain numbers
+		positions = new Float64Array( vertexCount * 3 );
+
+		for ( let i = 0; i < vertexCount; i ++ ) {
+
+			positions[ 3 * i + 0 ] = posAttr.getX( i );
+			positions[ 3 * i + 1 ] = posAttr.getY( i );
+			positions[ 3 * i + 2 ] = posAttr.getZ( i );
+
+		}
+
+	}
+
 	const creaseDot = Math.cos( creaseAngle );
 	const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
+	const faceCount = vertexCount / 3;
+
+	// compute the normal of each face
+	const faceNormals = new Float64Array( faceCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
 
-	// reusable vectors
-	const verts = [ new Vector3(), new Vector3(), new Vector3() ];
-	const tempVec1 = new Vector3();
-	const tempVec2 = new Vector3();
-	const tempNorm = new Vector3();
-	const tempNorm2 = new Vector3();
+		const f9 = 9 * f;
+		const ax = positions[ f9 + 0 ], ay = positions[ f9 + 1 ], az = positions[ f9 + 2 ];
+		const bx = positions[ f9 + 3 ], by = positions[ f9 + 4 ], bz = positions[ f9 + 5 ];
+		const cx = positions[ f9 + 6 ], cy = positions[ f9 + 7 ], cz = positions[ f9 + 8 ];
 
-	// hashes a vector
-	function hashVertex( v ) {
+		const v1x = cx - bx, v1y = cy - by, v1z = cz - bz;
+		const v2x = ax - bx, v2y = ay - by, v2z = az - bz;
 
-		const x = ~ ~ ( v.x * hashMultiplier );
-		const y = ~ ~ ( v.y * hashMultiplier );
-		const z = ~ ~ ( v.z * hashMultiplier );
-		return `${x},${y},${z}`;
+		const nx = v1y * v2z - v1z * v2y;
+		const ny = v1z * v2x - v1x * v2z;
+		const nz = v1x * v2y - v1y * v2x;
+
+		const invLength = 1 / ( Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1 );
+		faceNormals[ 3 * f + 0 ] = nx * invLength;
+		faceNormals[ 3 * f + 1 ] = ny * invLength;
+		faceNormals[ 3 * f + 2 ] = nz * invLength;
 
 	}
 
-	// BufferGeometry.toNonIndexed() warns if the geometry is non-indexed
-	// and returns the original geometry
-	const resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry;
-	const posAttr = resultGeometry.attributes.position;
-	const vertexMap = {};
+	// assign an id to each vertex, sharing the id between vertices with the same
+	// quantized position via an open-addressed hash table (slots hold id + 1, 0 means empty)
+	const vertexIds = new Int32Array( vertexCount );
+	const quantized = new Int32Array( vertexCount * 3 );
 
-	// find all the normals shared by commonly located vertices
-	for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+	let tableSize = 1;
+	while ( tableSize < vertexCount * 2 ) tableSize <<= 1;
+	const tableMask = tableSize - 1;
+	const table = new Int32Array( tableSize );
+
+	let uniqueCount = 0;
+	for ( let i = 0; i < vertexCount; i ++ ) {
 
 		const i3 = 3 * i;
-		const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
-		const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
-		const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+		const qx = ~ ~ ( positions[ i3 + 0 ] * hashMultiplier );
+		const qy = ~ ~ ( positions[ i3 + 1 ] * hashMultiplier );
+		const qz = ~ ~ ( positions[ i3 + 2 ] * hashMultiplier );
 
-		tempVec1.subVectors( c, b );
-		tempVec2.subVectors( a, b );
+		let slot = ( Math.imul( qx, 73856093 ) ^ Math.imul( qy, 19349663 ) ^ Math.imul( qz, 83492791 ) ) & tableMask;
 
-		// add the normal to the map for all vertices
-		const normal = new Vector3().crossVectors( tempVec1, tempVec2 ).normalize();
-		for ( let n = 0; n < 3; n ++ ) {
+		while ( true ) {
 
-			const vert = verts[ n ];
-			const hash = hashVertex( vert );
-			if ( ! ( hash in vertexMap ) ) {
+			const id = table[ slot ];
 
-				vertexMap[ hash ] = [];
+			if ( id === 0 ) {
+
+				const q3 = 3 * uniqueCount;
+				quantized[ q3 + 0 ] = qx;
+				quantized[ q3 + 1 ] = qy;
+				quantized[ q3 + 2 ] = qz;
+
+				table[ slot ] = uniqueCount + 1;
+				vertexIds[ i ] = uniqueCount ++;
+				break;
 
 			}
 
-			vertexMap[ hash ].push( normal );
+			const q3 = 3 * ( id - 1 );
+
+			if ( quantized[ q3 + 0 ] === qx && quantized[ q3 + 1 ] === qy && quantized[ q3 + 2 ] === qz ) {
+
+				vertexIds[ i ] = id - 1;
+				break;
+
+			}
+
+			slot = ( slot + 1 ) & tableMask;
 
 		}
 
 	}
 
-	// average normals from all vertices that share a common location if they are within the
-	// provided crease threshold
-	const normalArray = new Float32Array( posAttr.count * 3 );
-	const normAttr = new BufferAttribute( normalArray, 3, false );
-	for ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {
+	// bucket the faces surrounding each unique vertex position
+	const bucketOffsets = new Int32Array( uniqueCount + 1 );
+	for ( let i = 0; i < vertexCount; i ++ ) bucketOffsets[ vertexIds[ i ] + 1 ] ++;
+	for ( let i = 0; i < uniqueCount; i ++ ) bucketOffsets[ i + 1 ] += bucketOffsets[ i ];
 
-		// get the face normal for this vertex
-		const i3 = 3 * i;
-		const a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );
-		const b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );
-		const c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );
+	const bucketFaces = new Int32Array( vertexCount );
+	const bucketCursors = bucketOffsets.slice( 0, uniqueCount );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 0 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 1 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 2 ] ] ++ ] = f;
 
-		tempVec1.subVectors( c, b );
-		tempVec2.subVectors( a, b );
+	}
+
+	// average the normals of the faces surrounding each vertex if they are within the
+	// provided crease threshold
+	const normalArray = new Float32Array( vertexCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
 
-		tempNorm.crossVectors( tempVec1, tempVec2 ).normalize();
+		const f3 = 3 * f;
+		const nx = faceNormals[ f3 + 0 ];
+		const ny = faceNormals[ f3 + 1 ];
+		const nz = faceNormals[ f3 + 2 ];
 
-		// average all normals that meet the threshold and set the normal value
 		for ( let n = 0; n < 3; n ++ ) {
 
-			const vert = verts[ n ];
-			const hash = hashVertex( vert );
-			const otherNormals = vertexMap[ hash ];
-			tempNorm2.set( 0, 0, 0 );
+			const i = f3 + n;
+			const id = vertexIds[ i ];
+
+			let sumX = 0, sumY = 0, sumZ = 0;
+
+			for ( let k = bucketOffsets[ id ], end = bucketOffsets[ id + 1 ]; k < end; k ++ ) {
 
-			for ( let k = 0, lk = otherNormals.length; k < lk; k ++ ) {
+				const o3 = 3 * bucketFaces[ k ];
+				const ox = faceNormals[ o3 + 0 ];
+				const oy = faceNormals[ o3 + 1 ];
+				const oz = faceNormals[ o3 + 2 ];
 
-				const otherNorm = otherNormals[ k ];
-				if ( tempNorm.dot( otherNorm ) > creaseDot ) {
+				if ( nx * ox + ny * oy + nz * oz > creaseDot ) {
 
-					tempNorm2.add( otherNorm );
+					sumX += ox;
+					sumY += oy;
+					sumZ += oz;
 
 				}
 
 			}
 
-			tempNorm2.normalize();
-			normAttr.setXYZ( i3 + n, tempNorm2.x, tempNorm2.y, tempNorm2.z );
+			const invLength = 1 / ( Math.sqrt( sumX * sumX + sumY * sumY + sumZ * sumZ ) || 1 );
+			normalArray[ 3 * i + 0 ] = sumX * invLength;
+			normalArray[ 3 * i + 1 ] = sumY * invLength;
+			normalArray[ 3 * i + 2 ] = sumZ * invLength;
 
 		}
 
 	}
 
-	resultGeometry.setAttribute( 'normal', normAttr );
+	resultGeometry.setAttribute( 'normal', new BufferAttribute( normalArray, 3, false ) );
 	return resultGeometry;
 
 }

package/examples/jsm/utils/ColorUtils.js

@@ -0,0 +1,76 @@
+import { MathUtils, SRGBColorSpace } from 'three';
+
+/**
+ * @module ColorUtils
+ * @three_import import * as ColorUtils from 'three/addons/utils/ColorUtils.js';
+ */
+
+/**
+ * Sets the given color from a color temperature in Kelvin.
+ *
+ * Converts a correlated color temperature (CTT) to an approximate sRGB color
+ * using Tanner Helland's algorithm. Useful for physically-based lighting
+ * setups — e.g. candle flame (~1900K), tungsten bulb (~3200K), daylight
+ * (~6500K), or clear blue sky (~10000K). Values outside [1000, 40000] are
+ * clamped.
+ *
+ * Reference: https://tannerhelland.com/2012/09/18/convert-temperature-rgb-algorithm-code.html
+ *
+ * @param {Color} color - The color to set.
+ * @param {number} kelvin - Color temperature in Kelvin. Clamped to [1000, 40000].
+ * @return {Color} The updated color.
+ */
+function setKelvin( color, kelvin ) {
+
+	// Algorithm by Tanner Helland (2012). Inputs are divided by 100.
+	const temp = MathUtils.clamp( kelvin, 1000, 40000 ) / 100;
+
+	let r, g, b;
+
+	// Red channel
+	if ( temp <= 66 ) {
+
+		r = 255;
+
+	} else {
+
+		r = 329.698727446 * Math.pow( temp - 60, - 0.1332047592 );
+
+	}
+
+	// Green channel
+	if ( temp <= 66 ) {
+
+		g = 99.4708025861 * Math.log( temp ) - 161.1195681661;
+
+	} else {
+
+		g = 288.1221695283 * Math.pow( temp - 60, - 0.0755148492 );
+
+	}
+
+	// Blue channel
+	if ( temp >= 66 ) {
+
+		b = 255;
+
+	} else if ( temp <= 19 ) {
+
+		b = 0;
+
+	} else {
+
+		b = 138.5177312231 * Math.log( temp - 10 ) - 305.0447927307;
+
+	}
+
+	return color.setRGB(
+		MathUtils.clamp( r, 0, 255 ) / 255,
+		MathUtils.clamp( g, 0, 255 ) / 255,
+		MathUtils.clamp( b, 0, 255 ) / 255,
+		SRGBColorSpace
+	);
+
+}
+
+export { setKelvin };

package/examples/jsm/utils/GeometryCompressionUtils.js

@@ -509,7 +509,7 @@ function quantizedEncodeUV( array, bytes ) {
 
 	}
 
-	decodeMat.scale(
+	decodeMat.makeScale(
 		( max[ 0 ] - min[ 0 ] ) / segments,
 		( max[ 1 ] - min[ 1 ] ) / segments
 	);

package/examples/jsm/utils/LDrawUtils.js

@@ -119,7 +119,7 @@ class LDrawUtils {
 
 		object.traverse( c => {
 
-			if ( c.isMesh | c.isLineSegments ) {
+			if ( c.isMesh || c.isLineSegments ) {
 
 				const elemSize = c.isMesh ? 3 : 2;