@babylonjs/core 5.57.0 → 6.0.0

package/Physics/physicsEngineComponent.d.ts

@@ -1,2 +1,3 @@
 import "./joinedPhysicsEngineComponent";
 import "./v1/physicsEngineComponent";
+import "./v2/physicsEngineComponent";

package/Physics/physicsEngineComponent.js

@@ -1,4 +1,5 @@
 // back compat
 import "./joinedPhysicsEngineComponent.js";
 import "./v1/physicsEngineComponent.js";
+import "./v2/physicsEngineComponent.js";
 //# sourceMappingURL=physicsEngineComponent.js.map

package/Physics/physicsEngineComponent.js.map

@@ -1 +1 @@
-{"version":3,"file":"physicsEngineComponent.js","sourceRoot":"","sources":["../../../../lts/core/generated/Physics/physicsEngineComponent.ts"],"names":[],"mappings":"AAAA,cAAc;AAEd,OAAO,gCAAgC,CAAC;AACxC,OAAO,6BAA6B,CAAC","sourcesContent":["// back compat\r\n\r\nimport \"./joinedPhysicsEngineComponent\";\r\nimport \"./v1/physicsEngineComponent\";\r\n"]}
+{"version":3,"file":"physicsEngineComponent.js","sourceRoot":"","sources":["../../../../lts/core/generated/Physics/physicsEngineComponent.ts"],"names":[],"mappings":"AAAA,cAAc;AAEd,OAAO,gCAAgC,CAAC;AACxC,OAAO,6BAA6B,CAAC;AACrC,OAAO,6BAA6B,CAAC","sourcesContent":["// back compat\r\n\r\nimport \"./joinedPhysicsEngineComponent\";\r\nimport \"./v1/physicsEngineComponent\";\r\nimport \"./v2/physicsEngineComponent\";\r\n"]}

package/Physics/physicsHelper.d.ts

@@ -35,6 +35,7 @@ export declare class PhysicsHelper {
      * @returns A physics radial explosion event, or null
      */
     applyRadialExplosionForce(origin: Vector3, radiusOrEventOptions: number | PhysicsRadialExplosionEventOptions, strength?: number, falloff?: PhysicsRadialImpulseFalloff): Nullable<PhysicsRadialExplosionEvent>;
+    private _applicationForBodies;
     /**
      * Creates a gravitational field
      * @param origin the origin of the gravitational field
@@ -88,11 +89,13 @@ declare class PhysicsRadialExplosionEvent {
     private _getHitData;
     /**
      * Returns the force and contact point of the body or false, if the body is not affected by the force/impulse.
-     * @param body A physics body
+     * @param body A physics body where the transform node is an AbstractMesh
      * @param origin the origin of the explosion
-     * @returns A physics force and contact point, or null
+     * @param data the data of the hit
+     * @param instanceIndex the instance index of the body
+     * @returns if there was a hit
      */
-    getBodyHitData(body: PhysicsBody, origin: Vector3, data: PhysicsHitData): boolean;
+    getBodyHitData(body: PhysicsBody, origin: Vector3, data: PhysicsHitData, instanceIndex?: number): boolean;
     /**
      * Returns the force and contact point of the impostor or false, if the impostor is not affected by the force/impulse.
      * @param impostor A physics imposter
@@ -172,7 +175,7 @@ declare class PhysicsUpdraftEvent {
     private _cylinder;
     private _cylinderPosition;
     private _dataFetched;
-    private static hitData;
+    private static _HitData;
     /**
      * Initializes the physics updraft event
      * @param _scene BabylonJS scene
@@ -380,6 +383,10 @@ export interface PhysicsHitData {
      * The distance from the origin to the contact point
      */
     distanceFromOrigin: number;
+    /**
+     * For an instanced physics body (mesh with thin instances), the index of the thin instance the hit applies to
+     */
+    instanceIndex?: number;
 }
 /**
  * Interface for radial explosion event data
@@ -409,7 +416,7 @@ export interface PhysicsUpdraftEventData {
     /**
      * A cylinder used for the updraft event
      */
-    cylinder: Mesh;
+    cylinder?: Mesh;
 }
 /**
  * Interface for vortex event data

package/Physics/physicsHelper.js

@@ -1,8 +1,57 @@
 import { Logger } from "../Misc/logger.js";
-import { Vector3 } from "../Maths/math.vector.js";
+import { TmpVectors, Vector3 } from "../Maths/math.vector.js";
 import { CreateSphere } from "../Meshes/Builders/sphereBuilder.js";
 import { CreateCylinder } from "../Meshes/Builders/cylinderBuilder.js";
 import { Ray } from "../Culling/ray.js";
+import { PhysicsMotionType } from "./v2/IPhysicsEnginePlugin.js";
+class HelperTools {
+    /*
+     * Gets the hit contact point between a mesh and a ray. The method varies between
+     * the different plugin versions; V1 uses a mesh intersection, V2 uses the physics body instance/object center (to avoid a raycast and improve perf).
+     */
+    static GetContactPointToRef(mesh, origin, direction, result, instanceIndex) {
+        const engine = mesh.getScene().getPhysicsEngine();
+        const pluginVersion = engine === null || engine === void 0 ? void 0 : engine.getPluginVersion();
+        if (pluginVersion === 1) {
+            const ray = new Ray(origin, direction);
+            const hit = ray.intersectsMesh(mesh);
+            if (hit.hit && hit.pickedPoint) {
+                result.copyFrom(hit.pickedPoint);
+                return true;
+            }
+        }
+        else if (pluginVersion === 2) {
+            mesh.physicsBody.getObjectCenterWorldToRef(result, instanceIndex);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if a body will be affected by forces
+     * @param body the body to check
+     * @param instanceIndex for instanced bodies, the index of the instance to check
+     * @returns
+     */
+    static HasAppliedForces(body, instanceIndex) {
+        var _a, _b, _c;
+        return (body.getMotionType(instanceIndex) === PhysicsMotionType.STATIC ||
+            ((_b = (_a = body.getMassProperties(instanceIndex)) === null || _a === void 0 ? void 0 : _a.mass) !== null && _b !== void 0 ? _b : 0) === 0 ||
+            ((_c = body.transformNode) === null || _c === void 0 ? void 0 : _c.getTotalVertices()) === 0);
+    }
+    /**
+     * Checks if a point is inside a cylinder
+     * @param point point to check
+     * @param origin cylinder origin on the bottom
+     * @param radius cylinder radius
+     * @param height cylinder height
+     * @returns
+     */
+    static IsInsideCylinder(point, origin, radius, height) {
+        const distance = TmpVectors.Vector3[0];
+        point.subtractToRef(origin, distance);
+        return Math.abs(distance.x) <= radius && Math.abs(distance.z) <= radius && distance.y >= 0 && distance.y <= height;
+    }
+}
 /**
  * A helper for physics simulations
  * @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
@@ -71,21 +120,9 @@ export class PhysicsHelper {
             event.triggerAffectedImpostorsCallback(affectedImpostorsWithData);
         }
         else {
-            const affectedBodiesWithData = Array();
-            const bodies = this._physicsEngine.getBodies();
-            bodies.forEach((body) => {
-                if (!event.getBodyHitData(body, origin, hitData)) {
-                    return;
-                }
-                body.applyImpulse(hitData.force, hitData.contactPoint);
-                if (useCallback) {
-                    affectedBodiesWithData.push({
-                        body: body,
-                        hitData: this._copyPhysicsHitData(hitData),
-                    });
-                }
+            this._applicationForBodies(event, origin, hitData, useCallback, (body, hitData) => {
+                body.applyImpulse(hitData.force, hitData.contactPoint, hitData.instanceIndex);
             });
-            event.triggerAffectedBodiesCallback(affectedBodiesWithData);
         }
         event.dispose(false);
         return event;
@@ -140,13 +177,22 @@ export class PhysicsHelper {
             event.triggerAffectedImpostorsCallback(affectedImpostorsWithData);
         }
         else {
-            const affectedBodiesWithData = Array();
-            const bodies = this._physicsEngine.getBodies();
-            bodies.forEach((body) => {
-                if (!event.getBodyHitData(body, origin, hitData)) {
+            this._applicationForBodies(event, origin, hitData, useCallback, (body, hitData) => {
+                body.applyForce(hitData.force, hitData.contactPoint, hitData.instanceIndex);
+            });
+        }
+        event.dispose(false);
+        return event;
+    }
+    _applicationForBodies(event, origin, hitData, useCallback, fnApplication) {
+        const affectedBodiesWithData = Array();
+        const bodies = this._physicsEngine.getBodies();
+        for (const body of bodies) {
+            body.iterateOverAllInstances((body, instanceIndex) => {
+                if (!event.getBodyHitData(body, origin, hitData, instanceIndex)) {
                     return;
                 }
-                body.applyForce(hitData.force, hitData.contactPoint);
+                fnApplication(body, hitData);
                 if (useCallback) {
                     affectedBodiesWithData.push({
                         body: body,
@@ -154,10 +200,8 @@ export class PhysicsHelper {
                     });
                 }
             });
-            event.triggerAffectedBodiesCallback(affectedBodiesWithData);
         }
-        event.dispose(false);
-        return event;
+        event.triggerAffectedBodiesCallback(affectedBodiesWithData);
     }
     /**
      * Creates a gravitational field
@@ -253,7 +297,7 @@ export class PhysicsHelper {
         return event;
     }
     _copyPhysicsHitData(data) {
-        return { force: data.force.clone(), contactPoint: data.contactPoint.clone(), distanceFromOrigin: data.distanceFromOrigin };
+        return { force: data.force.clone(), contactPoint: data.contactPoint.clone(), distanceFromOrigin: data.distanceFromOrigin, instanceIndex: data.instanceIndex };
     }
 }
 /**
@@ -282,11 +326,11 @@ class PhysicsRadialExplosionEvent {
         };
     }
     _getHitData(mesh, center, origin, data) {
-        const direction = center.subtract(origin);
-        const ray = new Ray(origin, direction, this._options.radius);
-        const hit = ray.intersectsMesh(mesh);
-        const contactPoint = hit.pickedPoint;
-        if (!contactPoint) {
+        const direction = TmpVectors.Vector3[0];
+        direction.copyFrom(center).subtractInPlace(origin);
+        const contactPoint = TmpVectors.Vector3[1];
+        const hasContactPoint = HelperTools.GetContactPointToRef(mesh, origin, direction, contactPoint, data.instanceIndex);
+        if (!hasContactPoint) {
             return false;
         }
         const distanceFromOrigin = Vector3.Distance(origin, contactPoint);
@@ -294,29 +338,30 @@ class PhysicsRadialExplosionEvent {
             return false;
         }
         const multiplier = this._options.falloff === PhysicsRadialImpulseFalloff.Constant ? this._options.strength : this._options.strength * (1 - distanceFromOrigin / this._options.radius);
-        const force = direction.multiplyByFloats(multiplier, multiplier, multiplier);
-        data.force = force;
-        data.contactPoint = contactPoint;
+        // Direction x multiplier equals force
+        direction.scaleInPlace(multiplier);
+        data.force.copyFrom(direction);
+        data.contactPoint.copyFrom(contactPoint);
         data.distanceFromOrigin = distanceFromOrigin;
         return true;
     }
     /**
      * Returns the force and contact point of the body or false, if the body is not affected by the force/impulse.
-     * @param body A physics body
+     * @param body A physics body where the transform node is an AbstractMesh
      * @param origin the origin of the explosion
-     * @returns A physics force and contact point, or null
+     * @param data the data of the hit
+     * @param instanceIndex the instance index of the body
+     * @returns if there was a hit
      */
-    getBodyHitData(body, origin, data) {
-        if (body.transformNode.getClassName() !== "Mesh" && body.transformNode.getClassName() !== "InstancedMesh") {
+    getBodyHitData(body, origin, data, instanceIndex) {
+        // No force will be applied in these cases, so we skip calculation
+        if (HelperTools.HasAppliedForces(body, instanceIndex)) {
             return false;
         }
         const mesh = body.transformNode;
-        if (!this._intersectsWithSphere(mesh, origin, this._options.radius)) {
-            return false;
-        }
-        const bodyObjectCenter = body.getObjectCenter();
-        this._getHitData(mesh, bodyObjectCenter, origin, data);
-        return true;
+        const bodyObjectCenter = body.getObjectCenterWorld(instanceIndex);
+        data.instanceIndex = instanceIndex;
+        return this._getHitData(mesh, bodyObjectCenter, origin, data);
     }
     /**
      * Returns the force and contact point of the impostor or false, if the impostor is not affected by the force/impulse.
@@ -362,15 +407,17 @@ class PhysicsRadialExplosionEvent {
      * @param force Specifies if the sphere should be disposed by force
      */
     dispose(force = true) {
-        if (force) {
-            this._sphere.dispose();
-        }
-        else {
-            setTimeout(() => {
-                if (!this._dataFetched) {
-                    this._sphere.dispose();
-                }
-            }, 0);
+        if (this._sphere) {
+            if (force) {
+                this._sphere.dispose();
+            }
+            else {
+                setTimeout(() => {
+                    if (!this._dataFetched) {
+                        this._sphere.dispose();
+                    }
+                }, 0);
+            }
         }
     }
     /*** Helpers ***/
@@ -438,6 +485,9 @@ class PhysicsGravitationalFieldEvent {
      * @param force The force to dispose from the gravitational field event
      */
     dispose(force = true) {
+        if (!this._sphere) {
+            return;
+        }
         if (force) {
             this._sphere.dispose();
         }
@@ -450,6 +500,7 @@ class PhysicsGravitationalFieldEvent {
         }
     }
     _tick() {
+        var _a;
         // Since the params won't change, we fetch the event only once
         if (this._sphere) {
             this._physicsHelper.applyRadialExplosionForce(this._origin, this._options);
@@ -457,7 +508,7 @@ class PhysicsGravitationalFieldEvent {
         else {
             const radialExplosionEvent = this._physicsHelper.applyRadialExplosionForce(this._origin, this._options);
             if (radialExplosionEvent) {
-                this._sphere = radialExplosionEvent.getData().sphere.clone("radialExplosionEventSphereClone");
+                this._sphere = (_a = radialExplosionEvent.getData().sphere) === null || _a === void 0 ? void 0 : _a.clone("radialExplosionEventSphereClone");
             }
         }
     }
@@ -488,7 +539,9 @@ class PhysicsUpdraftEvent {
             this._originDirection = this._origin.subtract(this._originTop).normalize();
         }
         this._tickCallback = this._tick.bind(this);
-        this._prepareCylinder();
+        if (this._physicsEngine.getPluginVersion() === 1) {
+            this._prepareCylinder();
+        }
     }
     /**
      * Returns the data related to the updraft event (cylinder).
@@ -523,11 +576,13 @@ class PhysicsUpdraftEvent {
         }
         if (force) {
             this._cylinder.dispose();
+            this._cylinder = undefined;
         }
         else {
             setTimeout(() => {
-                if (!this._dataFetched) {
+                if (!this._dataFetched && this._cylinder) {
                     this._cylinder.dispose();
+                    this._cylinder = undefined;
                 }
             }, 0);
         }
@@ -543,19 +598,19 @@ class PhysicsUpdraftEvent {
         const distanceFromOrigin = Vector3.Distance(this._origin, center);
         const multiplier = this._options.strength * -1;
         const force = direction.multiplyByFloats(multiplier, multiplier, multiplier);
-        data.force = force;
-        data.contactPoint = center;
+        data.force.copyFrom(force);
+        data.contactPoint.copyFrom(center);
         data.distanceFromOrigin = distanceFromOrigin;
     }
-    _getBodyHitData(body, data) {
-        if (body.transformNode.getClassName() !== "Mesh" && body.transformNode.getClassName() !== "InstancedMesh") {
+    _getBodyHitData(body, data, instanceIndex) {
+        if (HelperTools.HasAppliedForces(body)) {
             return false;
         }
-        const bodyObject = body.transformNode;
-        if (!this._intersectsWithCylinder(bodyObject)) {
+        const center = body.getObjectCenterWorld(instanceIndex);
+        if (!HelperTools.IsInsideCylinder(center, this._origin, this._options.radius, this._options.height)) {
             return false;
         }
-        const center = body.getObjectCenter();
+        data.instanceIndex = instanceIndex;
         this._getHitData(center, data);
         return true;
     }
@@ -572,7 +627,7 @@ class PhysicsUpdraftEvent {
         return true;
     }
     _tick() {
-        const hitData = PhysicsUpdraftEvent.hitData;
+        const hitData = PhysicsUpdraftEvent._HitData;
         if (this._physicsEngine.getPluginVersion() === 1) {
             this._physicsEngine.getImpostors().forEach((impostor) => {
                 if (!this._getImpostorHitData(impostor, hitData)) {
@@ -584,10 +639,12 @@ class PhysicsUpdraftEvent {
         else {
             // V2
             this._physicsEngine.getBodies().forEach((body) => {
-                if (!this._getBodyHitData(body, hitData)) {
-                    return;
-                }
-                body.applyForce(hitData.force, hitData.contactPoint);
+                body.iterateOverAllInstances((body, instanceIndex) => {
+                    if (!this._getBodyHitData(body, hitData, instanceIndex)) {
+                        return;
+                    }
+                    body.applyForce(hitData.force, hitData.contactPoint, hitData.instanceIndex);
+                });
             });
         }
     }
@@ -602,11 +659,14 @@ class PhysicsUpdraftEvent {
         }
     }
     _intersectsWithCylinder(mesh) {
+        if (!this._cylinder) {
+            return false;
+        }
         this._cylinder.position = this._cylinderPosition;
         return this._cylinder.intersectsMesh(mesh, true);
     }
 }
-PhysicsUpdraftEvent.hitData = { force: new Vector3(), contactPoint: new Vector3(), distanceFromOrigin: 0 };
+PhysicsUpdraftEvent._HitData = { force: new Vector3(), contactPoint: new Vector3(), distanceFromOrigin: 0 };
 /**
  * Represents a physics vortex event
  */
@@ -629,7 +689,9 @@ class PhysicsVortexEvent {
         this._origin.addToRef(new Vector3(0, this._options.height / 2, 0), this._cylinderPosition);
         this._origin.addToRef(new Vector3(0, this._options.height, 0), this._originTop);
         this._tickCallback = this._tick.bind(this);
-        this._prepareCylinder();
+        if (this._physicsEngine.getPluginVersion() === 1) {
+            this._prepareCylinder();
+        }
     }
     /**
      * Returns the data related to the vortex event (cylinder).
@@ -659,6 +721,9 @@ class PhysicsVortexEvent {
      * @param force
      */
     dispose(force = true) {
+        if (!this._cylinder) {
+            return;
+        }
         if (force) {
             this._cylinder.dispose();
         }
@@ -673,17 +738,19 @@ class PhysicsVortexEvent {
     _getHitData(mesh, center, data) {
         const originOnPlane = PhysicsVortexEvent.originOnPlane;
         originOnPlane.set(this._origin.x, center.y, this._origin.z); // the distance to the origin as if both objects were on a plane (Y-axis)
-        const originToImpostorDirection = center.subtract(originOnPlane);
-        const ray = new Ray(originOnPlane, originToImpostorDirection, this._options.radius);
-        const hit = ray.intersectsMesh(mesh);
-        const contactPoint = hit.pickedPoint;
-        if (!contactPoint) {
+        const originToImpostorDirection = TmpVectors.Vector3[0];
+        center.subtractToRef(originOnPlane, originToImpostorDirection);
+        const contactPoint = TmpVectors.Vector3[1];
+        const hasContactPoint = HelperTools.GetContactPointToRef(mesh, originOnPlane, originToImpostorDirection, contactPoint, data.instanceIndex);
+        if (!hasContactPoint) {
             return false;
         }
-        const absoluteDistanceFromOrigin = hit.distance / this._options.radius;
-        let directionToOrigin = contactPoint.normalize();
+        const distance = Vector3.Distance(contactPoint, originOnPlane);
+        const absoluteDistanceFromOrigin = distance / this._options.radius;
+        const directionToOrigin = TmpVectors.Vector3[2];
+        contactPoint.normalizeToRef(directionToOrigin);
         if (absoluteDistanceFromOrigin > this._options.centripetalForceThreshold) {
-            directionToOrigin = directionToOrigin.negate();
+            directionToOrigin.negateInPlace();
         }
         let forceX;
         let forceY;
@@ -699,24 +766,25 @@ class PhysicsVortexEvent {
             forceY = this._originTop.y * this._options.updraftForceMultiplier;
             forceZ = (perpendicularDirection.z + directionToOrigin.z) * this._options.centrifugalForceMultiplier;
         }
-        let force = new Vector3(forceX, forceY, forceZ);
-        force = force.multiplyByFloats(this._options.strength, this._options.strength, this._options.strength);
-        data.force = force;
-        data.contactPoint = center;
+        const force = TmpVectors.Vector3[3];
+        force.set(forceX, forceY, forceZ);
+        force.scaleInPlace(this._options.strength);
+        data.force.copyFrom(force);
+        data.contactPoint.copyFrom(center);
         data.distanceFromOrigin = absoluteDistanceFromOrigin;
         return true;
     }
-    _getBodyHitData(body, data) {
-        if (body.transformNode.getClassName() !== "Mesh" && body.transformNode.getClassName() !== "InstancedMesh") {
+    _getBodyHitData(body, data, instanceIndex) {
+        if (HelperTools.HasAppliedForces(body, instanceIndex)) {
             return false;
         }
         const bodyObject = body.transformNode;
-        if (!this._intersectsWithCylinder(bodyObject)) {
+        const bodyCenter = body.getObjectCenterWorld(instanceIndex);
+        if (!HelperTools.IsInsideCylinder(bodyCenter, this._origin, this._options.radius, this._options.height)) {
             return false;
         }
-        const bodyCenter = body.getObjectCenter();
-        this._getHitData(bodyObject, bodyCenter, data);
-        return true;
+        data.instanceIndex = instanceIndex;
+        return this._getHitData(bodyObject, bodyCenter, data);
     }
     _getImpostorHitData(impostor, data) {
         if (impostor.mass === 0) {
@@ -745,10 +813,12 @@ class PhysicsVortexEvent {
         }
         else {
             this._physicsEngine.getBodies().forEach((body) => {
-                if (!this._getBodyHitData(body, hitData)) {
-                    return;
-                }
-                body.applyForce(hitData.force, hitData.contactPoint);
+                body.iterateOverAllInstances((body, instanceIndex) => {
+                    if (!this._getBodyHitData(body, hitData, instanceIndex)) {
+                        return;
+                    }
+                    body.applyForce(hitData.force, hitData.contactPoint, hitData.instanceIndex);
+                });
             });
         }
     }