@galacean/engine-core 0.0.0-experimental-2.0-game.13 → 0.0.0-experimental-2.0-game.14

package/dist/main.js

@@ -7360,7 +7360,7 @@ var particle_common = "vec3 rotationByQuaternions(in vec3 v, in vec4 q) {\n    r
 
 var velocity_over_lifetime_module = "#if defined(RENDERER_VOL_CONSTANT_MODE) || defined(RENDERER_VOL_CURVE_MODE)\n    #define _VOL_MODULE_ENABLED\n#endif\n\n#ifdef _VOL_MODULE_ENABLED\n    uniform int renderer_VOLSpace;\n\n    #ifdef RENDERER_VOL_CONSTANT_MODE\n        uniform vec3 renderer_VOLMaxConst;\n\n         #ifdef RENDERER_VOL_IS_RANDOM_TWO\n            uniform vec3 renderer_VOLMinConst;\n        #endif\n    #endif\n\n    #ifdef RENDERER_VOL_CURVE_MODE\n        uniform vec2 renderer_VOLMaxGradientX[4]; // x:time y:value\n        uniform vec2 renderer_VOLMaxGradientY[4]; // x:time y:value\n        uniform vec2 renderer_VOLMaxGradientZ[4]; // x:time y:value\n\n        #ifdef RENDERER_VOL_IS_RANDOM_TWO\n            uniform vec2 renderer_VOLMinGradientX[4]; // x:time y:value\n            uniform vec2 renderer_VOLMinGradientY[4]; // x:time y:value\n            uniform vec2 renderer_VOLMinGradientZ[4]; // x:time y:value\n        #endif\n    #endif\n\n\n    vec3 computeVelocityPositionOffset(in float normalizedAge, in float age, out vec3 currentVelocity) {\n        vec3 velocityPosition;\n\n        #ifdef RENDERER_VOL_CONSTANT_MODE\n            currentVelocity = renderer_VOLMaxConst;\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                currentVelocity = mix(renderer_VOLMinConst, currentVelocity, a_Random1.yzw);\n            #endif\n\n            velocityPosition = currentVelocity * age;\n        #endif\n\n        #ifdef RENDERER_VOL_CURVE_MODE\n            velocityPosition = vec3(\n            evaluateParticleCurveCumulative(renderer_VOLMaxGradientX, normalizedAge, currentVelocity.x),\n            evaluateParticleCurveCumulative(renderer_VOLMaxGradientY, normalizedAge, currentVelocity.y),\n            evaluateParticleCurveCumulative(renderer_VOLMaxGradientZ, normalizedAge, currentVelocity.z));\n\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vec3 minCurrentVelocity;\n                vec3 minVelocityPosition = vec3(\n                    evaluateParticleCurveCumulative(renderer_VOLMinGradientX, normalizedAge, minCurrentVelocity.x),\n                    evaluateParticleCurveCumulative(renderer_VOLMinGradientY, normalizedAge, minCurrentVelocity.y),\n                    evaluateParticleCurveCumulative(renderer_VOLMinGradientZ, normalizedAge, minCurrentVelocity.z));\n\n                currentVelocity = mix(minCurrentVelocity, currentVelocity, a_Random1.yzw);\n                velocityPosition = mix(minVelocityPosition, velocityPosition, a_Random1.yzw);\n            #endif\n\n            velocityPosition *= vec3(a_ShapePositionStartLifeTime.w);\n        #endif\n        return velocityPosition;\n    }\n#endif\n"; // eslint-disable-line
 
-var rotation_over_lifetime_module = "#if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n    #ifdef RENDERER_ROL_CURVE_MODE\n        uniform vec2 renderer_ROLMaxCurveZ[4];\n        #ifdef RENDERER_ROL_IS_SEPARATE\n            uniform vec2 renderer_ROLMaxCurveX[4];\n            uniform vec2 renderer_ROLMaxCurveY[4];\n        #endif\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec2 renderer_ROLMinCurveZ[4];\n            #ifdef RENDERER_ROL_IS_SEPARATE\n                uniform vec2 renderer_ROLMinCurveX[4];\n                uniform vec2 renderer_ROLMinCurveY[4];\n            #endif\n        #endif\n    #else\n        uniform vec3 renderer_ROLMaxConst;\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec3 renderer_ROLMinConst;\n        #endif\n    #endif\n#endif\n\nfloat computeParticleRotationFloat(in float rotation, in float age, in float normalizedAge) {\n    #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #else\n            float lifeRotation = renderer_ROLMaxConst.z;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(renderer_ROLMinConst.z, lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * age;\n        #endif\n    #endif\n    return rotation;\n}\n\n\n#if defined(RENDERER_MODE_MESH) && (defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE))\nvec3 computeParticleRotationVec3(in vec3 rotation, in float age, in float normalizedAge) {\n    #ifdef RENDERER_ROL_IS_SEPARATE\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                vec3 ageRot = mix(renderer_ROLMinConst, renderer_ROLMaxConst, a_Random0.w) * age;\n            #else\n                vec3 ageRot = renderer_ROLMaxConst * age;\n            #endif\n            rotation += ageRot;\n        #endif\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifetime = a_ShapePositionStartLifeTime.w;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                rotation += vec3(\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveX, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveY, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue), a_Random0.w)) * lifetime;\n            #else\n                rotation += vec3(\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue)) * lifetime;\n            #endif\n        #endif\n    #else\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                float ageRot = mix(renderer_ROLMinConst.z, renderer_ROLMaxConst.z, a_Random0.w) * age;\n            #else\n                float ageRot = renderer_ROLMaxConst.z * age;\n            #endif\n            rotation += ageRot;\n        #endif\n\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #endif\n    #endif\n    return rotation;\n}\n#endif\n"; // eslint-disable-line
+var rotation_over_lifetime_module = "#if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n    #ifdef RENDERER_ROL_CURVE_MODE\n        uniform vec2 renderer_ROLMaxCurveZ[4];\n        #ifdef RENDERER_ROL_IS_SEPARATE\n            uniform vec2 renderer_ROLMaxCurveX[4];\n            uniform vec2 renderer_ROLMaxCurveY[4];\n        #endif\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec2 renderer_ROLMinCurveZ[4];\n            #ifdef RENDERER_ROL_IS_SEPARATE\n                uniform vec2 renderer_ROLMinCurveX[4];\n                uniform vec2 renderer_ROLMinCurveY[4];\n            #endif\n        #endif\n    #else\n        uniform vec3 renderer_ROLMaxConst;\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec3 renderer_ROLMinConst;\n        #endif\n    #endif\n#endif\n\nfloat computeParticleRotationFloat(in float rotation, in float age, in float normalizedAge) {\n    #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #else\n            float lifeRotation = renderer_ROLMaxConst.z;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(renderer_ROLMinConst.z, lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * age;\n        #endif\n    #endif\n    return rotation;\n}\n\n\n#if defined(RENDERER_MODE_MESH) && (defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE))\nvec3 computeParticleRotationVec3(in vec3 rotation, in float age, in float normalizedAge) {\n    #ifdef RENDERER_ROL_IS_SEPARATE\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                vec3 ageRot = mix(renderer_ROLMinConst, renderer_ROLMaxConst, a_Random0.w) * age;\n            #else\n                vec3 ageRot = renderer_ROLMaxConst * age;\n            #endif\n            rotation += ageRot;\n        #endif\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifetime = a_ShapePositionStartLifeTime.w;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                rotation += vec3(\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveX, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveY, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue), a_Random0.w)) * lifetime;\n            #else\n                rotation += vec3(\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue)) * lifetime;\n            #endif\n        #endif\n    #else\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                float ageRot = mix(renderer_ROLMinConst.z, renderer_ROLMaxConst.z, a_Random0.w) * age;\n            #else\n                float ageRot = renderer_ROLMaxConst.z * age;\n            #endif\n            rotation.z += ageRot;\n        #endif\n\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation.z += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #endif\n    #endif\n    return rotation;\n}\n#endif\n"; // eslint-disable-line
 
 var size_over_lifetime_module = "#ifdef RENDERER_SOL_CURVE_MODE\n    uniform vec2 renderer_SOLMaxCurveX[4]; // x:time y:value\n    #ifdef RENDERER_SOL_IS_SEPARATE\n        uniform vec2 renderer_SOLMaxCurveY[4]; // x:time y:value\n        uniform vec2 renderer_SOLMaxCurveZ[4]; // x:time y:value\n    #endif\n\n    #ifdef RENDERER_SOL_IS_RANDOM_TWO\n        uniform vec2 renderer_SOLMinCurveX[4]; // x:time y:value\n        #ifdef RENDERER_SOL_IS_SEPARATE\n            uniform vec2 renderer_SOLMinCurveY[4]; // x:time y:value\n            uniform vec2 renderer_SOLMinCurveZ[4]; // x:time y:value\n        #endif\n    #endif\n#endif\n\nvec2 computeParticleSizeBillboard(in vec2 size, in float normalizedAge) {\n    #ifdef RENDERER_SOL_CURVE_MODE\n        float lifeSizeX = evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge);\n        #ifdef RENDERER_SOL_IS_RANDOM_TWO\n            lifeSizeX = mix(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge), lifeSizeX, a_Random0.z);\n        #endif\n\n        #ifdef RENDERER_SOL_IS_SEPARATE\n            float lifeSizeY = evaluateParticleCurve(renderer_SOLMaxCurveY, normalizedAge);\n            #ifdef RENDERER_SOL_IS_RANDOM_TWO\n                lifeSizeY = mix(evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge), lifeSizeY, a_Random0.z);\n            #endif\n            size *= vec2(lifeSizeX, lifeSizeY);\n        #else\n            size *= lifeSizeX;\n        #endif\n    #endif\n    return size;\n}\n\n#ifdef RENDERER_MODE_MESH\n    vec3 computeParticleSizeMesh(in vec3 size, in float normalizedAge) {\n        #ifdef RENDERER_SOL_CURVE\n            size *= evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge);\n        #endif\n        #ifdef RENDERER_SOL_RANDOM_CURVES\n            size *= mix(evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge),\n            evaluateParticleCurve(u_SOLSizeGradientMax, normalizedAge),\n            a_Random0.z);\n        #endif\n        #ifdef RENDERER_SOL_CURVE_SEPARATE\n            size *= vec3(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge),\n            evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge),\n            evaluateParticleCurve(renderer_SOLMinCurveZ, normalizedAge));\n        #endif\n        #ifdef RENDERER_SOL_RANDOM_CURVES_SEPARATE\n            size *= vec3(mix(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge),\n                    evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge),\n                    a_Random0.z),\n            mix(evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge),\n                evaluateParticleCurve(renderer_SOLMaxCurveY, normalizedAge),\n                a_Random0.z),\n            mix(evaluateParticleCurve(renderer_SOLMinCurveZ, normalizedAge),\n                evaluateParticleCurve(renderer_SOLMaxCurveZ, normalizedAge),\n                a_Random0.z));\n        #endif\n        return size;\n    }\n#endif"; // eslint-disable-line
 
@@ -20559,7 +20559,13 @@ exports.Collider = /*#__PURE__*/ function(Component) {
     _inherits(Collider, Component);
     function Collider(entity) {
         var _this;
-        _this = Component.call(this, entity) || this, /** @internal */ _this._index = -1, _this._shapes = [], _this._collisionLayerIndex = 0;
+        _this = Component.call(this, entity) || this, /** @internal */ _this._index = -1, _this._shapes = [], _this._collisionLayerIndex = 0, /**
+   * Disabling a collider only detaches its native actor from the simulation
+   * scene; the actor is not destroyed, so on re-enable it still holds its
+   * pre-disable pose. The first transform sync after (re-)enable must teleport,
+   * never sweep — otherwise a kinematic actor drags across the scene from that
+   * stale pose and fires spurious contacts along the path.
+   */ _this._pendingReenterTeleport = false;
         _this._updateFlag = entity.registerWorldChangeFlag();
         return _this;
     }
@@ -20603,9 +20609,14 @@ exports.Collider = /*#__PURE__*/ function(Component) {
    * @internal
    */ _proto._onUpdate = function _onUpdate() {
         var shapes = this._shapes;
-        if (this._updateFlag.flag) {
+        if (this._pendingReenterTeleport || this._updateFlag.flag) {
             var transform = this.entity.transform;
-            this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
+            if (this._pendingReenterTeleport) {
+                this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+                this._pendingReenterTeleport = false;
+            } else {
+                this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
+            }
             var worldScale = transform.lossyWorldScale;
             for(var i = 0, n = shapes.length; i < n; i++){
                 var _shapes_i__nativeShape;
@@ -20627,6 +20638,7 @@ exports.Collider = /*#__PURE__*/ function(Component) {
    * @internal
    */ _proto._onEnableInScene = function _onEnableInScene() {
         this.scene.physics._addCollider(this);
+        this._pendingReenterTeleport = true;
     };
     /**
    * @internal
@@ -20745,6 +20757,9 @@ __decorate([
 __decorate([
     deepClone
 ], exports.Collider.prototype, "_shapes", void 0);
+__decorate([
+    ignoreClone
+], exports.Collider.prototype, "_pendingReenterTeleport", void 0);
 exports.Collider = __decorate([
     dependentComponents(Transform, DependentMode.CheckOnly)
 ], exports.Collider);
@@ -21045,7 +21060,6 @@ __decorate([
         this._isTrigger = false;
         this._rotation = new engineMath.Vector3();
         this._position = new engineMath.Vector3();
-        this._contactOffset = 0.02;
         /**
    * @internal
    * @beta
@@ -21111,7 +21125,9 @@ __decorate([
         if (!this._nativeShape) return;
         this._nativeShape.setPosition(this._position);
         this._nativeShape.setRotation(this._rotation);
-        this._nativeShape.setContactOffset(this._contactOffset);
+        if (this._contactOffset !== undefined) {
+            this._nativeShape.setContactOffset(this._contactOffset);
+        }
         this._nativeShape.setIsTrigger(this._isTrigger);
         this._nativeShape.setMaterial(this._material._nativeMaterial);
         (_this__collider = this._collider) == null ? void 0 : _this__collider._handleShapesChanged(ColliderShapeChangeFlag.Property);
@@ -21149,7 +21165,9 @@ __decorate([
    * Contact offset for this shape, the value must be greater than or equal to 0.
    * @defaultValue 0.02
    */ function get() {
-                return this._contactOffset;
+                var _Engine__nativePhysics_getDefaultContactOffset, _Engine__nativePhysics;
+                var _this__contactOffset, _ref;
+                return (_ref = (_this__contactOffset = this._contactOffset) != null ? _this__contactOffset : (_Engine__nativePhysics = Engine._nativePhysics) == null ? void 0 : (_Engine__nativePhysics_getDefaultContactOffset = _Engine__nativePhysics.getDefaultContactOffset) == null ? void 0 : _Engine__nativePhysics_getDefaultContactOffset.call(_Engine__nativePhysics)) != null ? _ref : 0.02;
             },
             set: function set(value) {
                 value = Math.max(0, value);
@@ -21472,7 +21490,7 @@ __decorate([
     _inherits(DynamicCollider, Collider);
     function DynamicCollider(entity) {
         var _this;
-        _this = Collider.call(this, entity) || this, _this._linearDamping = 0, _this._angularDamping = 0.05, _this._linearVelocity = new engineMath.Vector3(), _this._angularVelocity = new engineMath.Vector3(), _this._mass = 1.0, _this._centerOfMass = new engineMath.Vector3(), _this._inertiaTensor = new engineMath.Vector3(1, 1, 1), _this._maxAngularVelocity = 18000 / Math.PI, _this._maxDepenetrationVelocity = 1.0000000331813535e32, _this._solverIterations = 4, _this._useGravity = true, _this._isKinematic = false, _this._constraints = 0, _this._collisionDetectionMode = 0, _this._sleepThreshold = 5e-3, _this._automaticCenterOfMass = true, _this._automaticInertiaTensor = true;
+        _this = Collider.call(this, entity) || this, _this._linearDamping = 0, _this._angularDamping = 0.05, _this._linearVelocity = new engineMath.Vector3(), _this._angularVelocity = new engineMath.Vector3(), _this._mass = 1.0, _this._centerOfMass = new engineMath.Vector3(), _this._inertiaTensor = new engineMath.Vector3(1, 1, 1), _this._maxAngularVelocity = 18000 / Math.PI, _this._maxDepenetrationVelocity = 1.0000000331813535e32, _this._solverIterations = 4, _this._useGravity = true, _this._isKinematic = false, _this._constraints = 0, _this._collisionDetectionMode = 0, _this._kinematicTransformSyncMode = 0, _this._automaticCenterOfMass = true, _this._automaticInertiaTensor = true;
         var transform = _this.entity.transform;
         _this._nativeCollider = Engine._nativePhysics.createDynamicCollider(transform.worldPosition, transform.worldRotationQuaternion);
         _this._setLinearVelocity = _this._setLinearVelocity.bind(_this);
@@ -21564,17 +21582,14 @@ __decorate([
    *    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.
+   * and new pose. setKinematicTarget tells PhysX the actor is animating to the
+   * target during the next simulate(), enabling swept contacts. Some compatibility
+   * layers need transform writes to stay teleport-like, so the sync mode is
+   * explicit while {@link move} always keeps target semantics.
    *
    * @internal
    */ _proto._syncEntityTransformToNative = function _syncEntityTransformToNative(worldPosition, worldRotation) {
-        if (this._isKinematic) {
+        if (this._isKinematic && this._kinematicTransformSyncMode === 0) {
             this._nativeCollider.move(worldPosition, worldRotation);
         } else {
             Collider.prototype._syncEntityTransformToNative.call(this, worldPosition, worldRotation);
@@ -21604,6 +21619,7 @@ __decorate([
         target._angularVelocity.copyFrom(this.angularVelocity);
         target._centerOfMass.copyFrom(this.centerOfMass);
         target._inertiaTensor.copyFrom(this.inertiaTensor);
+        target._kinematicTransformSyncMode = this._kinematicTransformSyncMode;
         Collider.prototype._cloneTo.call(this, target);
     };
     /**
@@ -21629,7 +21645,9 @@ __decorate([
         }
         this._nativeCollider.setMaxAngularVelocity(this._maxAngularVelocity);
         this._nativeCollider.setMaxDepenetrationVelocity(this._maxDepenetrationVelocity);
-        this._nativeCollider.setSleepThreshold(this._sleepThreshold);
+        if (this._sleepThreshold !== undefined) {
+            this._nativeCollider.setSleepThreshold(this._sleepThreshold);
+        }
         this._nativeCollider.setSolverIterations(this._solverIterations);
         this._nativeCollider.setUseGravity(this._useGravity);
         this._nativeCollider.setIsKinematic(this._isKinematic);
@@ -21853,7 +21871,9 @@ __decorate([
             get: /**
    * The mass-normalized energy threshold, below which objects start going to sleep.
    */ function get() {
-                return this._sleepThreshold;
+                var _Engine__nativePhysics_getDefaultSleepThreshold, _Engine__nativePhysics;
+                var _this__sleepThreshold, _ref;
+                return (_ref = (_this__sleepThreshold = this._sleepThreshold) != null ? _this__sleepThreshold : (_Engine__nativePhysics = Engine._nativePhysics) == null ? void 0 : (_Engine__nativePhysics_getDefaultSleepThreshold = _Engine__nativePhysics.getDefaultSleepThreshold) == null ? void 0 : _Engine__nativePhysics_getDefaultSleepThreshold.call(_Engine__nativePhysics)) != null ? _ref : 5e-3;
             },
             set: function set(value) {
                 if (value !== this._sleepThreshold) {
@@ -21949,6 +21969,22 @@ __decorate([
                     this._nativeCollider.setCollisionDetectionMode(value);
                 }
             }
+        },
+        {
+            key: "kinematicTransformSyncMode",
+            get: /**
+   * Controls how entity transform changes are synchronized to a kinematic native actor.
+   *
+   * @remarks
+   * `Target` routes transform changes through {@link move}, so PhysX treats the
+   * actor as moving between frames and can generate swept contacts. `Teleport`
+   * writes the native pose directly and does not imply velocity.
+   */ function get() {
+                return this._kinematicTransformSyncMode;
+            },
+            set: function set(value) {
+                this._kinematicTransformSyncMode = value;
+            }
         }
     ]);
     return DynamicCollider;
@@ -21990,6 +22026,13 @@ __decorate([
     /** Speculative continuous collision detection is on for static and dynamic geometries */ CollisionDetectionMode[CollisionDetectionMode["ContinuousSpeculative"] = 3] = "ContinuousSpeculative";
     return CollisionDetectionMode;
 }({});
+/**
+ * Kinematic transform synchronization mode.
+ */ var DynamicColliderKinematicTransformSyncMode = /*#__PURE__*/ function(DynamicColliderKinematicTransformSyncMode) {
+    /** Synchronize transform changes through PhysX setKinematicTarget. */ DynamicColliderKinematicTransformSyncMode[DynamicColliderKinematicTransformSyncMode["Target"] = 0] = "Target";
+    /** Synchronize transform changes by directly teleporting the native actor. */ DynamicColliderKinematicTransformSyncMode[DynamicColliderKinematicTransformSyncMode["Teleport"] = 1] = "Teleport";
+    return DynamicColliderKinematicTransformSyncMode;
+}({});
 /**
  * Use these flags to constrain motion of dynamic collider.
  */ var DynamicColliderConstraints = /*#__PURE__*/ function(DynamicColliderConstraints) {
@@ -32929,6 +32972,14 @@ var AnimatorLayerBlendingMode = /*#__PURE__*/ function(AnimatorLayerBlendingMode
     return LayerState;
 }({});
 
+/**
+ * Animation wrap mode.
+ */ var WrapMode = /*#__PURE__*/ function(WrapMode) {
+    /** Play once */ WrapMode[WrapMode["Once"] = 0] = "Once";
+    /** Loop play */ WrapMode[WrapMode["Loop"] = 1] = "Loop";
+    return WrapMode;
+}({});
+
 /**
  * @internal
  */ var AnimationEventHandler = /*#__PURE__*/ function() {
@@ -33040,22 +33091,15 @@ function _type_of(obj) {
     return AnimatorStateTransition;
 }();
 
-/**
- * Animation wrap mode.
- */ var WrapMode = /*#__PURE__*/ function(WrapMode) {
-    /** Play once */ WrapMode[WrapMode["Once"] = 0] = "Once";
-    /** Loop play */ WrapMode[WrapMode["Loop"] = 1] = "Loop";
-    return WrapMode;
-}({});
-
 /**
  * Per-instance runtime data for an AnimatorState.
  * Proxies read-only properties from the shared AnimatorState asset,
- * while providing per-instance mutable properties (e.g. speed).
+ * while providing per-instance mutable properties (e.g. speed, wrapMode).
  */ var AnimatorStatePlayData = /*#__PURE__*/ function() {
     function AnimatorStatePlayData() {
         /** @internal */ this.isForward = true;
         /** Per-instance speed. Initialized from AnimatorState.speed, safe to modify without affecting other instances. */ this.speed = 1.0;
+        /** Per-instance wrap mode. Initialized from AnimatorState.wrapMode, safe to modify without affecting other instances. */ this.wrapMode = WrapMode.Loop;
         this._changedOrientation = false;
     }
     var _proto = AnimatorStatePlayData.prototype;
@@ -33074,6 +33118,7 @@ function _type_of(obj) {
         this.currentEventIndex = 0;
         this.isForward = true;
         this.speed = state.speed;
+        this.wrapMode = state.wrapMode;
         this.state._transitionCollection.needResetCurrentCheckIndex = true;
     };
     _proto.updateOrientation = function updateOrientation(deltaTime) {
@@ -33092,7 +33137,7 @@ function _type_of(obj) {
         var time = this.playedTime + this.offsetFrameTime;
         var duration = state._getDuration();
         this.playState = AnimatorStatePlayState.Playing;
-        if (state.wrapMode === WrapMode.Loop) {
+        if (this.wrapMode === WrapMode.Loop) {
             time = duration ? time % duration : 0;
         } else {
             if (Math.abs(time) >= duration) {
@@ -33127,12 +33172,6 @@ function _type_of(obj) {
                 return this.state.clip;
             }
         },
-        {
-            key: "wrapMode",
-            get: /** The wrap mode. */ function get() {
-                return this.state.wrapMode;
-            }
-        },
         {
             key: "transitions",
             get: /** The transitions going out of this state. */ function get() {
@@ -33282,7 +33321,7 @@ function _type_of(obj) {
    * @param layerIndex - The layer index(default -1). If layer is -1, find the first state with the given state name
    */ /**
    * Find the per-instance play data for a state by name.
-   * The returned object's `speed` is per-instance and safe to modify without affecting other Animator instances.
+   * The returned object's `speed` and `wrapMode` are per-instance and safe to modify without affecting other Animator instances.
    * @param stateName - The state name
    * @param layerIndex - The layer index (default -1, searches all layers)
    * @returns Per-instance AnimatorStatePlayData, or null if not found
@@ -34108,22 +34147,27 @@ function _type_of(obj) {
         return true;
     };
     _proto._fireAnimationEvents = function _fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime) {
-        var state = playData.state, isForward = playData.isForward, clipTime = playData.clipTime;
+        var state = playData.state, isForward = playData.isForward, clipTime = playData.clipTime, wrapMode = playData.wrapMode;
         var startTime = state._getClipActualStartTime();
         var endTime = state._getClipActualEndTime();
+        var canWrap = wrapMode === WrapMode.Loop;
         if (isForward) {
             if (lastClipTime + deltaTime >= endTime) {
                 this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, endTime);
-                playData.currentEventIndex = 0;
-                this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+                if (canWrap) {
+                    playData.currentEventIndex = 0;
+                    this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+                }
             } else {
                 this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
             }
         } else {
             if (lastClipTime + deltaTime <= startTime) {
                 this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, startTime);
-                playData.currentEventIndex = eventHandlers.length - 1;
-                this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+                if (canWrap) {
+                    playData.currentEventIndex = eventHandlers.length - 1;
+                    this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+                }
             } else {
                 this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
             }
@@ -36615,7 +36659,7 @@ __decorate([
     _inherits(EmissionModule, ParticleGeneratorModule);
     function EmissionModule() {
         var _this;
-        _this = ParticleGeneratorModule.apply(this, arguments) || this, /**  The rate of particle emission. */ _this.rateOverTime = new ParticleCompositeCurve(10), /**  The rate at which the emitter spawns new particles over distance. */ _this.rateOverDistance = new ParticleCompositeCurve(0), /** @internal */ _this._shapeRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Shape), /** @internal */ _this._frameRateTime = 0, _this._bursts = [], _this._currentBurstIndex = 0, _this._burstRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Burst);
+        _this = ParticleGeneratorModule.apply(this, arguments) || this, /**  The rate of particle emission. */ _this.rateOverTime = new ParticleCompositeCurve(10), /**  The rate at which the emitter spawns new particles over distance. */ _this.rateOverDistance = new ParticleCompositeCurve(0), /** @internal */ _this._shapeRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Shape), /** @internal */ _this._frameRateTime = 0, _this._distanceAccumulator = 0, _this._lastEmitPosition = new engineMath.Vector3(), _this._hasLastEmitPosition = false, _this._bursts = [], _this._currentBurstIndex = 0, _this._burstRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Burst);
         return _this;
     }
     var _proto = EmissionModule.prototype;
@@ -36652,6 +36696,7 @@ __decorate([
    * @internal
    */ _proto._emit = function _emit(lastPlayTime, playTime) {
         this._emitByRateOverTime(playTime);
+        this._emitByRateOverDistance(lastPlayTime, playTime);
         this._emitByBurst(lastPlayTime, playTime);
     };
     /**
@@ -36665,6 +36710,13 @@ __decorate([
    */ _proto._reset = function _reset() {
         this._frameRateTime = 0;
         this._currentBurstIndex = 0;
+        this._invalidateDistanceBaseline();
+    };
+    /**
+   * @internal
+   */ _proto._invalidateDistanceBaseline = function _invalidateDistanceBaseline() {
+        this._hasLastEmitPosition = false;
+        this._distanceAccumulator = 0;
     };
     /**
    * @internal
@@ -36685,6 +36737,55 @@ __decorate([
             }
         }
     };
+    _proto._emitByRateOverDistance = function _emitByRateOverDistance(lastPlayTime, playTime) {
+        var ratePerUnit = this.rateOverDistance.evaluate(undefined, undefined);
+        var generator = this._generator;
+        if (ratePerUnit <= 0) {
+            this._invalidateDistanceBaseline();
+            return;
+        }
+        if (!this._hasLastEmitPosition) {
+            this._lastEmitPosition.copyFrom(generator._renderer.entity.transform.worldPosition);
+            this._hasLastEmitPosition = true;
+            return;
+        }
+        var lastPos = this._lastEmitPosition;
+        var currentPos = generator._renderer.entity.transform.worldPosition;
+        var dx = currentPos.x - lastPos.x;
+        var dy = currentPos.y - lastPos.y;
+        var dz = currentPos.z - lastPos.z;
+        var moveLength = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        this._distanceAccumulator += moveLength;
+        var emitInterval = 1.0 / ratePerUnit;
+        // `+ zeroTolerance` absorbs float divide error so an exact `N*interval` accumulator doesn't drop 1
+        var count = Math.floor(this._distanceAccumulator / emitInterval + engineMath.MathUtil.zeroTolerance);
+        if (count > 0) {
+            this._distanceAccumulator -= count * emitInterval;
+            // `subFrameAge ∈ [0, 1]`: how far back into the frame a particle was born
+            // (0 = newest at currentPos/playTime, 1 = oldest at lastPos/lastPlayTime).
+            // The initial clamp protects two edges — moveLength ≈ 0 (collapse to frame-end
+            // emit) and a tiny moveLength near the emitInterval edge (would put age > 1).
+            // Local simulation space ignores the position override but still uses emitTime.
+            var isWorld = generator.main.simulationSpace === ParticleSimulationSpace.World;
+            var invMoveLength = moveLength > engineMath.MathUtil.zeroTolerance ? 1.0 / moveLength : 0;
+            var ageStep = emitInterval * invMoveLength;
+            var dt = playTime - lastPlayTime;
+            var subFrameAge = Math.min(this._distanceAccumulator * invMoveLength, 1.0);
+            var emitPos = EmissionModule._tempEmitPosition;
+            for(var i = 0; i < count; i++){
+                if (isWorld) {
+                    emitPos.set(currentPos.x - dx * subFrameAge, currentPos.y - dy * subFrameAge, currentPos.z - dz * subFrameAge);
+                }
+                if (generator._emit(playTime - dt * subFrameAge, 1, isWorld ? emitPos : undefined) === 0) {
+                    // Buffer full: settle the frame's distance budget instead of carrying it over
+                    this._distanceAccumulator = 0;
+                    break;
+                }
+                subFrameAge += ageStep;
+            }
+        }
+        lastPos.copyFrom(currentPos);
+    };
     _proto._emitByBurst = function _emitByBurst(lastPlayTime, playTime) {
         var main = this._generator.main;
         var duration = main.duration;
@@ -36781,6 +36882,7 @@ __decorate([
     return EmissionModule;
 }(ParticleGeneratorModule);
 /** @internal */ EmissionModule._emissionShapeMacro = ShaderMacro.getByName("RENDERER_EMISSION_SHAPE");
+EmissionModule._tempEmitPosition = new engineMath.Vector3();
 __decorate([
     deepClone
 ], EmissionModule.prototype, "rateOverTime", void 0);
@@ -36793,6 +36895,15 @@ __decorate([
 __decorate([
     ignoreClone
 ], EmissionModule.prototype, "_shapeRand", void 0);
+__decorate([
+    ignoreClone
+], EmissionModule.prototype, "_distanceAccumulator", void 0);
+__decorate([
+    ignoreClone
+], EmissionModule.prototype, "_lastEmitPosition", void 0);
+__decorate([
+    ignoreClone
+], EmissionModule.prototype, "_hasLastEmitPosition", void 0);
 __decorate([
     deepClone
 ], EmissionModule.prototype, "_bursts", void 0);
@@ -38479,11 +38590,15 @@ __decorate([
             }
         } else {
             this._isPlaying = false;
+            // Invalidate the rateOverDistance baseline so emitter movement during the stop
+            // interval doesn't burst on resume.
             if (stopMode === ParticleStopMode.StopEmittingAndClear) {
                 this._clearActiveParticles();
                 this._playTime = 0;
                 this._firstActiveTransformedBoundingBox = this._firstFreeTransformedBoundingBox;
                 this.emission._reset();
+            } else {
+                this.emission._invalidateDistanceBaseline();
             }
         }
     };
@@ -38495,37 +38610,40 @@ __decorate([
     };
     /**
    * @internal
-   */ _proto._emit = function _emit(playTime, count) {
-        var emission = this.emission;
-        if (emission.enabled) {
-            var main = this.main;
-            // Wait the existing particles to be retired
-            var notRetireParticleCount = this._getNotRetiredParticleCount();
-            if (notRetireParticleCount >= main.maxParticles) {
-                return;
-            }
-            var position = ParticleGenerator._tempVector30;
-            var direction = ParticleGenerator._tempVector31;
-            var transform = this._renderer.entity.transform;
-            var shape = emission.shape;
-            var positionScale = main._getPositionScale();
-            for(var i = 0; i < count; i++){
-                if (shape == null ? void 0 : shape.enabled) {
-                    shape._generatePositionAndDirection(emission._shapeRand, playTime, position, direction);
-                    position.multiply(positionScale);
-                    direction.normalize().multiply(positionScale);
-                } else {
-                    position.set(0, 0, 0);
-                    direction.set(0, 0, -1);
-                    // Speed is scaled by shape scale in world simulation space
-                    // So if no shape and in world simulation space, we shouldn't scale the speed
-                    if (main.simulationSpace === ParticleSimulationSpace.Local) {
-                        direction.multiply(positionScale);
-                    }
+   */ _proto._emit = function _emit(playTime, count, emitWorldPositionOverride) {
+        var _this = this, emission = _this.emission, main = _this.main;
+        if (!emission.enabled) {
+            return 0;
+        }
+        var budget = main.maxParticles - this._getNotRetiredParticleCount();
+        if (count > budget) {
+            count = budget;
+        }
+        if (count <= 0) {
+            return 0;
+        }
+        var position = ParticleGenerator._tempVector30;
+        var direction = ParticleGenerator._tempVector31;
+        var transform = this._renderer.entity.transform;
+        var shape = emission.shape;
+        var positionScale = main._getPositionScale();
+        for(var i = 0; i < count; i++){
+            if (shape == null ? void 0 : shape.enabled) {
+                shape._generatePositionAndDirection(emission._shapeRand, playTime, position, direction);
+                position.multiply(positionScale);
+                direction.normalize().multiply(positionScale);
+            } else {
+                position.set(0, 0, 0);
+                direction.set(0, 0, -1);
+                // Speed is scaled by shape scale in world simulation space
+                // So if no shape and in world simulation space, we shouldn't scale the speed
+                if (main.simulationSpace === ParticleSimulationSpace.Local) {
+                    direction.multiply(positionScale);
                 }
-                this._addNewParticle(position, direction, transform, playTime);
             }
+            this._addNewParticle(position, direction, transform, playTime, emitWorldPositionOverride);
         }
+        return count;
     };
     /**
    * @internal
@@ -38927,7 +39045,7 @@ __decorate([
             this._transformedBoundsArray[previousFreeElement * ParticleBufferUtils.boundsFloatStride + boundsTimeOffset] = this._playTime;
         }
     };
-    _proto._addNewParticle = function _addNewParticle(position, direction, transform, playTime) {
+    _proto._addNewParticle = function _addNewParticle(position, direction, transform, playTime, emitWorldPositionOverride) {
         var firstFreeElement = this._firstFreeElement;
         var nextFreeElement = firstFreeElement + 1;
         if (nextFreeElement >= this._currentParticleCount) {
@@ -38950,7 +39068,7 @@ __decorate([
         }
         var pos, rot;
         if (main.simulationSpace === ParticleSimulationSpace.World) {
-            pos = transform.worldPosition;
+            pos = emitWorldPositionOverride != null ? emitWorldPositionOverride : transform.worldPosition;
             rot = transform.worldRotationQuaternion;
         }
         var startSpeed = main.startSpeed.evaluate(undefined, main._startSpeedRand.random());
@@ -39070,18 +39188,18 @@ __decorate([
         }
         // Initialize feedback buffer for this particle
         if (this._useTransformFeedback) {
-            this._addFeedbackParticle(firstFreeElement, position, direction, startSpeed, transform);
+            this._addFeedbackParticle(firstFreeElement, position, direction, startSpeed, transform, pos);
         }
         this._firstFreeElement = nextFreeElement;
     };
-    _proto._addFeedbackParticle = function _addFeedbackParticle(index, shapePosition, direction, startSpeed, transform) {
+    _proto._addFeedbackParticle = function _addFeedbackParticle(index, shapePosition, direction, startSpeed, transform, emitWorldPosition) {
         var position;
         if (this.main.simulationSpace === ParticleSimulationSpace.Local) {
             position = shapePosition;
         } else {
             position = ParticleGenerator._tempVector32;
             engineMath.Vector3.transformByQuat(shapePosition, transform.worldRotationQuaternion, position);
-            position.add(transform.worldPosition);
+            position.add(emitWorldPosition != null ? emitWorldPosition : transform.worldPosition);
         }
         this._feedbackSimulator.writeParticleData(index, position, direction.x * startSpeed, direction.y * startSpeed, direction.z * startSpeed);
     };
@@ -41768,6 +41886,7 @@ exports.DisorderedArray = DisorderedArray;
 exports.Downsampling = Downsampling;
 exports.DynamicCollider = DynamicCollider;
 exports.DynamicColliderConstraints = DynamicColliderConstraints;
+exports.DynamicColliderKinematicTransformSyncMode = DynamicColliderKinematicTransformSyncMode;
 exports.EmissionModule = EmissionModule;
 exports.Engine = Engine;
 exports.EngineObject = EngineObject;