@unikia/upe-renderer 0.186.110 → 0.187.11

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

@@ -23,7 +23,7 @@ const hitBox = /*@__PURE__*/ Fn( ( { orig, dir } ) => {
 
 	return vec2( t0, t1 );
 
-} );
+}, { orig: 'vec3', dir: 'vec3', return: 'vec2' } );
 
 /**
  * TSL function for performing raymarching in a box-area using the specified number of steps

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

@@ -12,26 +12,19 @@ import { Fn, float, positionView, viewportDepthTexture, perspectiveDepthToViewZ,
  * @tsl
  * @function
  * @private
- * @param {Node<float>} input - The value to remap, expected in the `[0, 1]` range.
+ * @param {Node<float>} value - The value to remap, expected in the `[0, 1]` range.
  * @param {Node<float>} power - The contrast power. `1` is linear, higher values sharpen the transition.
  * @return {Node<float>} The remapped value.
  */
-const contrastCurve = /*@__PURE__*/ Fn( ( [ input, power ] ) => {
+const contrastCurve = /*@__PURE__*/ Fn( ( [ value, power ] ) => {
 
-	const aboveHalf = input.greaterThan( 0.5 ).toConst();
-	const folded = aboveHalf.select( input.oneMinus(), input ).toConst();
+	const aboveHalf = value.greaterThan( 0.5 ).toConst();
+	const folded = aboveHalf.select( value.oneMinus(), value ).toConst();
 	const output = folded.mul( 2 ).saturate().pow( power ).mul( 0.5 ).toConst();
 
 	return aboveHalf.select( output.oneMinus(), output );
 
-} ).setLayout( {
-	name: 'contrastCurve',
-	type: 'float',
-	inputs: [
-		{ name: 'input', type: 'float' },
-		{ name: 'power', type: 'float' }
-	]
-} );
+}, { value: 'float', power: 'float', return: 'float' } );
 
 /**
  * Computes an opacity node for soft particles, based on the "Soft Particles" white

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

@@ -1,4 +1,4 @@
-import { Fn, If, PI, clamp, cos, cross, dot, equirectUV, float, log, max, mix, normalize, pow, reflect, sin, sqrt, struct, vec3 } from 'three/tsl';
+import { EPSILON, 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,
@@ -57,15 +57,12 @@ const SampleGGXVNDF = Fn( ( [ V, ax, ay, r1, r2 ] ) => {
 	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' },
-	]
+	V: 'vec3',
+	ax: 'float',
+	ay: 'float',
+	r1: 'float',
+	r2: 'float',
+	return: 'vec3'
 } );
 
 // Generalized Trowbridge-Reitz (GTR). For GGX set k=2.
@@ -79,7 +76,7 @@ export const D_GTR = Fn( ( [ roughness, NoH, k ] ) => {
 	// a² / (π * base^k)
 	return a2.div( PI.mul( pow( base, k ) ) ).toVar(); // float
 
-} );
+}, { roughness: 'float', NoH: 'float', k: 'float', return: 'float' } );
 
 // Smith G1 (Heitz): expects alpha (not squared); it squares internally
 export const SmithG = Fn( ( [ NDotX, alpha ] ) => {
@@ -94,7 +91,7 @@ export const SmithG = Fn( ( [ NDotX, alpha ] ) => {
 		) )
 	);
 
-} );
+}, { NDotX: 'float', alpha: 'float', return: 'float' } );
 
 // Geometry term G = G1(N·L, α_G) * G1(N·V, α_G)  (α_G is NOT squared here)
 export const GeometryTerm = Fn( ( [ NoL, NoV, alphaG ] ) => {
@@ -103,7 +100,7 @@ export const GeometryTerm = Fn( ( [ NoL, NoV, alphaG ] ) => {
 	const G1l = SmithG( NoL, alphaG ).toVar();
 	return G1v.mul( G1l ).toVar();
 
-} );
+}, { NoL: 'float', NoV: 'float', alphaG: 'float', return: 'float' } );
 
 // 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)
@@ -117,21 +114,21 @@ const GGXVNDFPdf = Fn( ( [ NoH, NoV, roughness ] ) => {
 	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();
+	return D.div( max( float( EPSILON ), float( 2.0 ).mul( k.mul( NoV ).add( t ) ) ) ).toVar();
 
-} );
+}, { NoH: 'float', NoV: 'float', roughness: 'float', return: 'float' } );
 
 /**
  * Fresnel reflectance for the Schlick approximation.
  */
-export const F_Schlick = Fn( ( [ f0, theta ] ) => {
+export const F_Schlick = Fn( ( [ f0, theta, f90 = float( 1 ) ] ) => {
 
 	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
+	return f0.add( vec3( f90 ).sub( f0 ).mul( oneMinus5 ) ).toVar(); // vec3
 
-} );
+}, { f0: 'vec3', theta: 'float', f90: 'float', return: 'vec3' } );
 
 /**
  * Specular dominant factor for parallax-corrected ray length.
@@ -147,14 +144,7 @@ export const getSpecularDominantFactor = Fn( ( [ NoV, roughness ] ) => {
 		.add( a );
 	return clamp( f );
 
-} ).setLayout( {
-	name: 'getSpecularDominantFactor',
-	type: 'float',
-	inputs: [
-		{ name: 'NoV', type: 'float' },
-		{ name: 'roughness', type: 'float' }
-	]
-} );
+}, { NoV: 'float', roughness: 'float', return: 'float' } );
 
 /**
  * Everything a single GGX reflection sample produces. `reflectDir` and `sampleWeight`
@@ -167,23 +157,12 @@ const ggxReflectionStruct = struct( {
 	pdf: 'float', // VNDF direction pdf (for MIS against the env CDF)
 	NdotV: 'float',
 	alpha: 'float', // GGX alpha (roughness²), clamped
+	f90: 'float',
 	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 ] ) => {
+// Core of `ggxReflectionSample()` with explicit F0/F90.
+const ggxReflectionSampleWithReflectance = Fn( ( [ N, V, roughness, f0, f90, Xi ] ) => {
 
 	// GGX alpha (use r^2, clamp to avoid degenerate)
 	const a = roughness.mul( roughness ).max( 0.001 ).toVar();
@@ -191,14 +170,8 @@ export const ggxReflectionSample = Fn( ( [ N, V, roughness, metalness, albedo, X
 	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 up = N.z.abs().lessThan( 0.999 ).select( vec3( 0, 0, 1 ), vec3( 1, 0, 0 ) );
+	const T = cross( up, N ).normalize().toVar();
 	const B = cross( N, T ).normalize().toVar();
 
 	// transform V to LOCAL frame (N = +Z)
@@ -228,10 +201,9 @@ export const ggxReflectionSample = Fn( ( [ N, V, roughness, metalness, albedo, X
 	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
+	const fresnelWeight = F_Schlick( f0, VdotH, f90 ).toVar(); // vec3
 
 	// Bounded-VNDF direction pdf — still needed for the env-miss MIS path.
 	const pdf = GGXVNDFPdf( NdotH, NdotV, ax ).toVar();
@@ -251,10 +223,30 @@ export const ggxReflectionSample = Fn( ( [ N, V, roughness, metalness, albedo, X
 		.mul( kB.mul( NdotV ).add( tB ) )
 		.div( float( 2.0 ).mul( NdotV ).max( 1e-4 ) ).toVar();
 
-	return ggxReflectionStruct( viewReflectDir, glossyWeight, pdf, NdotV, ax, f0 );
+	return ggxReflectionStruct( viewReflectDir, glossyWeight, pdf, NdotV, ax, f90, f0 );
 
 } );
 
+/**
+ * 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.
+ *
+ * @tsl
+ * @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]`; only used when `f0` is omitted.
+ * @param {Node<vec3>} albedo - Surface base color; tints the metal F0 when `f0` is omitted.
+ * @param {Node<vec4>} Xi - Per-pixel random numbers; only `.xy` are used.
+ * @param {?Node<vec3>} [f0=null] - Normal-incidence reflectance. Defaults to `mix( 0.04, albedo, metalness )`.
+ * @param {Node<float>|number} [f90=1] - Grazing reflectance.
+ * @return {ggxReflectionStruct}
+ */
+export const ggxReflectionSample = ( N, V, roughness, metalness, albedo, Xi, f0 = null, f90 = 1 ) =>
+
+	ggxReflectionSampleWithReflectance( N, V, roughness, f0 ?? mix( vec3( 0.04 ), albedo, metalness ), float( f90 ), Xi );
+
 // Equirectangular environment sampling
 
 /**
@@ -279,27 +271,19 @@ export const equirectUvToDir = Fn( ( [ uvIn ] ) => {
 		cosLat.mul( sin( phi ) )
 	) );
 
-} ).setLayout( {
-	name: 'equirectUvToDir',
-	type: 'vec3',
-	inputs: [ { name: 'uv', type: 'vec2' } ]
-} );
+}, { uv: 'vec2', return: 'vec3' } );
 
 // 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(
+	return sinTheta.abs().lessThan( float( EPSILON ) ).select(
 		float( 0 ),
 		float( 1 ).div( float( 2 * Math.PI * Math.PI ).mul( sinTheta ) )
 	);
 
-} ).setLayout( {
-	name: 'equirectDirPdf',
-	type: 'float',
-	inputs: [ { name: 'direction', type: 'vec3' } ]
-} );
+}, { direction: 'vec3', return: 'float' } );
 
 /**
  * MIS power heuristic with β = 2: `pdfA² / (pdfA² + pdfB²)`.
@@ -314,12 +298,5 @@ export const misPowerHeuristic = Fn( ( [ pdfA, pdfB ] ) => {
 	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' }
-	]
-} );
+}, { pdfA: 'float', pdfB: 'float', return: 'float' } );
 

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

@@ -27,15 +27,12 @@ export const clipAABB = Fn( ( [ currentColor, historyColor, minColor, maxColor ]
 		historyColor
 	);
 
-} ).setLayout( {
-	name: 'clipAABB',
-	type: 'vec4',
-	inputs: [
-		{ name: 'currentColor', type: 'vec4' },
-		{ name: 'historyColor', type: 'vec4' },
-		{ name: 'minColor', type: 'vec4' },
-		{ name: 'maxColor', type: 'vec4' }
-	]
+}, {
+	currentColor: 'vec4',
+	historyColor: 'vec4',
+	minColor: 'vec4',
+	maxColor: 'vec4',
+	return: 'vec4'
 } );
 
 /**
@@ -62,14 +59,6 @@ export const flickerReduction = Fn( ( [ currentColor, historyColor, currentWeigh
 
 	return add( currentColor.mul( weightCurrent ), historyColor.mul( weightHistory ) ).div( max( weightCurrent.add( weightHistory ), 0.00001 ) );
 
-} ).setLayout( {
-	name: 'flickerReduction',
-	type: 'vec4',
-	inputs: [
-		{ name: 'currentColor', type: 'vec4' },
-		{ name: 'historyColor', type: 'vec4' },
-		{ name: 'currentWeight', type: 'float' }
-	]
 } );
 
 /**

package/examples/jsm/utils/BufferGeometryUtils.js

@@ -5,6 +5,7 @@ import {
 	InstancedBufferAttribute,
 	InterleavedBuffer,
 	InterleavedBufferAttribute,
+	MathUtils,
 	TriangleFanDrawMode,
 	TriangleStripDrawMode,
 	TrianglesDrawMode,
@@ -27,10 +28,11 @@ import {
  * custom material, and may be faster than MikkTSpace.
  *
  * Returns the original BufferGeometry. Indexed geometries will be de-indexed. Requires position, normal, and uv attributes.
+ * Tangents are stored like the normals: normalized Int8 or Int16 when the normals are, Float32 otherwise.
  *
  * @param {BufferGeometry} geometry - The geometry to compute tangents for.
  * @param {Object} MikkTSpace - Instance of `examples/jsm/libs/mikktspace.module.js`, or `mikktspace` npm package.
- * Await `MikkTSpace.ready` before use.
+ * The bundled JavaScript implementation is ready immediately. Await `MikkTSpace.ready` before using a WebAssembly implementation.
  * @param {boolean} [negateSign=true] - Whether to negate the sign component (.w) of each tangent.
  * Required for normal map conventions in some formats, including glTF.
  * @return {BufferGeometry} The updated geometry.
@@ -111,7 +113,28 @@ function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
 
 	//
 
-	_geometry.setAttribute( 'tangent', new BufferAttribute( tangents, 4 ) );
+	// Quantized normals get tangents of the same precision.
+
+	const normal = _geometry.attributes.normal;
+	const normalArray = normal.array;
+
+	if ( normal.normalized && ( normalArray instanceof Int8Array || normalArray instanceof Int16Array ) ) {
+
+		const quantized = new normalArray.constructor( tangents.length );
+
+		for ( let i = 0; i < tangents.length; i ++ ) {
+
+			quantized[ i ] = MathUtils.normalize( tangents[ i ], quantized );
+
+		}
+
+		_geometry.setAttribute( 'tangent', new BufferAttribute( quantized, 4, true ) );
+
+	} else {
+
+		_geometry.setAttribute( 'tangent', new BufferAttribute( tangents, 4 ) );
+
+	}
 
 	if ( geometry !== _geometry ) {
 
@@ -143,6 +166,7 @@ function mergeGeometries( geometries, useGroups = false ) {
 	const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
 
 	const mergedGeometry = new BufferGeometry();
+	mergedGeometry.morphTargetsRelative = morphTargetsRelative;
 
 	let offset = 0;
 
@@ -150,6 +174,7 @@ function mergeGeometries( geometries, useGroups = false ) {
 
 		const geometry = geometries[ i ];
 		let attributesCount = 0;
+		let morphAttributesCount = 0;
 
 		// ensure that all geometries are indexed, or none
 
@@ -206,10 +231,28 @@ function mergeGeometries( geometries, useGroups = false ) {
 
 			}
 
+			if ( geometry.morphAttributes[ name ].length !== geometries[ 0 ].morphAttributes[ name ].length ) {
+
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have the same number of morph targets for the "' + name + '" morph attribute.' );
+				return null;
+
+			}
+
 			if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
 
 			morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
 
+			morphAttributesCount ++;
+
+		}
+
+		// ensure geometries have the same number of morph attributes
+
+		if ( morphAttributesCount !== morphAttributesUsed.size ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of morph attributes.' );
+			return null;
+
 		}
 
 		if ( useGroups ) {
@@ -569,7 +612,7 @@ function deinterleaveAttribute( attribute ) {
 function deinterleaveGeometry( geometry ) {
 
 	const attributes = geometry.attributes;
-	const morphTargets = geometry.morphTargets;
+	const morphAttributes = geometry.morphAttributes;
 	const attrMap = new Map();
 
 	for ( const key in attributes ) {
@@ -589,18 +632,24 @@ function deinterleaveGeometry( geometry ) {
 
 	}
 
-	for ( const key in morphTargets ) {
+	for ( const key in morphAttributes ) {
 
-		const attr = morphTargets[ key ];
-		if ( attr.isInterleavedBufferAttribute ) {
+		const morphAttribute = morphAttributes[ key ];
 
-			if ( ! attrMap.has( attr ) ) {
+		for ( let i = 0, l = morphAttribute.length; i < l; i ++ ) {
 
-				attrMap.set( attr, deinterleaveAttribute( attr ) );
+			const attr = morphAttribute[ i ];
+			if ( attr.isInterleavedBufferAttribute ) {
 
-			}
+				if ( ! attrMap.has( attr ) ) {
+
+					attrMap.set( attr, deinterleaveAttribute( attr ) );
+
+				}
+
+				morphAttribute[ i ] = attrMap.get( attr );
 
-			morphTargets[ key ] = attrMap.get( attr );
+			}
 
 		}
 
@@ -656,39 +705,10 @@ function mergeVertices( geometry, tolerance = 1e-4 ) {
 
 	// attributes and new attribute arrays
 	const attributeNames = Object.keys( geometry.attributes );
-	const tmpAttributes = {};
-	const tmpMorphAttributes = {};
+	const sourceIndices = [];
+	const buffers = new Map();
 	const newIndices = [];
 	const getters = [ 'getX', 'getY', 'getZ', 'getW' ];
-	const setters = [ 'setX', 'setY', 'setZ', 'setW' ];
-
-	// Initialize the arrays, allocating space conservatively. Extra
-	// space will be trimmed in the last step.
-	for ( let i = 0, l = attributeNames.length; i < l; i ++ ) {
-
-		const name = attributeNames[ i ];
-		const attr = geometry.attributes[ name ];
-
-		tmpAttributes[ name ] = new attr.constructor(
-			new attr.array.constructor( attr.count * attr.itemSize ),
-			attr.itemSize,
-			attr.normalized
-		);
-
-		const morphAttributes = geometry.morphAttributes[ name ];
-		if ( morphAttributes ) {
-
-			if ( ! tmpMorphAttributes[ name ] ) tmpMorphAttributes[ name ] = [];
-			morphAttributes.forEach( ( morphAttr, i ) => {
-
-				const array = new morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize );
-				tmpMorphAttributes[ name ][ i ] = new morphAttr.constructor( array, morphAttr.itemSize, morphAttr.normalized );
-
-			} );
-
-		}
-
-	}
 
 	// convert the error tolerance to an amount of decimal places to truncate to
 	const halfTolerance = tolerance * 0.5;
@@ -724,35 +744,7 @@ function mergeVertices( geometry, tolerance = 1e-4 ) {
 
 		} else {
 
-			// copy data to the new index in the temporary attributes
-			for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
-
-				const name = attributeNames[ j ];
-				const attribute = geometry.getAttribute( name );
-				const morphAttributes = geometry.morphAttributes[ name ];
-				const itemSize = attribute.itemSize;
-				const newArray = tmpAttributes[ name ];
-				const newMorphArrays = tmpMorphAttributes[ name ];
-
-				for ( let k = 0; k < itemSize; k ++ ) {
-
-					const getterFunc = getters[ k ];
-					const setterFunc = setters[ k ];
-					newArray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) );
-
-					if ( morphAttributes ) {
-
-						for ( let m = 0, ml = morphAttributes.length; m < ml; m ++ ) {
-
-							newMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttributes[ m ][ getterFunc ]( index ) );
-
-						}
-
-					}
-
-				}
-
-			}
+			sourceIndices.push( index );
 
 			hashToIndex[ hash ] = nextIndex;
 			newIndices.push( nextIndex );
@@ -766,27 +758,13 @@ function mergeVertices( geometry, tolerance = 1e-4 ) {
 	const result = geometry.clone();
 	for ( const name in geometry.attributes ) {
 
-		const tmpAttribute = tmpAttributes[ name ];
-
-		result.setAttribute( name, new tmpAttribute.constructor(
-			tmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ),
-			tmpAttribute.itemSize,
-			tmpAttribute.normalized,
-		) );
-
-		if ( ! ( name in tmpMorphAttributes ) ) continue;
-
-		for ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) {
+		result.setAttribute( name, remapAttribute( geometry.attributes[ name ], sourceIndices, buffers ) );
 
-			const tmpMorphAttribute = tmpMorphAttributes[ name ][ j ];
+	}
 
-			result.morphAttributes[ name ][ j ] = new tmpMorphAttribute.constructor(
-				tmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ),
-				tmpMorphAttribute.itemSize,
-				tmpMorphAttribute.normalized,
-			);
+	for ( const name in geometry.morphAttributes ) {
 
-		}
+		result.morphAttributes[ name ] = geometry.morphAttributes[ name ].map( attribute => remapAttribute( attribute, sourceIndices, buffers ) );
 
 	}
 
@@ -1249,6 +1227,8 @@ function mergeGroups( geometry ) {
 
 		const group = groups[ i ];
 
+		if ( group.count === Infinity ) group.count = index.count - group.start;
+
 		const groupStart = group.start;
 		const groupLength = groupStart + group.count;
 
@@ -1484,6 +1464,47 @@ function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */
 
 }
 
+/**
+ * Copies attribute entries in the order specified by the source vertex indices.
+ * Preserves raw values, attribute type and metadata. Reuse the same buffer map
+ * across calls to preserve shared interleaved buffers for the same mapping.
+ *
+ * @param {BufferAttribute|InterleavedBufferAttribute} attribute - The source attribute.
+ * @param {Array<number>|TypedArray} sourceIndices - The source index for each output vertex.
+ * @param {Map<InterleavedBuffer, InterleavedBuffer>} [buffers] - Shared interleaved buffer copies.
+ * @return {BufferAttribute|InterleavedBufferAttribute} The remapped attribute.
+ */
+function remapAttribute( attribute, sourceIndices, buffers = new Map() ) {
+
+	const interleaved = attribute.isInterleavedBufferAttribute;
+	const source = interleaved ? attribute.data : attribute;
+	const stride = interleaved ? source.stride : attribute.itemSize;
+	let data = interleaved ? buffers.get( source ) : undefined;
+
+	if ( data === undefined ) {
+
+		const array = new source.array.constructor( sourceIndices.length * stride );
+		for ( let i = 0; i < sourceIndices.length; i ++ ) {
+
+			for ( let j = 0; j < stride; j ++ ) array[ i * stride + j ] = source.array[ sourceIndices[ i ] * stride + j ];
+
+		}
+
+		data = interleaved
+			? new source.constructor( array, stride, source.meshPerAttribute )
+			: new attribute.constructor( array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute );
+		data.setUsage( source.usage );
+		if ( interleaved ) buffers.set( source, data );
+
+	}
+
+	const result = interleaved ? new attribute.constructor( data, attribute.itemSize, attribute.offset, attribute.normalized ) : data;
+	result.name = attribute.name;
+	if ( ! interleaved ) result.gpuType = attribute.gpuType;
+	return result;
+
+}
+
 export {
 	computeMikkTSpaceTangents,
 	mergeGeometries,
@@ -1494,6 +1515,7 @@ export {
 	interleaveAttributes,
 	estimateBytesUsed,
 	mergeVertices,
+	remapAttribute,
 	toTrianglesDrawMode,
 	computeMorphedAttributes,
 	mergeGroups,