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

package/dist/browser.js

@@ -12318,7 +12318,7 @@
     };
     var particle_common = "vec3 rotationByQuaternions(in vec3 v, in vec4 q) {\n    return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);\n}\n\nvec4 quaternionConjugate(in vec4 q) {\n    return vec4(-q.xyz, q.w);\n}\n\nvec3 rotationByEuler(in vec3 vector, in vec3 rot) {\n    float halfRoll = rot.z * 0.5;\n    float halfPitch = rot.x * 0.5;\n    float halfYaw = rot.y * 0.5;\n\n    float sinRoll = sin(halfRoll);\n    float cosRoll = cos(halfRoll);\n    float sinPitch = sin(halfPitch);\n    float cosPitch = cos(halfPitch);\n    float sinYaw = sin(halfYaw);\n    float cosYaw = cos(halfYaw);\n\n    float cosYawPitch = cosYaw * cosPitch;\n    float sinYawPitch = sinYaw * sinPitch;\n\n    float quaX = (cosYaw * sinPitch * cosRoll) + (sinYaw * cosPitch * sinRoll);\n    float quaY = (sinYaw * cosPitch * cosRoll) - (cosYaw * sinPitch * sinRoll);\n    float quaZ = (cosYawPitch * sinRoll) - (sinYawPitch * cosRoll);\n    float quaW = (cosYawPitch * cosRoll) + (sinYawPitch * sinRoll);\n\n    return rotationByQuaternions(vector, vec4(quaX, quaY, quaZ, quaW));\n}\n\n// Assume axis is normalized\nvec3 rotationByAxis(in vec3 vector, in vec3 axis, in float angle) {\n    float halfAngle = angle * 0.5;\n    float s = sin(halfAngle);\n\n    return rotationByQuaternions(vector, vec4(axis * s, cos(halfAngle)));\n}\n\n\nfloat evaluateParticleCurve(in vec2 keys[4], in float normalizedAge) {\n    float value;\n    for (int i = 1; i < 4; i++) {\n        vec2 key = keys[i];\n        float time = key.x;\n        if (time >= normalizedAge) {\n            vec2 lastKey = keys[i - 1];\n            float lastTime = lastKey.x;\n            float age = (normalizedAge - lastTime) / (time - lastTime);\n            value = mix(lastKey.y, key.y, age);\n            break;\n        }\n    }\n    return value;\n}\n\nfloat evaluateParticleCurveCumulative(in vec2 keys[4], in float normalizedAge, out float currentValue){\n    float cumulativeValue = 0.0;\n    for (int i = 1; i < 4; i++){\n\t    vec2 key = keys[i];\n\t    float time = key.x;\n\t    vec2 lastKey = keys[i - 1];\n\t    float lastValue = lastKey.y;\n\n\t    if (time >= normalizedAge){\n\t\t    float lastTime = lastKey.x;\n            float offsetTime = normalizedAge - lastTime;\n\t\t    float age = offsetTime / (time - lastTime);\n            currentValue = mix(lastValue, key.y, age);\n\t\t    cumulativeValue += (lastValue + currentValue) * 0.5 * offsetTime;\n\t\t    break;\n\t\t}\n\t    else{\n\t\t    cumulativeValue += (lastValue + key.y) * 0.5 * (time - lastKey.x);\n\t\t}\n\t}\n    return cumulativeValue;\n}\n\nvec4 evaluateParticleGradient(in vec4 colorKeys[4], in float colorMaxTime, in vec2 alphaKeys[4], in float alphaMaxTime, in float t) {\n    vec4 value;\n\n    float alphaT = min(t, alphaMaxTime);\n    for (int i = 0; i < 4; i++) {\n        vec2 key = alphaKeys[i];\n        if (alphaT <= key.x) {\n            if (i == 0) {\n                value.a = alphaKeys[0].y;\n            } else {\n                vec2 lastKey = alphaKeys[i - 1];\n                float age = (alphaT - lastKey.x) / (key.x - lastKey.x);\n                value.a = mix(lastKey.y, key.y, age);\n            }\n            break;\n        }\n    }\n\n    float colorT = min(t, colorMaxTime);\n    for (int i = 0; i < 4; i++) {\n        vec4 key = colorKeys[i];\n        if (colorT <= key.x) {\n            if (i == 0) {\n                value.rgb = colorKeys[0].yzw;\n            } else {\n                vec4 lastKey = colorKeys[i - 1];\n                float age = (colorT - lastKey.x) / (key.x - lastKey.x);\n                value.rgb = mix(lastKey.yzw, key.yzw, age);\n            }\n            break;\n        }\n    }\n\n    return value;\n}"; // eslint-disable-line
     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
     var color_over_lifetime_module = "#if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n    uniform vec4 renderer_COLMaxGradientColor[4]; // x:time y:r z:g w:b\n    uniform vec2 renderer_COLMaxGradientAlpha[4]; // x:time y:alpha\n\n    #ifdef RENDERER_COL_RANDOM_GRADIENTS\n        uniform vec4 renderer_COLMinGradientColor[4]; // x:time y:r z:g w:b\n        uniform vec2 renderer_COLMinGradientAlpha[4]; // x:time y:alpha\n    #endif\n\n    uniform vec4 renderer_COLGradientKeysMaxTime; // x: minColorKeysMaxTime, y: minAlphaKeysMaxTime, z: maxColorKeysMaxTime, w: maxAlphaKeysMaxTime\n#endif\n\n\nvec4 computeParticleColor(in vec4 color, in float normalizedAge) {\n    #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n       vec4 gradientColor = evaluateParticleGradient(renderer_COLMaxGradientColor, renderer_COLGradientKeysMaxTime.z, renderer_COLMaxGradientAlpha, renderer_COLGradientKeysMaxTime.w, normalizedAge);\n    #endif\n\n    #ifdef RENDERER_COL_RANDOM_GRADIENTS\n        gradientColor = mix(evaluateParticleGradient(renderer_COLMinGradientColor,renderer_COLGradientKeysMaxTime.x, renderer_COLMinGradientAlpha, renderer_COLGradientKeysMaxTime.y, normalizedAge), gradientColor, a_Random0.y);\n    #endif\n\n    #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n       color *= gradientColor;\n    #endif\n\n    return color;\n}\n"; // eslint-disable-line
     var texture_sheet_animation_module = "#if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n    uniform float renderer_TSACycles;\n    uniform vec3 renderer_TSATillingParams; // x:subU y:subV z:tileCount\n    uniform vec2 renderer_TSAFrameMaxCurve[4]; // x:time y:value\n\n    #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n        uniform vec2 renderer_TSAFrameMinCurve[4]; // x:time y:value\n    #endif\n#endif\n\nvec2 computeParticleUV(in vec2 uv, in float normalizedAge) {\n    #if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n        float scaledNormalizedAge = normalizedAge * renderer_TSACycles;\n        float cycleNormalizedAge = scaledNormalizedAge - floor(scaledNormalizedAge);\n        float normalizedFrame = evaluateParticleCurve(renderer_TSAFrameMaxCurve, cycleNormalizedAge);\n        #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n            normalizedFrame = mix(evaluateParticleCurve(renderer_TSAFrameMinCurve, cycleNormalizedAge), normalizedFrame, a_Random1.x);\n        #endif\n\n        float frame = floor(normalizedFrame * renderer_TSATillingParams.z);\n\n        float tileRow = frame * renderer_TSATillingParams.x;\n        float tileRowIndex = floor(tileRow);\n        uv.x += tileRow - tileRowIndex;\n        uv.y += tileRowIndex * renderer_TSATillingParams.y;\n    #endif\n    \n    return uv;\n}\n"; // eslint-disable-line
@@ -25401,7 +25401,13 @@
         _inherits$2(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;
         }
@@ -25445,9 +25451,14 @@
        * @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;
@@ -25469,6 +25480,7 @@
        * @internal
        */ _proto._onEnableInScene = function _onEnableInScene() {
             this.scene.physics._addCollider(this);
+            this._pendingReenterTeleport = true;
         };
         /**
        * @internal
@@ -25587,6 +25599,9 @@
     __decorate$1([
         deepClone
     ], exports.Collider.prototype, "_shapes", void 0);
+    __decorate$1([
+        ignoreClone
+    ], exports.Collider.prototype, "_pendingReenterTeleport", void 0);
     exports.Collider = __decorate$1([
         dependentComponents(Transform, DependentMode.CheckOnly)
     ], exports.Collider);
@@ -25881,7 +25896,6 @@
             this._isTrigger = false;
             this._rotation = new Vector3();
             this._position = new Vector3();
-            this._contactOffset = 0.02;
             /**
        * @internal
        * @beta
@@ -25947,7 +25961,9 @@
             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);
@@ -25985,7 +26001,9 @@
        * 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);
@@ -26306,7 +26324,7 @@
         _inherits$2(DynamicCollider, Collider);
         function DynamicCollider(entity) {
             var _this;
-            _this = Collider.call(this, entity) || this, _this._linearDamping = 0, _this._angularDamping = 0.05, _this._linearVelocity = new Vector3(), _this._angularVelocity = new Vector3(), _this._mass = 1.0, _this._centerOfMass = new Vector3(), _this._inertiaTensor = new 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 Vector3(), _this._angularVelocity = new Vector3(), _this._mass = 1.0, _this._centerOfMass = new Vector3(), _this._inertiaTensor = new 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);
@@ -26398,17 +26416,14 @@
        *    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);
@@ -26438,6 +26453,7 @@
             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);
         };
         /**
@@ -26463,7 +26479,9 @@
             }
             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);
@@ -26687,7 +26705,9 @@
                 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) {
@@ -26783,6 +26803,22 @@
                         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;
@@ -26824,6 +26860,13 @@
         /** 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) {
@@ -37585,6 +37628,13 @@
         /** Finished state. */ LayerState[LayerState["Finished"] = 4] = "Finished";
         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() {
@@ -37690,21 +37740,15 @@
         ]);
         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;
@@ -37723,6 +37767,7 @@
             this.currentEventIndex = 0;
             this.isForward = true;
             this.speed = state.speed;
+            this.wrapMode = state.wrapMode;
             this.state._transitionCollection.needResetCurrentCheckIndex = true;
         };
         _proto.updateOrientation = function updateOrientation(deltaTime) {
@@ -37741,7 +37786,7 @@
             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) {
@@ -37775,12 +37820,6 @@
                     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() {
@@ -37927,7 +37966,7 @@
        * @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
@@ -38749,22 +38788,27 @@
             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);
                 }
@@ -41223,7 +41267,7 @@
         _inherits$2(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 Rand(0, ParticleRandomSubSeeds.Shape), /** @internal */ _this._frameRateTime = 0, _this._bursts = [], _this._currentBurstIndex = 0, _this._burstRand = new 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 Rand(0, ParticleRandomSubSeeds.Shape), /** @internal */ _this._frameRateTime = 0, _this._distanceAccumulator = 0, _this._lastEmitPosition = new Vector3(), _this._hasLastEmitPosition = false, _this._bursts = [], _this._currentBurstIndex = 0, _this._burstRand = new Rand(0, ParticleRandomSubSeeds.Burst);
             return _this;
         }
         var _proto = EmissionModule.prototype;
@@ -41260,6 +41304,7 @@
        * @internal
        */ _proto._emit = function _emit(lastPlayTime, playTime) {
             this._emitByRateOverTime(playTime);
+            this._emitByRateOverDistance(lastPlayTime, playTime);
             this._emitByBurst(lastPlayTime, playTime);
         };
         /**
@@ -41273,6 +41318,13 @@
        */ _proto._reset = function _reset() {
             this._frameRateTime = 0;
             this._currentBurstIndex = 0;
+            this._invalidateDistanceBaseline();
+        };
+        /**
+       * @internal
+       */ _proto._invalidateDistanceBaseline = function _invalidateDistanceBaseline() {
+            this._hasLastEmitPosition = false;
+            this._distanceAccumulator = 0;
         };
         /**
        * @internal
@@ -41293,6 +41345,55 @@
                 }
             }
         };
+        _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 + 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 > 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;
@@ -41389,6 +41490,7 @@
         return EmissionModule;
     }(ParticleGeneratorModule);
     /** @internal */ EmissionModule._emissionShapeMacro = ShaderMacro.getByName("RENDERER_EMISSION_SHAPE");
+    EmissionModule._tempEmitPosition = new Vector3();
     __decorate$1([
         deepClone
     ], EmissionModule.prototype, "rateOverTime", void 0);
@@ -41401,6 +41503,15 @@
     __decorate$1([
         ignoreClone
     ], EmissionModule.prototype, "_shapeRand", void 0);
+    __decorate$1([
+        ignoreClone
+    ], EmissionModule.prototype, "_distanceAccumulator", void 0);
+    __decorate$1([
+        ignoreClone
+    ], EmissionModule.prototype, "_lastEmitPosition", void 0);
+    __decorate$1([
+        ignoreClone
+    ], EmissionModule.prototype, "_hasLastEmitPosition", void 0);
     __decorate$1([
         deepClone
     ], EmissionModule.prototype, "_bursts", void 0);
@@ -43077,11 +43188,15 @@
                 }
             } 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();
                 }
             }
         };
@@ -43093,37 +43208,40 @@
         };
         /**
        * @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
@@ -43525,7 +43643,7 @@
                 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) {
@@ -43548,7 +43666,7 @@
             }
             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());
@@ -43668,18 +43786,18 @@
             }
             // 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;
                 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);
         };
@@ -46355,6 +46473,7 @@
         Downsampling: Downsampling,
         DynamicCollider: DynamicCollider,
         DynamicColliderConstraints: DynamicColliderConstraints,
+        DynamicColliderKinematicTransformSyncMode: DynamicColliderKinematicTransformSyncMode,
         EmissionModule: EmissionModule,
         Engine: Engine,
         EngineObject: EngineObject,
@@ -55768,6 +55887,14 @@
                             if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
                             if (fog.fogColor != undefined) scene.fogColor.copyFrom(fog.fogColor);
                         }
+                        // parse physics
+                        var physics = data.scene.physics;
+                        // PhysicsScene has a native backing only when the engine was created with a physics backend.
+                        // Keep scene files loadable for render-only engines by ignoring serialized physics settings there.
+                        if (physics && engine._physicsInitialized) {
+                            if (physics.gravity != undefined) scene.physics.gravity.copyFrom(physics.gravity);
+                            if (physics.fixedTimeStep != undefined) scene.physics.fixedTimeStep = physics.fixedTimeStep;
+                        }
                         // Post Process
                         var postProcessData = data.scene.postProcess;
                         if (postProcessData) {
@@ -56294,7 +56421,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-2.0-game.13";
+    var version = "0.0.0-experimental-2.0-game.14";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);
@@ -56398,6 +56525,7 @@
     exports.Downsampling = Downsampling;
     exports.DynamicCollider = DynamicCollider;
     exports.DynamicColliderConstraints = DynamicColliderConstraints;
+    exports.DynamicColliderKinematicTransformSyncMode = DynamicColliderKinematicTransformSyncMode;
     exports.EmissionModule = EmissionModule;
     exports.Engine = Engine;
     exports.EngineObject = EngineObject;