@onerjs/core 8.47.9 → 8.48.2

package/Debug/physicsViewer.d.ts

@@ -2,13 +2,16 @@ import { type Nullable } from "../types.js";
 import { type Scene } from "../scene.js";
 import { type AbstractMesh } from "../Meshes/abstractMesh.js";
 import { Mesh } from "../Meshes/mesh.js";
-import { Vector3 } from "../Maths/math.vector.js";
+import { Matrix, Vector3 } from "../Maths/math.vector.js";
+import { type Material } from "../Materials/material.js";
+import { StandardMaterial } from "../Materials/standardMaterial.js";
 import { type IPhysicsEnginePlugin as IPhysicsEnginePluginV1 } from "../Physics/v1/IPhysicsEnginePlugin.js";
-import { type IPhysicsEnginePluginV2 } from "../Physics/v2/IPhysicsEnginePlugin.js";
+import { type IPhysicsEnginePluginV2, type PhysicsMassProperties } from "../Physics/v2/IPhysicsEnginePlugin.js";
 import { PhysicsImpostor } from "../Physics/v1/physicsImpostor.js";
 import { UtilityLayerRenderer } from "../Rendering/utilityLayerRenderer.js";
 import { type PhysicsBody } from "../Physics/v2/physicsBody.js";
 import { type PhysicsConstraint } from "../Physics/v2/physicsConstraint.js";
+import { TransformNode } from "../Meshes/transformNode.js";
 import "../Physics/joinedPhysicsEngineComponent.js";
 /**
  * Used to show the physics impostor around the specific mesh
@@ -29,7 +32,7 @@ export declare class PhysicsViewer {
     /** @internal */
     protected _inertiaMeshes: Array<Nullable<AbstractMesh>>;
     /** @internal */
-    protected _constraintMeshes: Array<Nullable<Array<AbstractMesh>>>;
+    protected _constraintMeshes: Array<Nullable<Array<TransformNode>>>;
     /** @internal */
     protected _scene: Nullable<Scene>;
     /** @internal */
@@ -42,25 +45,20 @@ export declare class PhysicsViewer {
     protected _numConstraints: number;
     /** @internal */
     protected _physicsEnginePlugin: IPhysicsEnginePluginV1 | IPhysicsEnginePluginV2 | null;
-    private _renderFunction;
-    private _inertiaRenderFunction;
-    private _constraintRenderFunction;
-    private _utilityLayer;
-    private _ownUtilityLayer;
-    private _debugBoxMesh;
-    private _debugSphereMesh;
-    private _debugCapsuleMesh;
-    private _debugCylinderMesh;
-    private _debugMaterial;
-    private _debugInertiaMaterial;
-    private _debugMeshMeshes;
-    private _constraintAxesSize;
-    private _constraintAngularSize;
-    private _localMatrixCache;
-    private _tempVectorCache;
-    private _inertiaMatrixCache;
-    private _transformMatrixCache;
-    private _finalMatrixCache;
+    protected _renderFunction: () => void;
+    protected _inertiaRenderFunction: () => void;
+    protected _constraintRenderFunction: () => void;
+    protected _utilityLayer: Nullable<UtilityLayerRenderer>;
+    protected _ownUtilityLayer: boolean;
+    protected _debugBoxMesh: Mesh;
+    protected _debugSphereMesh: Mesh;
+    protected _debugCapsuleMesh: Mesh;
+    protected _debugCylinderMesh: Mesh;
+    protected _debugMaterial: StandardMaterial;
+    protected _debugInertiaMaterial: StandardMaterial;
+    protected _debugMeshMeshes: Mesh[];
+    protected _constraintAxesSize: number;
+    protected _constraintAngularSize: number;
     /**
      * Creates a new PhysicsViewer
      * @param scene defines the hosting scene
@@ -101,7 +99,7 @@ export declare class PhysicsViewer {
      * @param scaling
      */
     protected _makeScalingUnitInPlace(scaling: Vector3): void;
-    protected _updateDebugConstraint(constraint: PhysicsConstraint, parentingMesh: AbstractMesh): void;
+    protected _updateDebugConstraint(constraint: PhysicsConstraint, parentingMesh: TransformNode): void;
     /**
      * Renders a specified physic impostor
      * @param impostor defines the impostor to render
@@ -130,7 +128,7 @@ export declare class PhysicsViewer {
      * @param constraint the physics constraint to show
      * @returns the debug mesh, or null if the constraint is already shown
      */
-    showConstraint(constraint: PhysicsConstraint): Nullable<AbstractMesh>;
+    showConstraint(constraint: PhysicsConstraint): Nullable<TransformNode>;
     /**
      * Hides an impostor from the scene.
      * @param impostor - The impostor to hide.
@@ -163,15 +161,15 @@ export declare class PhysicsViewer {
      * @param constraint the constraint to hide
      */
     hideConstraint(constraint: Nullable<PhysicsConstraint>): void;
-    private _getDebugMaterial;
-    private _getDebugInertiaMaterial;
-    private _getDebugAxisColoredMaterial;
-    private _getDebugBoxMesh;
-    private _getDebugSphereMesh;
-    private _getDebugCapsuleMesh;
-    private _getDebugCylinderMesh;
-    private _getDebugMeshMesh;
-    private _getDebugMesh;
+    protected _getDebugMaterial(scene: Scene): Material;
+    protected _getDebugInertiaMaterial(scene: Scene): Material;
+    protected _getDebugAxisColoredMaterial(axisNumber: number, scene: Scene): Material;
+    protected _getDebugBoxMesh(scene: Scene): AbstractMesh;
+    protected _getDebugSphereMesh(scene: Scene): AbstractMesh;
+    protected _getDebugCapsuleMesh(scene: Scene): AbstractMesh;
+    protected _getDebugCylinderMesh(scene: Scene): AbstractMesh;
+    protected _getDebugMeshMesh(mesh: Mesh, scene: Scene): AbstractMesh;
+    protected _getDebugMesh(impostor: PhysicsImpostor, targetMesh?: Mesh): Nullable<AbstractMesh>;
     /**
      * Creates a debug mesh for a given physics body
      * @param body The physics body to create the debug mesh for
@@ -182,13 +180,13 @@ export declare class PhysicsViewer {
      * of the geometry of the body. The mesh is then assigned a debug material from the utility layer scene.
      * This allows for visualizing the physics body in the scene.
      */
-    private _getDebugBodyMesh;
-    private _getMeshDebugInertiaMatrixToRef;
-    private _getDebugInertiaMesh;
-    private _getTransformFromBodyToRef;
-    private _createAngularConstraintMesh;
-    private _createCage;
-    private _getDebugConstraintMesh;
+    protected _getDebugBodyMesh(body: PhysicsBody): Nullable<AbstractMesh>;
+    protected _getMeshDebugInertiaMatrixToRef(massProps: PhysicsMassProperties, matrix: Matrix): Matrix;
+    protected _getDebugInertiaMesh(body: PhysicsBody): Nullable<AbstractMesh>;
+    protected _getTransformFromBodyToRef(body: PhysicsBody, matrix: Matrix, instanceIndex?: number): Matrix;
+    protected _createAngularConstraintMesh(minLimit: number, maxLimit: number, axisNumber: number, parent: TransformNode, scene: Scene): TransformNode;
+    protected _createCage(parent: TransformNode, scene: Scene): AbstractMesh;
+    protected _getDebugConstraintMesh(constraint: PhysicsConstraint): Nullable<Array<TransformNode>>;
     /**
      * Clean up physics debug display
      */

package/Debug/physicsViewer.js

@@ -55,11 +55,6 @@ export class PhysicsViewer {
         this._debugMeshMeshes = new Array();
         this._constraintAxesSize = 0.4;
         this._constraintAngularSize = 0.4;
-        this._localMatrixCache = Matrix.Identity();
-        this._tempVectorCache = Vector3.Zero();
-        this._inertiaMatrixCache = Matrix.Identity();
-        this._transformMatrixCache = Matrix.Identity();
-        this._finalMatrixCache = Matrix.Identity();
         this._scene = scene || EngineStore.LastCreatedScene;
         if (!this._scene) {
             return;
@@ -161,30 +156,33 @@ export class PhysicsViewer {
         }
     }
     _updateDebugInertia(body, inertiaMesh) {
+        const inertiaMatrixRef = Matrix.Identity();
+        const transformMatrixRef = Matrix.Identity();
+        const finalMatrixRef = Matrix.Identity();
         if (body._pluginDataInstances.length) {
             const inertiaAsMesh = inertiaMesh;
             const inertiaMeshMatrixData = inertiaAsMesh._thinInstanceDataStorage.matrixData;
             const bodyTransformMatrixData = body.transformNode._thinInstanceDataStorage.matrixData;
             for (let i = 0; i < body._pluginDataInstances.length; i++) {
                 const props = body.getMassProperties(i);
-                this._getMeshDebugInertiaMatrixToRef(props, this._inertiaMatrixCache);
-                Matrix.FromArrayToRef(bodyTransformMatrixData, i * 16, this._transformMatrixCache);
-                this._inertiaMatrixCache.multiplyToRef(this._transformMatrixCache, this._finalMatrixCache);
-                this._finalMatrixCache.copyToArray(inertiaMeshMatrixData, i * 16);
+                this._getMeshDebugInertiaMatrixToRef(props, inertiaMatrixRef);
+                Matrix.FromArrayToRef(bodyTransformMatrixData, i * 16, transformMatrixRef);
+                inertiaMatrixRef.multiplyToRef(transformMatrixRef, finalMatrixRef);
+                finalMatrixRef.copyToArray(inertiaMeshMatrixData, i * 16);
             }
             inertiaAsMesh.thinInstanceBufferUpdated("matrix");
         }
         else {
             const props = body.getMassProperties();
-            this._getMeshDebugInertiaMatrixToRef(props, this._inertiaMatrixCache);
-            body.transformNode.rotationQuaternion?.toRotationMatrix(this._transformMatrixCache);
-            this._transformMatrixCache.setTranslation(body.transformNode.position);
+            this._getMeshDebugInertiaMatrixToRef(props, inertiaMatrixRef);
+            body.transformNode.rotationQuaternion?.toRotationMatrix(transformMatrixRef);
+            transformMatrixRef.setTranslation(body.transformNode.position);
             if (body.transformNode.parent) {
                 const parentTransform = body.transformNode.parent.computeWorldMatrix(true);
-                this._transformMatrixCache.multiplyToRef(parentTransform, this._transformMatrixCache);
+                transformMatrixRef.multiplyToRef(parentTransform, transformMatrixRef);
             }
-            this._inertiaMatrixCache.multiplyToRef(this._transformMatrixCache, this._inertiaMatrixCache);
-            this._inertiaMatrixCache.decomposeToTransformNode(inertiaMesh);
+            inertiaMatrixRef.multiplyToRef(transformMatrixRef, inertiaMatrixRef);
+            inertiaMatrixRef.decomposeToTransformNode(inertiaMesh);
         }
     }
     _updateDebugConstraints() {
@@ -221,18 +219,11 @@ export class PhysicsViewer {
         if (!pivotA || !pivotB || !axisA || !axisB || !perpAxisA || !perpAxisB) {
             return;
         }
-        const childNodes = parentingMesh.getChildMeshes(false);
-        for (const parentConstraintMesh of childNodes) {
-            if (!(parentConstraintMesh instanceof TransformNode)) {
-                continue;
-            }
-            // Get the direct children of parentOfPair
-            const directChildren = parentConstraintMesh.getChildren((node) => node instanceof TransformNode, true);
-            const parentCoordSystemNode = directChildren.find((child) => child.name === "parentCoordSystem");
-            const childCoordSystemNode = directChildren.find((child) => child.name === "childCoordSystem");
-            if (!parentCoordSystemNode || !childCoordSystemNode) {
-                continue;
-            }
+        const descendants = parentingMesh.getDescendants(true);
+        for (const parentConstraintMesh of descendants) {
+            // Get the parent transform
+            const parentCoordSystemNode = parentConstraintMesh.getDescendants(true)[0];
+            const childCoordSystemNode = parentConstraintMesh.getDescendants(true)[1];
             const { parentBody, parentBodyIndex } = parentCoordSystemNode.metadata;
             const { childBody, childBodyIndex } = childCoordSystemNode.metadata;
             const parentTransform = this._getTransformFromBodyToRef(parentBody, TmpVectors.Matrix[0], parentBodyIndex);
@@ -242,56 +233,13 @@ export class PhysicsViewer {
             childTransform.decomposeToTransformNode(childCoordSystemNode);
             this._makeScalingUnitInPlace(childCoordSystemNode.scaling);
             // Create a transform node and set its matrix
-            const parentTransformNodeChildren = parentCoordSystemNode.getChildren((node) => node instanceof TransformNode, true);
-            const parentTransformNode = parentTransformNodeChildren[0];
+            const parentTransformNode = parentCoordSystemNode.getDescendants(true)[0];
             parentTransformNode.position.copyFrom(pivotA);
-            const childTransformNodeChildren = childCoordSystemNode.getChildren((node) => node instanceof TransformNode, true);
-            const childTransformNode = childTransformNodeChildren[0];
+            const childTransformNode = childCoordSystemNode.getDescendants(true)[0];
             childTransformNode.position.copyFrom(pivotB);
             // Get the transform to align the XYZ axes to the constraint axes
             Quaternion.FromRotationMatrixToRef(Matrix.FromXYZAxesToRef(axisA, perpAxisA, Vector3.CrossToRef(axisA, perpAxisA, TmpVectors.Vector3[0]), TmpVectors.Matrix[0]), parentTransformNode.rotationQuaternion);
             Quaternion.FromRotationMatrixToRef(Matrix.FromXYZAxesToRef(axisB, perpAxisB, Vector3.CrossToRef(axisB, perpAxisB, TmpVectors.Vector3[1]), TmpVectors.Matrix[1]), childTransformNode.rotationQuaternion);
-            // Sync angular constraint meshes with child body transform
-            const allDescendants = parentConstraintMesh.getDescendants(true);
-            for (const descendant of allDescendants) {
-                if (descendant.metadata?.childBody) {
-                    const { childBody, axisNumber } = descendant.metadata;
-                    if (childBody.transformNode) {
-                        const childWorldMatrix = childBody.transformNode.getWorldMatrix();
-                        const childWorldMatrixInverse = TmpVectors.Matrix[2];
-                        childWorldMatrix.invertToRef(childWorldMatrixInverse);
-                        childWorldMatrixInverse.multiplyToRef(childTransform, this._localMatrixCache);
-                        const position = TmpVectors.Vector3[0];
-                        const rotation = TmpVectors.Quaternion[0];
-                        const scaling = TmpVectors.Vector3[1];
-                        this._localMatrixCache.decompose(scaling, rotation, position);
-                        position.addToRef(pivotB, this._tempVectorCache);
-                        descendant.position.copyFrom(this._tempVectorCache);
-                        const worldRotation = TmpVectors.Quaternion[1];
-                        childBody.transformNode.getWorldMatrix().getRotationQuaternionToRef(worldRotation);
-                        worldRotation.multiplyToRef(descendant.rotationQuaternion, TmpVectors.Quaternion[2]);
-                        TmpVectors.Quaternion[2].copyFrom(descendant.rotationQuaternion);
-                        const parentScaling = childBody.transformNode.absoluteScaling;
-                        switch (axisNumber) {
-                            case 0:
-                                descendant.scaling.x = 1 / parentScaling.x;
-                                descendant.scaling.y = 1 / parentScaling.z;
-                                descendant.scaling.z = 1 / parentScaling.y;
-                                break;
-                            case 1:
-                                descendant.scaling.x = 1 / parentScaling.z;
-                                descendant.scaling.y = 1 / parentScaling.y;
-                                descendant.scaling.z = 1 / parentScaling.x;
-                                break;
-                            case 2:
-                                descendant.scaling.x = 1 / parentScaling.x;
-                                descendant.scaling.y = 1 / parentScaling.z;
-                                descendant.scaling.z = 1 / parentScaling.y;
-                                break;
-                        }
-                    }
-                }
-            }
         }
     }
     /**
@@ -533,7 +481,6 @@ export class PhysicsViewer {
             return;
         }
         let removed = false;
-        const utilityLayerScene = this._utilityLayer.utilityLayerScene;
         for (let i = 0; i < this._numConstraints; i++) {
             if (this._constraints[i] === constraint) {
                 const meshes = this._constraintMeshes[i];
@@ -541,7 +488,6 @@ export class PhysicsViewer {
                     continue;
                 }
                 for (const mesh of meshes) {
-                    utilityLayerScene.removeMesh(mesh);
                     mesh.dispose();
                 }
                 this._constraints.splice(i, 1);
@@ -809,25 +755,40 @@ export class PhysicsViewer {
             return matrix.copyFrom(tnode.getWorldMatrix());
         }
     }
-    _createAngularConstraintMesh(minLimit, maxLimit, axisNumber, childBody, childBodyIndex, scene) {
+    _createAngularConstraintMesh(minLimit, maxLimit, axisNumber, parent, scene) {
         const arcAngle = (maxLimit - minLimit) / (Math.PI * 2);
         const mesh = MeshBuilder.CreateCylinder("ConstraintCylinder", { height: 0.0001, diameter: 3 * this._constraintAngularSize, arc: arcAngle }, scene);
+        const root = new TransformNode("angular_root", scene);
+        root.metadata = { bodyNode: parent };
         mesh.material = this._getDebugAxisColoredMaterial(axisNumber, scene);
-        mesh.metadata = { childBody, childBodyIndex, axisNumber, minLimit };
-        mesh.rotationQuaternion = Quaternion.Identity();
+        parent.getWorldMatrix().decomposeToTransformNode(root);
+        mesh.parent = root;
+        const parentScaling = parent.absoluteScaling;
         switch (axisNumber) {
             case 0:
                 mesh.rotation.z = Math.PI * 0.5;
                 mesh.rotation.x = -minLimit + Math.PI * 0.5;
+                // scaling on y,z
+                mesh.scaling.x = 1 / parentScaling.x;
+                mesh.scaling.y = 1 / parentScaling.z;
+                mesh.scaling.z = 1 / parentScaling.y;
                 break;
             case 1:
                 mesh.rotation.y = Math.PI * 1.5 + minLimit;
+                // flip x,z
+                mesh.scaling.x = 1 / parentScaling.z;
+                mesh.scaling.y = 1 / parentScaling.y;
+                mesh.scaling.z = 1 / parentScaling.x;
                 break;
             case 2:
                 mesh.rotation.x = Math.PI * 0.5;
+                // flip z,y
+                mesh.scaling.x = 1 / parentScaling.x;
+                mesh.scaling.y = 1 / parentScaling.z;
+                mesh.scaling.z = 1 / parentScaling.y;
                 break;
         }
-        return mesh;
+        return root;
     }
     _createCage(parent, scene) {
         const cage = MeshBuilder.CreateBox("cage", { size: 1 }, scene);
@@ -864,9 +825,6 @@ export class PhysicsViewer {
             // Create a mesh to keep the pair of constraint axes
             const parentOfPair = new TransformNode("parentOfPair", utilityLayerScene);
             parentOfPair.parent = parentingMesh;
-            // Create a container for angular constraint meshes within this pair
-            const angularConstraintContainer = new TransformNode("angularConstraintContainer", utilityLayerScene);
-            angularConstraintContainer.parent = parentOfPair;
             const { parentBody, parentBodyIndex, childBody, childBodyIndex } = bodyPairInfo;
             // Get the parent transform
             const parentTransform = this._getTransformFromBodyToRef(parentBody, TmpVectors.Matrix[0], parentBodyIndex);
@@ -900,6 +858,7 @@ export class PhysicsViewer {
             // Create axes for the constraint
             const parentAxes = new AxesViewer(utilityLayerScene, this._constraintAxesSize);
             parentAxes.xAxis.parent = parentTransformNode;
+            // parentAxes.xAxis.isPi
             parentAxes.yAxis.parent = parentTransformNode;
             parentAxes.zAxis.parent = parentTransformNode;
             const childAxes = new AxesViewer(utilityLayerScene, this._constraintAxesSize);
@@ -957,8 +916,7 @@ export class PhysicsViewer {
                         maxLimit = engine.getAxisMaxLimit(constraint, axis);
                     }
                     if (axisMode != 2 /* PhysicsConstraintAxisLimitMode.LOCKED */ && constraint.options.pivotB) {
-                        const mesh = this._createAngularConstraintMesh(minLimit, maxLimit, axisIndex, childBody, childBodyIndex, utilityLayerScene);
-                        mesh.parent = angularConstraintContainer;
+                        const mesh = this._createAngularConstraintMesh(minLimit, maxLimit, axisIndex, childBody.transformNode, utilityLayerScene);
                         mesh.position.copyFrom(constraint.options.pivotB);
                         parentedConstraintMeshes.push(mesh);
                     }