@pmndrs/viverse 0.2.26 → 0.2.27

package/dist/physics/world.js

@@ -1,4 +1,4 @@
-import { Box3, BufferGeometry, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, Vector3, } from 'three';
+import { BatchedMesh, Box3, BufferAttribute, BufferGeometry, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, SkinnedMesh, Vector3, } from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { computeBoundsTree, ExtendedTriangle } from 'three-mesh-bvh';
 const rayHelper = new Ray();
@@ -10,15 +10,54 @@ const matrixHelper = new Matrix4();
  * Bakes a mesh's collision geometry into `matrix` space. A bvh only needs positions and (optionally) an index, so
  * everything else is dropped - this keeps the merge below trivial and sidesteps three's "geometries must have the
  * same attributes" restriction that a body mixing meshes with different attribute sets (e.g. gltf primitives) hits.
+ * Positions are read into a fresh float buffer so interleaved or quantized (e.g. meshopt/draco int) source
+ * attributes are de-interleaved and de-quantized - otherwise applyMatrix4 would overflow the source storage and
+ * mergeGeometries would reject the mismatching layouts.
  */
 function bakeCollisionGeometry(mesh, matrix) {
+    const source = mesh.geometry.getAttribute('position');
+    const position = new BufferAttribute(new Float32Array(source.count * 3), 3);
+    for (let i = 0; i < source.count; i++) {
+        position.setXYZ(i, source.getX(i), source.getY(i), source.getZ(i));
+    }
     const geometry = new BufferGeometry();
-    geometry.setAttribute('position', mesh.geometry.getAttribute('position').clone());
+    geometry.setAttribute('position', position);
     if (mesh.geometry.index != null) {
         geometry.setIndex(mesh.geometry.index.clone());
     }
     return geometry.applyMatrix4(matrix);
 }
+/**
+ * A mesh whose positions are actively displaced by morph targets - its resting geometry doesn't match what's drawn,
+ * so (like a skinned mesh) it is skipped rather than baked into a wrong-shaped collider.
+ */
+function isMorphDeformed(mesh) {
+    return (mesh.geometry.morphAttributes.position != null &&
+        (mesh.morphTargetInfluences?.some((influence) => influence !== 0) ?? false));
+}
+/**
+ * Extracts one geometry of a BatchedMesh into a standalone geometry in its local space. A BatchedMesh packs every
+ * geometry into one shared buffer, so a single bvh over that buffer would collide against all of them at once -
+ * instead each geometry gets its own bvh, referenced per instance with the instance's matrix at query time.
+ */
+function extractBatchedCollisionGeometry(mesh, geometryId) {
+    const range = mesh.getGeometryRangeAt(geometryId);
+    if (range == null) {
+        throw new Error(`BvhPhysicsWorld: BatchedMesh has no geometry ${geometryId}`);
+    }
+    const source = mesh.geometry.getAttribute('position');
+    const index = mesh.geometry.index;
+    const start = index != null ? range.indexStart : range.vertexStart;
+    const count = index != null ? range.indexCount : range.vertexCount;
+    const position = new BufferAttribute(new Float32Array(count * 3), 3);
+    for (let i = 0; i < count; i++) {
+        const vertexIndex = index != null ? index.getX(start + i) : start + i;
+        position.setXYZ(i, source.getX(vertexIndex), source.getY(vertexIndex), source.getZ(vertexIndex));
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', position);
+    return geometry;
+}
 export class BvhPhysicsWorld {
     bodies = [];
     sensors = [];
@@ -52,10 +91,14 @@ export class BvhPhysicsWorld {
         //non-indexed meshes apart and turn each group into its own bvh.
         const indexedGeometries = [];
         const nonIndexedGeometries = [];
-        object.traverse((entry) => {
+        //traverseVisible so hidden meshes (toggled decorations, LODs) don't silently become colliders.
+        object.traverseVisible((entry) => {
             if (entry instanceof InstancedMesh) {
                 const bvh = computeBoundsTree.apply(entry.geometry);
-                result.push(...Array.from({ length: entry.instanceMatrix.count }, (_, instanceIndex) => ({
+                result.push(
+                //entry.count (active instances), not instanceMatrix.count (allocated capacity), to avoid phantom
+                //colliders at the stale matrices of unused instance slots.
+                ...Array.from({ length: entry.count }, (_, instanceIndex) => ({
                     object: entry,
                     bvh,
                     instanceIndex,
@@ -63,7 +106,31 @@ export class BvhPhysicsWorld {
                 })));
                 return;
             }
-            if (!(entry instanceof Mesh)) {
+            if (entry instanceof BatchedMesh) {
+                //Each geometry in the batch gets its own bvh, referenced once per visible instance with the instance's
+                //matrix applied at query time (like InstancedMesh). Instances deleted before addBody aren't handled -
+                //three offers no way to enumerate active instances across the gaps a deletion leaves.
+                const geometryBvhs = new Map();
+                for (let instanceIndex = 0; instanceIndex < entry.instanceCount; instanceIndex++) {
+                    if (!entry.getVisibleAt(instanceIndex)) {
+                        continue;
+                    }
+                    const geometryId = entry.getGeometryIdAt(instanceIndex);
+                    let bvh = geometryBvhs.get(geometryId);
+                    if (bvh == null) {
+                        bvh = computeBoundsTree.apply(extractBatchedCollisionGeometry(entry, geometryId));
+                        geometryBvhs.set(geometryId, bvh);
+                    }
+                    result.push({ object: entry, bvh, instanceIndex, isStatic });
+                }
+                return;
+            }
+            //skip skinned and morph-deformed meshes (their shape comes from per-vertex deformation a single baked
+            //matrix can't capture - use a primitive collider) and meshes that have no positions to collide against.
+            if (!(entry instanceof Mesh) ||
+                entry instanceof SkinnedMesh ||
+                isMorphDeformed(entry) ||
+                entry.geometry.getAttribute('position') == null) {
                 return;
             }
             bakeMatrix.copy(entry.matrixWorld);

package/package.json

@@ -21,7 +21,7 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.2.26",
+  "version": "0.2.27",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",