@galacean/engine 0.0.0-experimental-2.0-game.12 → 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
@@ -12744,7 +12744,13 @@
     };
     ShaderFactory._has300OutInFragReg = /\bout\s+(?:\w+\s+)?vec4\s+\w+\s*;/;
     ShaderFactory._precisionStr = "\n#ifdef GL_FRAGMENT_PRECISION_HIGH\n  precision highp float;\n  precision highp int;\n#else\n  precision mediump float;\n  precision mediump int;\n#endif\n";
-    ShaderFactory._derivedDefines = "#define renderer_MVMat (camera_ViewMat * renderer_ModelMat)\n#define renderer_MVPMat (camera_VPMat * renderer_ModelMat)\n#define renderer_NormalMat mat4(transpose(inverse(mat3(renderer_ModelMat))))";
+    // Derived built-ins re-exposed on top of `renderer_ModelMat`.
+    // `renderer_NormalMat` uses the cofactor (cross-product) form, which algebraically equals
+    // `det(M) · transpose(inverse(M))`. After `normalize()` it's directionally identical to the
+    // classic `transpose(inverse(M))`, but stays NaN-free when `M` is singular (e.g. any scale
+    // axis is 0 — common in animations that pop / hide via scale). `sign(det)` (`s` below)
+    // keeps mirrored matrices facing the right way
+    ShaderFactory._derivedDefines = "mat3 _normalMatFromModel(mat3 m) {\n    vec3 c0 = cross(m[1], m[2]);\n    vec3 c1 = cross(m[2], m[0]);\n    vec3 c2 = cross(m[0], m[1]);\n    float s = (dot(m[0], c0) < 0.0) ? -1.0 : 1.0;\n    return mat3(c0 * s, c1 * s, c2 * s);\n}\n#define renderer_MVMat (camera_ViewMat * renderer_ModelMat)\n#define renderer_MVPMat (camera_VPMat * renderer_ModelMat)\n#define renderer_NormalMat mat4(_normalMatFromModel(mat3(renderer_ModelMat)))";
     // Built-in renderer uniforms. value=true means derived (remove but not added to UBO)
     ShaderFactory._builtinRendererUniforms = {
         renderer_ModelMat: false,
@@ -23980,7 +23986,7 @@
         /** Scene. */ AssetType["Scene"] = "Scene";
         /** Font. */ AssetType["Font"] = "Font";
         /** Source Font, include ttf, otf and woff. */ AssetType["SourceFont"] = "SourceFont";
-        /** AudioClip, include ogg, wav and mp3. */ AssetType["Audio"] = "Audio";
+        /** AudioClip, include ogg, wav, mp3, m4a, aac and flac. */ AssetType["Audio"] = "Audio";
         /** Project asset. */ AssetType["Project"] = "project";
         /** PhysicsMaterial. */ AssetType["PhysicsMaterial"] = "PhysicsMaterial";
         /** RenderTarget. */ AssetType["RenderTarget"] = "RenderTarget";
@@ -25395,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;
         }
@@ -25439,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;
@@ -25463,6 +25480,7 @@
        * @internal
        */ _proto._onEnableInScene = function _onEnableInScene() {
             this.scene.physics._addCollider(this);
+            this._pendingReenterTeleport = true;
         };
         /**
        * @internal
@@ -25581,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);
@@ -25875,7 +25896,6 @@
             this._isTrigger = false;
             this._rotation = new Vector3();
             this._position = new Vector3();
-            this._contactOffset = 0.02;
             /**
        * @internal
        * @beta
@@ -25941,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);
@@ -25979,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);
@@ -26300,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);
@@ -26392,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);
@@ -26432,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);
         };
         /**
@@ -26457,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);
@@ -26681,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) {
@@ -26777,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;
@@ -26818,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) {
@@ -26860,8 +26909,7 @@
        * You need to obtain the actual number of contact points from the function's return value.
        */ _proto.getContacts = function getContacts(outContacts) {
             var nativeCollision = this._nativeCollision;
-            var smallerShapeId = Math.min(nativeCollision.shape0Id, nativeCollision.shape1Id);
-            var factor = this.shape.id === smallerShapeId ? 1 : -1;
+            var factor = this.shape.id === nativeCollision.shape1Id ? 1 : -1;
             var nativeContactPoints = nativeCollision.getContacts();
             var length = nativeContactPoints.size();
             for(var i = 0; i < length; i++){
@@ -37580,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() {
@@ -37685,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;
@@ -37718,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) {
@@ -37736,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) {
@@ -37770,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() {
@@ -37922,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
@@ -38341,8 +38385,8 @@
             if (this._tryCrossFadeInterrupt(layerData, transitionDuration, destState, deltaTime, aniUpdate)) {
                 return;
             }
-            var srcPlaySpeed = srcState.speed * speed;
-            var dstPlaySpeed = destState.speed * speed;
+            var srcPlaySpeed = srcPlayData.speed * speed;
+            var dstPlaySpeed = destPlayData.speed * speed;
             var dstPlayDeltaTime = dstPlaySpeed * deltaTime;
             srcPlayData && srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
             destPlayData && destPlayData.updateOrientation(dstPlayDeltaTime);
@@ -38744,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);
                 }
@@ -41218,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;
@@ -41255,6 +41304,7 @@
        * @internal
        */ _proto._emit = function _emit(lastPlayTime, playTime) {
             this._emitByRateOverTime(playTime);
+            this._emitByRateOverDistance(lastPlayTime, playTime);
             this._emitByBurst(lastPlayTime, playTime);
         };
         /**
@@ -41268,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
@@ -41288,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;
@@ -41384,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);
@@ -41396,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);
@@ -43072,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();
                 }
             }
         };
@@ -43088,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
@@ -43520,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) {
@@ -43543,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());
@@ -43663,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);
         };
@@ -46350,6 +46473,7 @@
         Downsampling: Downsampling,
         DynamicCollider: DynamicCollider,
         DynamicColliderConstraints: DynamicColliderConstraints,
+        DynamicColliderKinematicTransformSyncMode: DynamicColliderKinematicTransformSyncMode,
         EmissionModule: EmissionModule,
         Engine: Engine,
         EngineObject: EngineObject,
@@ -53859,33 +53983,11 @@
             if (rootBoneIndex !== -1) {
                 BoundingBox.transform(mesh.bounds, inverseBindMatrices[rootBoneIndex], skinnedMeshRenderer.localBounds);
             } else {
-                // Root bone is not in joints list, we can only compute approximate inverse bind matrix
-                // Average all root bone's children inverse bind matrix
-                var approximateBindMatrix = new Matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-                var subRootBoneCount = this._computeApproximateBindMatrix(bones, inverseBindMatrices, rootBone, approximateBindMatrix);
-                if (subRootBoneCount !== 0) {
-                    Matrix.multiplyScalar(approximateBindMatrix, 1.0 / subRootBoneCount, approximateBindMatrix);
-                    BoundingBox.transform(mesh.bounds, approximateBindMatrix, skinnedMeshRenderer.localBounds);
-                } else {
-                    skinnedMeshRenderer.localBounds.copyFrom(mesh.bounds);
-                }
+                var inverseRootBoneWorld = new Matrix();
+                Matrix.invert(rootBone.transform.worldMatrix, inverseRootBoneWorld);
+                BoundingBox.transform(mesh.bounds, inverseRootBoneWorld, skinnedMeshRenderer.localBounds);
             }
         };
-        _proto._computeApproximateBindMatrix = function _computeApproximateBindMatrix(jointEntities, inverseBindMatrices, rootEntity, approximateBindMatrix) {
-            var subRootBoneCount = 0;
-            var children = rootEntity.children;
-            for(var i = 0, n = children.length; i < n; i++){
-                var rootChild = children[i];
-                var index = jointEntities.indexOf(rootChild);
-                if (index !== -1) {
-                    Matrix.add(approximateBindMatrix, inverseBindMatrices[index], approximateBindMatrix);
-                    subRootBoneCount++;
-                } else {
-                    subRootBoneCount += this._computeApproximateBindMatrix(jointEntities, inverseBindMatrices, rootChild, approximateBindMatrix);
-                }
-            }
-            return subRootBoneCount;
-        };
         return GLTFSceneParser;
     }(GLTFParser);
     exports.GLTFSceneParser = __decorate([
@@ -53926,8 +54028,7 @@
                     var rootBone = entities[skeleton];
                     skin.rootBone = rootBone;
                 } else {
-                    var _this__findSceneRootBone;
-                    var rootBone1 = (_this__findSceneRootBone = _this._findSceneRootBone(context, joints, entities)) != null ? _this__findSceneRootBone : _this._findSkeletonRootBone(joints, entities);
+                    var rootBone1 = _this._findSkinRootBoneByLCA(index, joints, entities, glTF.nodes);
                     if (rootBone1) {
                         skin.rootBone = rootBone1;
                     } else {
@@ -53938,46 +54039,20 @@
             });
             return AssetPromise.resolve(skinPromise);
         };
-        _proto._findSceneRootBone = function _findSceneRootBone(context, joints, entities) {
-            var glTF = context.glTF, glTFResource = context.glTFResource;
-            var scenes = glTF.scenes;
-            var sceneRoots = glTFResource._sceneRoots;
-            if (!(scenes == null ? void 0 : scenes.length) || !(sceneRoots == null ? void 0 : sceneRoots.length)) {
-                return null;
-            }
-            for(var i = 0, n = scenes.length; i < n; i++){
-                var _scenes_i_nodes;
-                var sceneNodes = (_scenes_i_nodes = scenes[i].nodes) != null ? _scenes_i_nodes : [];
-                if (sceneNodes.length <= 1) {
-                    continue;
-                }
-                var sceneRoot = sceneRoots[i];
-                if (!sceneRoot) {
-                    continue;
-                }
-                var sceneRootChildren = new Set(sceneNodes.map(function(nodeIndex) {
-                    return entities[nodeIndex];
-                }));
-                var allJointsUnderSceneRoot = true;
-                for(var j = 0, m = joints.length; j < m; j++){
-                    var entity = entities[joints[j]];
-                    while(entity == null ? void 0 : entity.parent){
-                        entity = entity.parent;
-                    }
-                    if (!sceneRootChildren.has(entity)) {
-                        allJointsUnderSceneRoot = false;
-                        break;
-                    }
-                }
-                if (allJointsUnderSceneRoot) {
-                    return sceneRoot;
+        _proto._findSkinRootBoneByLCA = function _findSkinRootBoneByLCA(skinIndex, joints, entities, nodes) {
+            if (nodes === void 0) nodes = [];
+            var nodeIndices = joints.slice();
+            for(var i = 0, n = nodes.length; i < n; i++){
+                var _nodes_i;
+                if (((_nodes_i = nodes[i]) == null ? void 0 : _nodes_i.skin) === skinIndex) {
+                    nodeIndices.push(i);
                 }
             }
-            return null;
+            return this._findRootBoneByLCA(nodeIndices, entities);
         };
-        _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
-            var paths = {};
-            for(var _iterator = _create_for_of_iterator_helper_loose(joints), _step; !(_step = _iterator()).done;){
+        _proto._findRootBoneByLCA = function _findRootBoneByLCA(nodeIndices, entities) {
+            var paths = [];
+            for(var _iterator = _create_for_of_iterator_helper_loose(nodeIndices), _step; !(_step = _iterator()).done;){
                 var index = _step.value;
                 var path = new Array();
                 var entity = entities[index];
@@ -53985,17 +54060,22 @@
                     path.unshift(entity);
                     entity = entity.parent;
                 }
-                paths[index] = path;
+                if (path.length) {
+                    paths.push(path);
+                }
+            }
+            if (!paths.length) {
+                return null;
             }
             var rootNode = null;
             for(var i = 0;; i++){
-                var path1 = paths[joints[0]];
+                var path1 = paths[0];
                 if (i >= path1.length) {
                     return rootNode;
                 }
                 var entity1 = path1[i];
-                for(var j = 1, m = joints.length; j < m; j++){
-                    path1 = paths[joints[j]];
+                for(var j = 1, m = paths.length; j < m; j++){
+                    path1 = paths[j];
                     if (i >= path1.length || entity1 !== path1[i]) {
                         return rootNode;
                     }
@@ -55540,7 +55620,10 @@
             "mp3",
             "ogg",
             "wav",
-            "audio"
+            "audio",
+            "m4a",
+            "aac",
+            "flac"
         ])
     ], AudioLoader);
     var ShaderChunkLoader = /*#__PURE__*/ function(Loader) {
@@ -55804,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) {
@@ -56330,7 +56421,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-2.0-game.12";
+    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]);
@@ -56434,6 +56525,7 @@
     exports.Downsampling = Downsampling;
     exports.DynamicCollider = DynamicCollider;
     exports.DynamicColliderConstraints = DynamicColliderConstraints;
+    exports.DynamicColliderKinematicTransformSyncMode = DynamicColliderKinematicTransformSyncMode;
     exports.EmissionModule = EmissionModule;
     exports.Engine = Engine;
     exports.EngineObject = EngineObject;