@galacean/engine 0.0.0-experimental-2.0-game.11 → 0.0.0-experimental-2.0-game.12

package/dist/browser.js

@@ -10787,8 +10787,13 @@
             rotation._onValueChanged = target._onRotationChanged;
             // @ts-ignore
             scale._onValueChanged = target._onScaleChanged;
-            // When cloning, other components may obtain properties such as `rotationQuaternion` in the constructor, local related dirty flags need to be corrected
+            // When cloning, other components may obtain properties such as `rotationQuaternion` in the constructor, local related dirty flags need to be corrected.
+            // Earlier in this Entity's construction other components (e.g. DynamicCollider) may have queried
+            // `worldPosition`, which clears the WorldPosition / WorldMatrix dirty flags as a side effect of caching
+            // the computed value. After this _cloneTo writes new local values, those world-derived caches are stale,
+            // so re-dirty them and notify listeners (Collider._updateFlag etc.) so subsequent reads recompute correctly.
             target._setDirtyFlagTrue(2 | 64);
+            target._worldAssociatedChange(444);
         };
         _proto._onLocalMatrixChanging = function _onLocalMatrixChanging() {
             this._setDirtyFlagFalse(64);
@@ -25433,17 +25438,23 @@
         /**
        * @internal
        */ _proto._onUpdate = function _onUpdate() {
+            var shapes = this._shapes;
             if (this._updateFlag.flag) {
                 var transform = this.entity.transform;
-                this._nativeCollider.setWorldTransform(transform.worldPosition, transform.worldRotationQuaternion);
+                this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
                 var worldScale = transform.lossyWorldScale;
-                var shapes = this._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
                     var _shapes_i__nativeShape;
                     (_shapes_i__nativeShape = shapes[i]._nativeShape) == null ? void 0 : _shapes_i__nativeShape.setWorldScale(worldScale);
                 }
                 this._updateFlag.flag = false;
             }
+            // Drive per-shape physics update (e.g. MeshColliderShape retries pending
+            // native shape creation when mesh data becomes accessible asynchronously).
+            // No-op for shape types that don't override `_onPhysicsUpdate`.
+            for(var i1 = 0, n1 = shapes.length; i1 < n1; i1++){
+                shapes[i1]._onPhysicsUpdate();
+            }
         };
         /**
        * @internal
@@ -25475,6 +25486,28 @@
                 this._addNativeShape(this.shapes[i]);
             }
             this._setCollisionLayer();
+            // Teleport native actor to entity's current world pose.
+            // The native actor was created in constructor() with the entity's then-current
+            // worldPosition/Rotation. On clone, the entity's transform fields are deep-cloned
+            // AFTER the Component (and its native actor) are constructed, so the native actor's
+            // pose lags behind the cloned entity transform until this sync.
+            var transform = this.entity.transform;
+            this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+        };
+        /**
+       * Teleport native actor to a world pose (instant, no implied velocity).
+       * Used during initialization paths (clone) where the native actor must be re-aligned
+       * with the entity transform after construction-time pose was based on stale defaults.
+       */ _proto._teleportToEntityTransform = function _teleportToEntityTransform(worldPosition, worldRotation) {
+            this._nativeCollider.setWorldTransform(worldPosition, worldRotation);
+        };
+        /**
+       * Sync entity world transform to native actor for per-frame updates.
+       * Default semantics: teleport (setGlobalPose). Subclasses override to express
+       * physics-aware movement (e.g. DynamicCollider routes kinematic actors through
+       * setKinematicTarget to generate contact events on swept motion).
+       */ _proto._syncEntityTransformToNative = function _syncEntityTransformToNative(worldPosition, worldRotation) {
+            this._nativeCollider.setWorldTransform(worldPosition, worldRotation);
         };
         /**
        * @internal
@@ -25632,6 +25665,9 @@
             this._nativeCollider.setUpDirection(this._upDirection);
             this._nativeCollider.setSlopeLimit(this._slopeLimit);
         };
+        _proto._teleportToEntityTransform = function _teleportToEntityTransform(worldPosition, _worldRotation) {
+            this._nativeCollider.setWorldPosition(worldPosition);
+        };
         _proto._syncWorldPositionFromPhysicalSpace = function _syncWorldPositionFromPhysicalSpace() {
             this._nativeCollider.getWorldPosition(this.entity.transform.worldPosition);
         };
@@ -25731,7 +25767,7 @@
             this._staticFriction = 0.6;
             this._bounceCombine = PhysicsMaterialCombineMode.Average;
             this._frictionCombine = PhysicsMaterialCombineMode.Average;
-            this._nativeMaterial = Engine._nativePhysics.createPhysicsMaterial(this._staticFriction, this._dynamicFriction, this._bounciness, this._bounceCombine, this._frictionCombine);
+            this._nativeMaterial = Engine._nativePhysics.createPhysicsMaterial(this._staticFriction, this._dynamicFriction, this._bounciness, this._frictionCombine, this._bounceCombine);
         }
         var _proto = PhysicsMaterial.prototype;
         /**
@@ -25740,6 +25776,21 @@
             !this._destroyed && this._nativeMaterial.destroy();
             this._destroyed = true;
         };
+        /**
+       * @internal
+       */ _proto._cloneTo = function _cloneTo(target) {
+            target._syncNative();
+        };
+        /**
+       * @internal
+       */ _proto._syncNative = function _syncNative() {
+            var nativeMaterial = this._nativeMaterial;
+            nativeMaterial.setStaticFriction(this._staticFriction);
+            nativeMaterial.setDynamicFriction(this._dynamicFriction);
+            nativeMaterial.setBounciness(this._bounciness);
+            nativeMaterial.setFrictionCombine(this._frictionCombine);
+            nativeMaterial.setBounceCombine(this._bounceCombine);
+        };
         _create_class$2(PhysicsMaterial, [
             {
                 key: "bounciness",
@@ -25814,6 +25865,9 @@
         ]);
         return PhysicsMaterial;
     }();
+    __decorate$1([
+        ignoreClone
+    ], PhysicsMaterial.prototype, "_nativeMaterial", void 0);
     /**
      * Abstract class for collider shapes.
      */ var ColliderShape = /*#__PURE__*/ function() {
@@ -25865,6 +25919,16 @@
         };
         /**
        * @internal
+       *
+       * Called once per physics update tick by `Collider._onUpdate`. Base no-op.
+       *
+       * Subclasses can override for frame-driven maintenance. Currently used by
+       * `MeshColliderShape` to retry native shape creation when mesh data becomes
+       * accessible later or PhysX cooking previously failed due to transient state
+       * (async resource loading, cook pipeline warmup, etc.).
+       */ _proto._onPhysicsUpdate = function _onPhysicsUpdate() {};
+        /**
+       * @internal
        */ _proto._destroy = function _destroy() {
             if (this._nativeShape) {
                 this._nativeShape.destroy();
@@ -26013,7 +26077,11 @@
         _inherits$2(MeshColliderShape, ColliderShape);
         function MeshColliderShape() {
             var _this;
-            _this = ColliderShape.apply(this, arguments) || this, _this._mesh = null, _this._isConvex = false, _this._positions = null, _this._indices = null, _this._cookingFlags = MeshColliderShapeCookingFlag.Cleaning | MeshColliderShapeCookingFlag.VertexWelding, _this._isShapeAttached = false;
+            _this = ColliderShape.apply(this, arguments) || this, _this._mesh = null, _this._isConvex = false, _this._positions = null, _this._indices = null, _this._cookingFlags = MeshColliderShapeCookingFlag.Cleaning | MeshColliderShapeCookingFlag.VertexWelding, _this._isShapeAttached = false, /**
+       * `true` if a native shape creation was attempted but failed (mesh data not yet
+       * accessible, PhysX cooking transient failure, etc.). The `_onPhysicsUpdate` hook
+       * will keep retrying every frame until creation succeeds.
+       */ _this._pendingNativeShapeCreation = false;
             return _this;
         }
         var _proto = MeshColliderShape.prototype;
@@ -26097,9 +26165,12 @@
             }
             var nativeShape = Engine._nativePhysics.createMeshColliderShape(this._id, this._positions, this._indices, this._isConvex, this._material._nativeMaterial, this._cookingFlags);
             if (!nativeShape) {
+                // Cook failed — `_onPhysicsUpdate` will retry next frame
+                this._pendingNativeShapeCreation = true;
                 return;
             }
             this._nativeShape = nativeShape;
+            this._pendingNativeShapeCreation = false;
             // Sync base class properties (position, rotation, contactOffset, isTrigger, material)
             ColliderShape.prototype._syncNative.call(this);
             // If already attached to a collider, add the newly created native shape to it
@@ -26108,6 +26179,36 @@
                 this._attachToCollider();
             }
         };
+        /**
+       * @internal
+       * Retry hook: keep attempting `_createNativeShape` until it succeeds.
+       *
+       * Triggered every physics update tick by `Collider._onUpdate`. Handles the case
+       * where `_cookMesh` fails on first attempt due to PhysX cooking pipeline timing
+       * (the mesh data was extracted successfully at `set mesh` time, but the native
+       * cook call returned null). No-op once a valid native shape exists.
+       *
+       * We DO NOT re-call `_extractMeshData` here — once `set mesh` finished, either:
+       *   - extraction succeeded → `_positions` is populated and we reuse it
+       *   - extraction failed → `_clearMeshData` cleared `_positions`, and `mesh.accessible`
+       *     won't recover (GPU upload is one-way), so re-extracting would fail again
+       */ _proto._onPhysicsUpdate = function _onPhysicsUpdate() {
+            if (!this._pendingNativeShapeCreation || !this._mesh || !this._positions) return;
+            this._createNativeShape();
+        };
+        /**
+       * @internal
+       * After CloneManager deep-copies `_positions` / `_indices` / `_mesh` and remaps `_collider`,
+       * the cloned shape still has no native PhysX shape because `_nativeShape` is `@ignoreClone`.
+       * Cook a fresh native shape now using the already-cloned vertex/index buffers; on transient
+       * cook failure `_createNativeShape` sets `_pendingNativeShapeCreation = true` and
+       * `_onPhysicsUpdate` will retry next tick.
+       */ _proto._cloneTo = function _cloneTo(target) {
+            ColliderShape.prototype._cloneTo.call(this, target);
+            if (target._positions) {
+                target._createNativeShape();
+            }
+        };
         _create_class$2(MeshColliderShape, [
             {
                 key: "cookingFlags",
@@ -26167,15 +26268,25 @@
                         (_this__mesh = this._mesh) == null ? void 0 : _this__mesh._addReferCount(-1);
                         value == null ? void 0 : value._addReferCount(1);
                         this._mesh = value;
-                        if (value && this._extractMeshData(value)) {
-                            if (this._nativeShape) {
-                                this._updateNativeShapeData();
+                        if (value) {
+                            if (this._extractMeshData(value)) {
+                                if (this._nativeShape) {
+                                    this._updateNativeShapeData();
+                                } else {
+                                    this._createNativeShape();
+                                }
+                                // _createNativeShape can fail silently (cookMesh transient failure); mark pending if so
+                                this._pendingNativeShapeCreation = !this._nativeShape;
                             } else {
-                                this._createNativeShape();
+                                // Mesh not yet accessible — keep pending so `_onPhysicsUpdate` retries later
+                                this._destroyNativeShape();
+                                this._clearMeshData();
+                                this._pendingNativeShapeCreation = true;
                             }
                         } else {
                             this._destroyNativeShape();
                             this._clearMeshData();
+                            this._pendingNativeShapeCreation = false;
                         }
                     }
                 }
@@ -26219,6 +26330,27 @@
        */ _proto.applyTorque = function applyTorque(torque) {
             this._phasedActiveInScene && this._nativeCollider.addTorque(torque);
         };
+        /**
+       * Apply a force to the DynamicCollider at a given position in world space.
+       * The force generates both linear acceleration through the center of mass and angular
+       * acceleration about it (torque = (position - centerOfMass) × force).
+       * @param force - The force to apply, in world space
+       * @param position - The position where the force is applied, in world space
+       */ _proto.applyForceAtPosition = function applyForceAtPosition(force, position) {
+            if (!this._phasedActiveInScene) return;
+            var nativeCollider = this._nativeCollider;
+            var localCoM = DynamicCollider._tempVector3;
+            nativeCollider.getCenterOfMass(localCoM);
+            var transform = this.entity.transform;
+            var worldCoM = DynamicCollider._tempVector3_1;
+            Vector3.transformByQuat(localCoM, transform.worldRotationQuaternion, worldCoM);
+            worldCoM.add(transform.worldPosition);
+            var torque = DynamicCollider._tempVector3_2;
+            Vector3.subtract(position, worldCoM, torque);
+            Vector3.cross(torque, force, torque);
+            nativeCollider.addForce(force);
+            nativeCollider.addTorque(torque);
+        };
         _proto.move = function move(positionOrRotation, rotation) {
             if (!this._isKinematic) {
                 console.warn("DynamicCollider: move() is only supported when isKinematic is true.");
@@ -26252,6 +26384,31 @@
             Collider.prototype.addShape.call(this, shape);
         };
         /**
+       * Route per-frame entity → native transform sync to the correct physics API based
+       * on kinematic state.
+       *
+       * PhysX 4.x docs (PxRigidDynamic):
+       *   "If you intend to move a kinematic actor with [setGlobalPose] and want
+       *    collision detection, use setKinematicTarget() instead."
+       *
+       * setGlobalPose is a teleport: PhysX skips contact detection between the old
+       * and new pose, so two kinematic actors moved onto each other via entity.transform
+       * mutation would NOT produce onCollisionEnter / onCollisionStay events even when
+       * scene.kineKineFilteringMode = eKEEP. Routing the per-frame sync through
+       * IDynamicCollider.move() (which the PhysX backend implements as
+       * setKinematicTarget) tells PhysX the actor is animating to the target during the
+       * next simulate(), enabling sweep contact detection for kine-kine and kine-dynamic
+       * pairs alike.
+       *
+       * @internal
+       */ _proto._syncEntityTransformToNative = function _syncEntityTransformToNative(worldPosition, worldRotation) {
+            if (this._isKinematic) {
+                this._nativeCollider.move(worldPosition, worldRotation);
+            } else {
+                Collider.prototype._syncEntityTransformToNative.call(this, worldPosition, worldRotation);
+            }
+        };
+        /**
        * @internal
        */ _proto._onLateUpdate = function _onLateUpdate() {
             var transform = this.entity.transform;
@@ -26625,6 +26782,8 @@
         return DynamicCollider;
     }(exports.Collider);
     DynamicCollider._tempVector3 = new Vector3();
+    DynamicCollider._tempVector3_1 = new Vector3();
+    DynamicCollider._tempVector3_2 = new Vector3();
     DynamicCollider._tempQuat = new Quaternion();
     __decorate$1([
         ignoreClone
@@ -56171,7 +56330,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-2.0-game.11";
+    var version = "0.0.0-experimental-2.0-game.12";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);