@babylonjs/core 6.11.2 → 6.12.0

package/Physics/v2/Plugins/havokPlugin.d.ts

@@ -423,7 +423,9 @@ export declare class HavokPlugin implements IPhysicsEnginePluginV2 {
      * Adds a child shape to the given shape.
      * @param shape - The parent shape.
      * @param newChild - The child shape to add.
-     * @param childTransform - The transform of the child shape relative to the parent shape.
+     * @param translation - The relative translation of the child from the parent shape
+     * @param rotation - The relative rotation of the child from the parent shape
+     * @param scale - The relative scale scale of the child from the parent shaep
      *
      */
     addChild(shape: PhysicsShape, newChild: PhysicsShape, translation?: Vector3, rotation?: Quaternion, scale?: Vector3): void;
@@ -445,14 +447,14 @@ export declare class HavokPlugin implements IPhysicsEnginePluginV2 {
     /**
      * Calculates the bounding box of a given physics shape.
      *
-     * @param shape - The physics shape to calculate the bounding box for.
+     * @param _shape - The physics shape to calculate the bounding box for.
      * @returns The calculated bounding box.
      *
      * This method is useful for physics engines as it allows to calculate the
      * boundaries of a given shape. Knowing the boundaries of a shape is important
      * for collision detection and other physics calculations.
      */
-    getBoundingBox(shape: PhysicsShape): BoundingBox;
+    getBoundingBox(_shape: PhysicsShape): BoundingBox;
     /**
      * Gets the geometry of a physics body.
      *

package/Physics/v2/Plugins/havokPlugin.js

@@ -4,6 +4,7 @@ import { Logger } from "../../../Misc/logger.js";
 import { PhysicsMaterialCombineMode } from "../physicsMaterial.js";
 import { PhysicsShape } from "../physicsShape.js";
 import { Mesh } from "../../../Meshes/mesh.js";
+import { InstancedMesh } from "../../../Meshes/instancedMesh.js";
 import { VertexBuffer } from "../../../Buffers/buffer.js";
 import { ArrayTools } from "../../../Misc/arrayTools.js";
 import { Observable } from "../../../Misc/observable.js";
@@ -35,17 +36,50 @@ class MeshAccumulator {
      * have a physics impostor. This is useful for creating a physics engine
      * that accurately reflects the mesh and its children.
      */
-    addMesh(mesh, includeChildren) {
-        const indexOffset = this._vertices.length;
-        // Force absoluteScaling to be computed
+    addNodeMeshes(mesh, includeChildren) {
+        // Force absoluteScaling to be computed; we're going to use that to bake
+        // the scale of any parent nodes into this shape, as physics engines
+        // usually use rigid transforms, so can't handle arbitrary scale.
         mesh.computeWorldMatrix(true);
-        const shapeFromBody = TmpVectors.Matrix[0];
-        Matrix.ScalingToRef(mesh.absoluteScaling.x, mesh.absoluteScaling.y, mesh.absoluteScaling.z, shapeFromBody);
+        const rootScaled = TmpVectors.Matrix[0];
+        Matrix.ScalingToRef(mesh.absoluteScaling.x, mesh.absoluteScaling.y, mesh.absoluteScaling.z, rootScaled);
+        if (mesh instanceof Mesh) {
+            this._addMesh(mesh, rootScaled);
+        }
+        else if (mesh instanceof InstancedMesh) {
+            this._addMesh(mesh.sourceMesh, rootScaled);
+        }
+        if (includeChildren) {
+            const worldToRoot = TmpVectors.Matrix[1];
+            mesh.computeWorldMatrix().invertToRef(worldToRoot);
+            const worldToRootScaled = TmpVectors.Matrix[2];
+            worldToRoot.multiplyToRef(rootScaled, worldToRootScaled);
+            const children = mesh.getChildMeshes(false);
+            //  Ignore any children which have a physics body.
+            //  Other plugin implementations do not have this check, which appears to be
+            //  a bug, as otherwise, the mesh will have a duplicate collider
+            children
+                .filter((m) => !m.physicsBody)
+                .forEach((m) => {
+                const childToWorld = m.computeWorldMatrix();
+                const childToRootScaled = TmpVectors.Matrix[3];
+                childToWorld.multiplyToRef(worldToRootScaled, childToRootScaled);
+                if (m instanceof Mesh) {
+                    this._addMesh(m, childToRootScaled);
+                }
+                else if (m instanceof InstancedMesh) {
+                    this._addMesh(m.sourceMesh, childToRootScaled);
+                }
+            });
+        }
+    }
+    _addMesh(mesh, meshToRoot) {
         const vertexData = mesh.getVerticesData(VertexBuffer.PositionKind) || [];
         const numVerts = vertexData.length / 3;
+        const indexOffset = this._vertices.length;
         for (let v = 0; v < numVerts; v++) {
             const pos = new Vector3(vertexData[v * 3 + 0], vertexData[v * 3 + 1], vertexData[v * 3 + 2]);
-            this._vertices.push(Vector3.TransformCoordinates(pos, shapeFromBody));
+            this._vertices.push(Vector3.TransformCoordinates(pos, meshToRoot));
         }
         if (this._collectIndices) {
             const meshIndices = mesh.getIndices();
@@ -65,13 +99,6 @@ class MeshAccumulator {
                 }
             }
         }
-        if (includeChildren) {
-            const children = mesh.getChildMeshes(false);
-            //  Ignore any children which have a physics body.
-            //  Other plugin implementations do not have this check, which appears to be
-            //  a bug, as otherwise, the mesh will have a duplicate collider
-            children.filter((m) => !m.physicsBody).forEach((m) => this.addMesh(m, includeChildren));
-        }
     }
     /**
      * Allocate and populate the vertex positions inside the physics plugin.
@@ -92,10 +119,10 @@ class MeshAccumulator {
             ret[i * 3 + 1] = this._vertices[i].y;
             ret[i * 3 + 2] = this._vertices[i].z;
         }
-        return ret;
+        return { offset: bufferBegin, numObjects: nFloats };
     }
     freeBuffer(plugin, arr) {
-        plugin._free(arr.byteOffset);
+        plugin._free(arr.offset);
     }
     /**
      * Allocate and populate the triangle indices inside the physics plugin
@@ -112,7 +139,7 @@ class MeshAccumulator {
         for (let i = 0; i < this._indices.length; i++) {
             ret[i] = this._indices[i];
         }
-        return ret;
+        return { offset: bufferBegin, numObjects: this._indices.length };
     }
 }
 class BodyPluginData {
@@ -950,16 +977,16 @@ export class HavokPlugin {
                         const includeChildMeshes = !!options.includeChildMeshes;
                         const needIndices = type != PhysicsShapeType.CONVEX_HULL;
                         const accum = new MeshAccumulator(mesh, needIndices, mesh === null || mesh === void 0 ? void 0 : mesh.getScene());
-                        accum.addMesh(mesh, includeChildMeshes);
+                        accum.addNodeMeshes(mesh, includeChildMeshes);
                         const positions = accum.getVertices(this._hknp);
-                        const numVec3s = positions.length / 3;
+                        const numVec3s = positions.numObjects / 3;
                         if (type == PhysicsShapeType.CONVEX_HULL) {
-                            shape._pluginData = this._hknp.HP_Shape_CreateConvexHull(positions.byteOffset, numVec3s)[1];
+                            shape._pluginData = this._hknp.HP_Shape_CreateConvexHull(positions.offset, numVec3s)[1];
                         }
                         else {
                             const triangles = accum.getTriangles(this._hknp);
-                            const numTriangles = triangles.length / 3;
-                            shape._pluginData = this._hknp.HP_Shape_CreateMesh(positions.byteOffset, numVec3s, triangles.byteOffset, numTriangles)[1];
+                            const numTriangles = triangles.numObjects / 3;
+                            shape._pluginData = this._hknp.HP_Shape_CreateMesh(positions.offset, numVec3s, triangles.offset, numTriangles)[1];
                             accum.freeBuffer(this._hknp, triangles);
                         }
                         accum.freeBuffer(this._hknp, positions);
@@ -1051,7 +1078,9 @@ export class HavokPlugin {
      * Adds a child shape to the given shape.
      * @param shape - The parent shape.
      * @param newChild - The child shape to add.
-     * @param childTransform - The transform of the child shape relative to the parent shape.
+     * @param translation - The relative translation of the child from the parent shape
+     * @param rotation - The relative rotation of the child from the parent shape
+     * @param scale - The relative scale scale of the child from the parent shaep
      *
      */
     addChild(shape, newChild, translation, rotation, scale) {
@@ -1084,14 +1113,14 @@ export class HavokPlugin {
     /**
      * Calculates the bounding box of a given physics shape.
      *
-     * @param shape - The physics shape to calculate the bounding box for.
+     * @param _shape - The physics shape to calculate the bounding box for.
      * @returns The calculated bounding box.
      *
      * This method is useful for physics engines as it allows to calculate the
      * boundaries of a given shape. Knowing the boundaries of a shape is important
      * for collision detection and other physics calculations.
      */
-    getBoundingBox(shape) {
+    getBoundingBox(_shape) {
         return {};
     }
     /**