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

package/dist/main.js

@@ -5759,8 +5759,13 @@ function dependentComponents(componentOrComponents, dependentMode) {
         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);
@@ -20591,17 +20596,23 @@ exports.Collider = /*#__PURE__*/ function(Component) {
     /**
    * @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
@@ -20633,6 +20644,28 @@ exports.Collider = /*#__PURE__*/ function(Component) {
             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
@@ -20792,6 +20825,9 @@ exports.Collider = __decorate([
         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);
     };
@@ -20894,7 +20930,7 @@ __decorate([
         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;
     /**
@@ -20903,6 +20939,21 @@ __decorate([
         !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(PhysicsMaterial, [
         {
             key: "bounciness",
@@ -20977,6 +21028,9 @@ __decorate([
     ]);
     return PhysicsMaterial;
 }();
+__decorate([
+    ignoreClone
+], PhysicsMaterial.prototype, "_nativeMaterial", void 0);
 
 /**
  * Abstract class for collider shapes.
@@ -21029,6 +21083,16 @@ __decorate([
     };
     /**
    * @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();
@@ -21178,7 +21242,11 @@ __decorate([
     _inherits(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;
@@ -21262,9 +21330,12 @@ __decorate([
         }
         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
@@ -21273,6 +21344,36 @@ __decorate([
             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(MeshColliderShape, [
         {
             key: "cookingFlags",
@@ -21332,15 +21433,25 @@ __decorate([
                     (_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;
                     }
                 }
             }
@@ -21385,6 +21496,27 @@ __decorate([
    */ _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;
+        engineMath.Vector3.transformByQuat(localCoM, transform.worldRotationQuaternion, worldCoM);
+        worldCoM.add(transform.worldPosition);
+        var torque = DynamicCollider._tempVector3_2;
+        engineMath.Vector3.subtract(position, worldCoM, torque);
+        engineMath.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.");
@@ -21418,6 +21550,31 @@ __decorate([
         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;
@@ -21791,6 +21948,8 @@ __decorate([
     return DynamicCollider;
 }(exports.Collider);
 DynamicCollider._tempVector3 = new engineMath.Vector3();
+DynamicCollider._tempVector3_1 = new engineMath.Vector3();
+DynamicCollider._tempVector3_2 = new engineMath.Vector3();
 DynamicCollider._tempQuat = new engineMath.Quaternion();
 __decorate([
     ignoreClone