@expofp/renderer 3.45.7 → 3.45.9

package/dist/objects/models/model-asset.d.ts

@@ -32,6 +32,12 @@ export interface ModelAsset {
  * the merge happen at all. Then it is filed under its material, sub-keyed by {@link mergeSignature},
  * because `mergeGeometries` requires its inputs to agree about their attributes.
  *
+ * Two shapes compressors emit are unpacked on the way in. An `EXT_mesh_gpu_instancing` node (an
+ * `InstancedMesh`, from gltfpack `-mi`) is baked once per instance, since the def is our only
+ * instanced unit; its per-instance colors and custom attributes are dropped with a warning. Quantized
+ * attributes (`KHR_mesh_quantization`, from gltfpack) are widened to floats first — see
+ * {@link toFloatGeometry}.
+ *
  * **Nothing here knows about the plan.** The geometry stays in the model's own space, glTF's y-up,
  * and the mapping onto the plan is a transform the *mesh* carries — see `ModelContainer`. That is
  * not a tidiness argument: a mapping baked into vertices is one three cannot see when it decides

package/dist/objects/models/model-asset.js

@@ -1,4 +1,4 @@
-import { Box3, Mesh } from 'three';
+import { Box3, BufferAttribute, InstancedMesh, Matrix4, Mesh, } from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { createLogger } from '../../utils/logging';
 const logger = createLogger('model');
@@ -10,6 +10,12 @@ const logger = createLogger('model');
  * the merge happen at all. Then it is filed under its material, sub-keyed by {@link mergeSignature},
  * because `mergeGeometries` requires its inputs to agree about their attributes.
  *
+ * Two shapes compressors emit are unpacked on the way in. An `EXT_mesh_gpu_instancing` node (an
+ * `InstancedMesh`, from gltfpack `-mi`) is baked once per instance, since the def is our only
+ * instanced unit; its per-instance colors and custom attributes are dropped with a warning. Quantized
+ * attributes (`KHR_mesh_quantization`, from gltfpack) are widened to floats first — see
+ * {@link toFloatGeometry}.
+ *
  * **Nothing here knows about the plan.** The geometry stays in the model's own space, glTF's y-up,
  * and the mapping onto the plan is a transform the *mesh* carries — see `ModelContainer`. That is
  * not a tidiness argument: a mapping baked into vertices is one three cannot see when it decides
@@ -38,16 +44,36 @@ export function bakeGltf(scene, url) {
         const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
         if (!material)
             return;
-        const baked = mesh.geometry.clone();
-        baked.applyMatrix4(mesh.matrixWorld);
-        baked.computeBoundingBox();
-        if (baked.boundingBox)
-            extents.union(baked.boundingBox);
-        const signature = mergeSignature(baked);
-        const id = `${material.uuid}|${signature}`;
-        const bucket = buckets.get(id) ?? { material, signature, geometries: [] };
-        bucket.geometries.push(baked);
-        buckets.set(id, bucket);
+        const source = toFloatGeometry(mesh.geometry);
+        // Per-instance attributes three parked on the shared geometry; each baked copy sheds them.
+        const dropped = mesh instanceof InstancedMesh
+            ? Object.keys(source.attributes).filter((name) => name.startsWith('_'))
+            : [];
+        const bake = (matrix) => {
+            const baked = source.clone();
+            for (const name of dropped)
+                baked.deleteAttribute(name);
+            baked.applyMatrix4(matrix);
+            baked.computeBoundingBox();
+            if (baked.boundingBox)
+                extents.union(baked.boundingBox);
+            const signature = mergeSignature(baked);
+            const id = `${material.uuid}|${signature}`;
+            const bucket = buckets.get(id) ?? { material, signature, geometries: [] };
+            bucket.geometries.push(baked);
+            buckets.set(id, bucket);
+        };
+        if (!(mesh instanceof InstancedMesh)) {
+            bake(mesh.matrixWorld);
+            return;
+        }
+        const ignored = mesh.instanceColor ? [...dropped, '_COLOR_0'] : dropped;
+        if (ignored.length > 0) {
+            logger.warn('model %s: ignored per-instance attributes %s on mesh "%s"', url, ignored.join(', '), mesh.name);
+        }
+        for (let i = 0; i < mesh.count; i++) {
+            bake(_matrix.multiplyMatrices(mesh.matrixWorld, mesh.getMatrixAt(i, _instanceMatrix)));
+        }
     });
     const parts = [];
     for (const [id, { material, signature, geometries }] of buckets) {
@@ -75,3 +101,44 @@ function mergeSignature(geometry) {
     const indexed = geometry.getIndex() ? 'indexed' : 'non-indexed';
     return `${indexed} [${Object.keys(geometry.attributes).sort().join(', ')}]`;
 }
+/**
+ * A copy of the geometry whose every attribute is a plain, non-normalized `Float32Array`.
+ *
+ * `KHR_mesh_quantization` stores attributes as (possibly normalized) integers, with the scale moved
+ * into the node transform. `applyMatrix4` writes its result back into the same array, so baking a
+ * world transform into an `Int16Array` rounds every coordinate to a whole unit. Widening first also
+ * gives `mergeGeometries` matching array types, which it requires but {@link mergeSignature} does not
+ * check. A geometry that is already all floats is returned as is, uncopied: the caller clones it.
+ * @param geometry - The geometry to widen; left untouched.
+ * @returns The geometry itself, or a widened copy.
+ */
+function toFloatGeometry(geometry) {
+    const narrow = Object.entries(geometry.attributes).filter(([, a]) => !isPlainFloat(a));
+    if (narrow.length === 0)
+        return geometry;
+    const widened = geometry.clone();
+    for (const [name, attribute] of narrow) {
+        const { count, itemSize } = attribute;
+        const array = new Float32Array(count * itemSize);
+        for (let i = 0; i < count; i++) {
+            for (let component = 0; component < itemSize; component++) {
+                // `getComponent` denormalizes, and reads through an interleaved buffer's stride.
+                array[i * itemSize + component] = attribute.getComponent(i, component);
+            }
+        }
+        widened.setAttribute(name, new BufferAttribute(array, itemSize));
+    }
+    return widened;
+}
+/**
+ * Whether an attribute is already what {@link toFloatGeometry} produces.
+ * @param attribute - The attribute to test.
+ * @returns `true` for a plain, non-normalized `Float32Array` attribute.
+ */
+function isPlainFloat(attribute) {
+    return (attribute instanceof BufferAttribute &&
+        attribute.array instanceof Float32Array &&
+        !attribute.normalized);
+}
+const _matrix = new Matrix4();
+const _instanceMatrix = new Matrix4();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/renderer",
-  "version": "3.45.7",
+  "version": "3.45.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -42,7 +42,7 @@
     "troika-three-text": "^0.52.5",
     "tslib": "^2.3.0",
     "webgl-memory": "^1.1.3",
-    "@expofp/geometry": "3.45.7"
+    "@expofp/geometry": "3.45.9"
   },
   "devDependencies": {
     "@react-three/test-renderer": "^9.1.0",