@galacean/engine-core 0.0.0-experimental-2.0-game.10 → 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);
@@ -11544,7 +11549,6 @@ __decorate([
         if (charLength > 0) {
             this._buildChunk(curTextChunk, charLength);
         }
-        this._setDirtyFlagTrue(4);
         charRenderInfos.length = 0;
     };
     _proto._onTransformChanged = function _onTransformChanged(bit) {
@@ -20592,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
@@ -20634,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
@@ -20793,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);
     };
@@ -20895,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;
     /**
@@ -20904,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",
@@ -20978,6 +21028,9 @@ __decorate([
     ]);
     return PhysicsMaterial;
 }();
+__decorate([
+    ignoreClone
+], PhysicsMaterial.prototype, "_nativeMaterial", void 0);
 
 /**
  * Abstract class for collider shapes.
@@ -21030,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();
@@ -21179,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;
@@ -21263,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
@@ -21274,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",
@@ -21333,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;
                     }
                 }
             }
@@ -21386,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.");
@@ -21419,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;
@@ -21792,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
@@ -24960,7 +25118,7 @@ var spriteFs = "#include <common>\nuniform sampler2D renderer_SpriteTexture;\n\n
 
 var spriteVs = "uniform mat4 renderer_MVPMat;\n\nattribute vec3 POSITION;\nattribute vec2 TEXCOORD_0;\nattribute vec4 COLOR_0;\n\nvarying vec2 v_uv;\nvarying vec4 v_color;\n\nvoid main()\n{\n  gl_Position = renderer_MVPMat * vec4(POSITION, 1.0);\n\n  v_uv = TEXCOORD_0;\n  v_color = COLOR_0;\n}\n"; // eslint-disable-line
 
-var textFs = "uniform sampler2D renderElement_TextTexture;\nuniform vec2 renderElement_TextTextureSize;\nuniform vec4 renderer_OutlineColor;\nuniform float renderer_OutlineWidth;\n\nuniform vec4 renderer_UIRectClipRect;\nuniform float renderer_UIRectClipEnabled;\nuniform vec4 renderer_UIRectClipSoftness;\nuniform float renderer_UIRectClipHardClip;\n\nvarying vec2 v_uv;\nvarying vec4 v_color;\nvarying vec2 v_worldPosition;\n\nfloat getUIRectClipAlpha()\n{\n  vec4 edgeDistance = vec4(\n    v_worldPosition.x - renderer_UIRectClipRect.x,\n    v_worldPosition.y - renderer_UIRectClipRect.y,\n    renderer_UIRectClipRect.z - v_worldPosition.x,\n    renderer_UIRectClipRect.w - v_worldPosition.y\n  );\n  vec4 hardClipFactor = step(vec4(0.0), edgeDistance);\n  vec4 softness = max(renderer_UIRectClipSoftness, vec4(1e-5));\n  vec4 softClipFactor = clamp(edgeDistance / softness, 0.0, 1.0);\n  vec4 useSoftness = step(vec4(1e-5), renderer_UIRectClipSoftness);\n  vec4 clipFactor = mix(hardClipFactor, softClipFactor, useSoftness);\n  return clipFactor.x * clipFactor.y * clipFactor.z * clipFactor.w;\n}\n\nfloat sampleCoverage(vec2 uv)\n{\n  vec4 c = texture2D(renderElement_TextTexture, uv);\n  #ifdef GRAPHICS_API_WEBGL2\n    return c.r;\n  #else\n    return c.a;\n  #endif\n}\n\nvoid main()\n{\n  float rectClipAlpha = 1.0;\n  if (renderer_UIRectClipEnabled > 0.5) {\n    rectClipAlpha = getUIRectClipAlpha();\n  }\n\n  float coverage = sampleCoverage(v_uv);\n  vec4 finalColor;\n\n  if (renderer_OutlineWidth > 0.0) {\n    vec2 texelSize = 1.0 / renderElement_TextTextureSize;\n    vec2 step = texelSize * renderer_OutlineWidth;\n    float outlineCoverage = coverage;\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x,  0.0)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x,  0.0)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( 0.0,  step.y)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( 0.0, -step.y)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x * 0.7071,  step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x * 0.7071,  step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x * 0.7071, -step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x * 0.7071, -step.y * 0.7071)));\n\n    vec3 rgb = mix(renderer_OutlineColor.rgb, v_color.rgb, coverage);\n    float alpha = max(coverage * v_color.a, outlineCoverage * renderer_OutlineColor.a);\n    finalColor = vec4(rgb, alpha);\n  } else {\n    finalColor = vec4(v_color.rgb, v_color.a * coverage);\n  }\n\n  finalColor.a *= rectClipAlpha;\n  if (renderer_UIRectClipEnabled > 0.5 && renderer_UIRectClipHardClip > 0.5 && finalColor.a < 0.001) {\n    discard;\n  }\n  gl_FragColor = finalColor;\n}\n"; // eslint-disable-line
+var textFs = "uniform sampler2D renderElement_TextTexture;\nuniform vec2 renderElement_TextTextureSize;\nuniform vec4 renderer_OutlineColor;\nuniform float renderer_OutlineWidth;\n\nuniform vec4 renderer_UIRectClipRect;\nuniform float renderer_UIRectClipEnabled;\nuniform vec4 renderer_UIRectClipSoftness;\nuniform float renderer_UIRectClipHardClip;\n\nvarying vec2 v_uv;\nvarying vec4 v_color;\nvarying vec2 v_worldPosition;\n\nfloat getUIRectClipAlpha()\n{\n  vec4 edgeDistance = vec4(\n    v_worldPosition.x - renderer_UIRectClipRect.x,\n    v_worldPosition.y - renderer_UIRectClipRect.y,\n    renderer_UIRectClipRect.z - v_worldPosition.x,\n    renderer_UIRectClipRect.w - v_worldPosition.y\n  );\n  vec4 hardClipFactor = step(vec4(0.0), edgeDistance);\n  vec4 softness = max(renderer_UIRectClipSoftness, vec4(1e-5));\n  vec4 softClipFactor = clamp(edgeDistance / softness, 0.0, 1.0);\n  vec4 useSoftness = step(vec4(1e-5), renderer_UIRectClipSoftness);\n  vec4 clipFactor = mix(hardClipFactor, softClipFactor, useSoftness);\n  return clipFactor.x * clipFactor.y * clipFactor.z * clipFactor.w;\n}\n\nfloat sampleCoverage(vec2 uv)\n{\n  vec4 c = texture2D(renderElement_TextTexture, uv);\n  #ifdef GRAPHICS_API_WEBGL2\n    return c.r;\n  #else\n    return c.a;\n  #endif\n}\n\nvoid main()\n{\n  float rectClipAlpha = 1.0;\n  if (renderer_UIRectClipEnabled > 0.5) {\n    rectClipAlpha = getUIRectClipAlpha();\n  }\n\n  float coverage = sampleCoverage(v_uv);\n  vec4 finalColor;\n\n  if (renderer_OutlineWidth > 0.0) {\n    vec2 texelSize = 1.0 / renderElement_TextTextureSize;\n    vec2 step = texelSize * renderer_OutlineWidth;\n    float outlineCoverage = coverage;\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x,  0.0)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x,  0.0)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( 0.0,  step.y)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( 0.0, -step.y)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x * 0.7071,  step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x * 0.7071,  step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2( step.x * 0.7071, -step.y * 0.7071)));\n    outlineCoverage = max(outlineCoverage, sampleCoverage(v_uv + vec2(-step.x * 0.7071, -step.y * 0.7071)));\n\n    vec3 rgb = mix(renderer_OutlineColor.rgb, v_color.rgb, coverage);\n    float alpha = max(coverage, outlineCoverage * renderer_OutlineColor.a) * v_color.a;\n    finalColor = vec4(rgb, alpha);\n  } else {\n    finalColor = vec4(v_color.rgb, v_color.a * coverage);\n  }\n\n  finalColor.a *= rectClipAlpha;\n  if (renderer_UIRectClipEnabled > 0.5 && renderer_UIRectClipHardClip > 0.5 && finalColor.a < 0.001) {\n    discard;\n  }\n  gl_FragColor = finalColor;\n}\n"; // eslint-disable-line
 
 var textVs = "uniform mat4 renderer_MVPMat;\nuniform mat4 renderer_ModelMat;\n\nattribute vec3 POSITION;\nattribute vec2 TEXCOORD_0;\nattribute vec4 COLOR_0;\n\nvarying vec2 v_uv;\nvarying vec4 v_color;\nvarying vec2 v_worldPosition;\n\nvoid main()\n{\n  gl_Position = renderer_MVPMat * vec4(POSITION, 1.0);\n\n  v_uv = TEXCOORD_0;\n  v_color = COLOR_0;\n  v_worldPosition = POSITION.xy;\n}\n"; // eslint-disable-line