@galacean/engine-core 2.0.0-alpha.16 → 2.0.0-alpha.18

package/dist/main.js

@@ -4902,7 +4902,7 @@ var ShadowLib = {
     ShadowVertex: ShadowVertex
 };
 
-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\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 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
 
@@ -4914,7 +4914,11 @@ var color_over_lifetime_module = "#if defined(RENDERER_COL_GRADIENT) || defined(
 
 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
 
-var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE)\n    #define _FOL_MODULE_ENABLED\n#endif\n\n#ifdef _FOL_MODULE_ENABLED\n    attribute vec4 a_Random2;\n\n    uniform int renderer_FOLSpace;\n\n    #ifdef RENDERER_FOL_CONSTANT_MODE\n        uniform vec3 renderer_FOLMaxConst;\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec3 renderer_FOLMinConst;\n        #endif\n\n    #endif\n\n    #ifdef RENDERER_FOL_CURVE_MODE\n        uniform vec2 renderer_FOLMaxGradientX[4];\n        uniform vec2 renderer_FOLMaxGradientY[4];\n        uniform vec2 renderer_FOLMaxGradientZ[4];\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec2 renderer_FOLMinGradientX[4];\n            uniform vec2 renderer_FOLMinGradientY[4];\n            uniform vec2 renderer_FOLMinGradientZ[4];\n        #endif\n    #endif\n\n    // (tHat - t1) * (tHat - t1) * (tHat - t1) * (a2 - a1) / ((t2 - t1) * 6.0) + a1 * (tHat - t1) * (tHat - t1) * 0.5 + v1 * (tHat - t1);\n    // to = tHat - t1; tr = t2 - t1\n    float computeDisplacementIntegral(in float to, in float tr, in float a1, in float a2, in float v1) {\n        return to * to * to * (a2 - a1) / (tr * 6.0) + a1 * to * to * 0.5 + v1 * to;\n    }\n\n    float evaluateForceParticleCurveCumulative(in vec2 keys[4], in float normalizedAge, out float velocityCumulative) {\n        float cumulativeValue = 0.0;\n        velocityCumulative = 0.0;\n\n        for (int i = 1; i < 4; i++){\n            vec2 key = keys[i];\n            vec2 lastKey = keys[i - 1];\n            float timeRange = (key.x - lastKey.x) * a_ShapePositionStartLifeTime.w;\n\n            if (key.x >= normalizedAge){\n                float timeOffset = (normalizedAge - lastKey.x) * a_ShapePositionStartLifeTime.w;\n                cumulativeValue += computeDisplacementIntegral(timeOffset, timeRange, lastKey.y, key.y, velocityCumulative);\n\n                float finalAcceleration = mix(lastKey.y, key.y, timeOffset / timeRange);\n                velocityCumulative += 0.5 * timeOffset * (finalAcceleration + lastKey.y);\n                break;\n            } else {  \n                cumulativeValue += computeDisplacementIntegral(timeRange, timeRange, lastKey.y, key.y, velocityCumulative);\n                velocityCumulative += 0.5 * timeRange * (lastKey.y + key.y);\n            }\n        }\n        return cumulativeValue;\n    }\n\n    vec3 computeForcePositionOffset(in float normalizedAge, in float age, out vec3 velocityOffset) {\n        vec3 forcePosition;\n\n        #if defined(RENDERER_FOL_CONSTANT_MODE)\n            vec3 forceAcceleration = renderer_FOLMaxConst;\n\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                forceAcceleration = mix(renderer_FOLMinConst, forceAcceleration, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n\n            velocityOffset = forceAcceleration * age;\n\n            forcePosition = 0.5 * forceAcceleration * age * age;\n        #elif defined(RENDERER_FOL_CURVE_MODE)\n            forcePosition = vec3(\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientX, normalizedAge, velocityOffset.x),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientY, normalizedAge, velocityOffset.y),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientZ, normalizedAge, velocityOffset.z)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minVelocityOffset;\n\n                forcePosition = vec3(\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientX, normalizedAge, minVelocityOffset.x), forcePosition.x, a_Random2.x),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientY, normalizedAge, minVelocityOffset.y), forcePosition.y, a_Random2.y),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientZ, normalizedAge, minVelocityOffset.z), forcePosition.z, a_Random2.z)\n                );\n\n                velocityOffset = mix(minVelocityOffset, velocityOffset, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        return forcePosition;\n    }\n#endif"; // eslint-disable-line
+var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE)\n    #define _FOL_MODULE_ENABLED\n#endif\n\n#ifdef _FOL_MODULE_ENABLED\n    uniform int renderer_FOLSpace;\n\n    #ifdef RENDERER_FOL_CONSTANT_MODE\n        uniform vec3 renderer_FOLMaxConst;\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec3 renderer_FOLMinConst;\n        #endif\n\n    #endif\n\n    #ifdef RENDERER_FOL_CURVE_MODE\n        uniform vec2 renderer_FOLMaxGradientX[4];\n        uniform vec2 renderer_FOLMaxGradientY[4];\n        uniform vec2 renderer_FOLMaxGradientZ[4];\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec2 renderer_FOLMinGradientX[4];\n            uniform vec2 renderer_FOLMinGradientY[4];\n            uniform vec2 renderer_FOLMinGradientZ[4];\n        #endif\n    #endif\n\n    // (tHat - t1) * (tHat - t1) * (tHat - t1) * (a2 - a1) / ((t2 - t1) * 6.0) + a1 * (tHat - t1) * (tHat - t1) * 0.5 + v1 * (tHat - t1);\n    // to = tHat - t1; tr = t2 - t1\n    float computeDisplacementIntegral(in float to, in float tr, in float a1, in float a2, in float v1) {\n        return to * to * to * (a2 - a1) / (tr * 6.0) + a1 * to * to * 0.5 + v1 * to;\n    }\n\n    float evaluateForceParticleCurveCumulative(in vec2 keys[4], in float normalizedAge, out float velocityCumulative) {\n        float cumulativeValue = 0.0;\n        velocityCumulative = 0.0;\n\n        for (int i = 1; i < 4; i++){\n            vec2 key = keys[i];\n            vec2 lastKey = keys[i - 1];\n            float timeRange = (key.x - lastKey.x) * a_ShapePositionStartLifeTime.w;\n\n            if (key.x >= normalizedAge){\n                float timeOffset = (normalizedAge - lastKey.x) * a_ShapePositionStartLifeTime.w;\n                cumulativeValue += computeDisplacementIntegral(timeOffset, timeRange, lastKey.y, key.y, velocityCumulative);\n\n                float finalAcceleration = mix(lastKey.y, key.y, timeOffset / timeRange);\n                velocityCumulative += 0.5 * timeOffset * (finalAcceleration + lastKey.y);\n                break;\n            } else {  \n                cumulativeValue += computeDisplacementIntegral(timeRange, timeRange, lastKey.y, key.y, velocityCumulative);\n                velocityCumulative += 0.5 * timeRange * (lastKey.y + key.y);\n            }\n        }\n        return cumulativeValue;\n    }\n\n    vec3 computeForcePositionOffset(in float normalizedAge, in float age, out vec3 velocityOffset) {\n        vec3 forcePosition;\n\n        #if defined(RENDERER_FOL_CONSTANT_MODE)\n            vec3 forceAcceleration = renderer_FOLMaxConst;\n\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                forceAcceleration = mix(renderer_FOLMinConst, forceAcceleration, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n\n            velocityOffset = forceAcceleration * age;\n\n            forcePosition = 0.5 * forceAcceleration * age * age;\n        #elif defined(RENDERER_FOL_CURVE_MODE)\n            forcePosition = vec3(\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientX, normalizedAge, velocityOffset.x),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientY, normalizedAge, velocityOffset.y),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientZ, normalizedAge, velocityOffset.z)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minVelocityOffset;\n\n                forcePosition = vec3(\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientX, normalizedAge, minVelocityOffset.x), forcePosition.x, a_Random2.x),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientY, normalizedAge, minVelocityOffset.y), forcePosition.y, a_Random2.y),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientZ, normalizedAge, minVelocityOffset.z), forcePosition.z, a_Random2.z)\n                );\n\n                velocityOffset = mix(minVelocityOffset, velocityOffset, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        return forcePosition;\n    }\n#endif"; // eslint-disable-line
+
+var limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n    uniform int renderer_LVLSpace;\n    uniform float renderer_LVLDampen;\n\n    // Scalar limit\n    #ifndef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform float renderer_LVLSpeedMaxConst;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform float renderer_LVLSpeedMinConst;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Per-axis limit\n    #ifdef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform vec3 renderer_LVLSpeedMaxConstVector;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec3 renderer_LVLSpeedMinConstVector;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedXMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedYMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedZMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedXMinCurve[4];\n                uniform vec2 renderer_LVLSpeedYMinCurve[4];\n                uniform vec2 renderer_LVLSpeedZMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Drag curve\n    #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n        uniform vec2 renderer_LVLDragMaxCurve[4];\n        #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n            uniform vec2 renderer_LVLDragMinCurve[4];\n        #endif\n    #endif\n\n    float evaluateLVLDrag(float normalizedAge, float dragRand) {\n        #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n            float dragMax = evaluateParticleCurve(renderer_LVLDragMaxCurve, normalizedAge);\n            #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n                float dragMin = evaluateParticleCurve(renderer_LVLDragMinCurve, normalizedAge);\n                return mix(dragMin, dragMax, dragRand);\n            #else\n                return dragMax;\n            #endif\n        #else\n            return mix(renderer_LVLDragConstant.x, renderer_LVLDragConstant.y, dragRand);\n        #endif\n    }\n\n    vec3 applyLVLSpeedLimitTF(vec3 velocity, float normalizedAge, float limitRand, float effectiveDampen) {\n        #ifdef RENDERER_LVL_SEPARATE_AXES\n            vec3 limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConstVector;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConstVector, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = vec3(\n                    evaluateParticleCurve(renderer_LVLSpeedXMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedYMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedZMaxCurve, normalizedAge)\n                );\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    vec3 minLimitSpeed = vec3(\n                        evaluateParticleCurve(renderer_LVLSpeedXMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedYMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedZMinCurve, normalizedAge)\n                    );\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            vec3 absVel = abs(velocity);\n            vec3 excess = max(absVel - limitSpeed, vec3(0.0));\n            velocity = sign(velocity) * (absVel - excess * effectiveDampen);\n        #else\n            float limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConst;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConst, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = evaluateParticleCurve(renderer_LVLSpeedMaxCurve, normalizedAge);\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    float minLimitSpeed = evaluateParticleCurve(renderer_LVLSpeedMinCurve, normalizedAge);\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            float speed = length(velocity);\n            if (speed > limitSpeed && speed > 0.0) {\n                float excess = speed - limitSpeed;\n                velocity = velocity * ((speed - excess * effectiveDampen) / speed);\n            }\n        #endif\n        return velocity;\n    }\n\n#endif\n"; // eslint-disable-line
+
+var particle_feedback_simulation = "// Transform Feedback update shader for particle simulation.\n// Update order: VOL/FOL → Dampen → Drag → Position.\n// Runs once per particle per frame (no rasterization).\n\n// Previous frame TF data\nattribute vec3 a_FeedbackPosition;\nattribute vec3 a_FeedbackVelocity;\n\n// Per-particle instance data\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec3 a_StartSize;\nattribute float a_StartSpeed;\nattribute vec4 a_Random0;\nattribute vec4 a_Random1;\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\nattribute vec4 a_Random2;\n\n// Uniforms\nuniform float renderer_CurrentTime;\nuniform float renderer_DeltaTime;\nuniform vec3 renderer_Gravity;\nuniform vec2 renderer_LVLDragConstant;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform int renderer_SimulationSpace;\n\n// TF outputs\nvarying vec3 v_FeedbackPosition;\nvarying vec3 v_FeedbackVelocity;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <limit_velocity_over_lifetime_module>\n\n// Get VOL instantaneous velocity at normalizedAge\nvec3 getVOLVelocity(float normalizedAge) {\n    vec3 vel = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        #ifdef RENDERER_VOL_CONSTANT_MODE\n            vel = renderer_VOLMaxConst;\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vel = mix(renderer_VOLMinConst, vel, a_Random1.yzw);\n            #endif\n        #endif\n        #ifdef RENDERER_VOL_CURVE_MODE\n            vel = vec3(\n                evaluateParticleCurve(renderer_VOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vec3 minVel = vec3(\n                    evaluateParticleCurve(renderer_VOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientZ, normalizedAge)\n                );\n                vel = mix(minVel, vel, a_Random1.yzw);\n            #endif\n        #endif\n    #endif\n    return vel;\n}\n\n// Get FOL instantaneous acceleration at normalizedAge\nvec3 getFOLAcceleration(float normalizedAge) {\n    vec3 acc = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        #ifdef RENDERER_FOL_CONSTANT_MODE\n            acc = renderer_FOLMaxConst;\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                acc = mix(renderer_FOLMinConst, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        #ifdef RENDERER_FOL_CURVE_MODE\n            acc = vec3(\n                evaluateParticleCurve(renderer_FOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minAcc = vec3(\n                    evaluateParticleCurve(renderer_FOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientZ, normalizedAge)\n                );\n                acc = mix(minAcc, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n    #endif\n    return acc;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float lifetime = a_ShapePositionStartLifeTime.w;\n    float normalizedAge = age / lifetime;\n    // Clamp to age on the first TF pass: particles emitted mid-frame have age < dt,\n    // so using the full dt would over-integrate. Subsequent passes are unaffected (age >= dt).\n    float dt = min(renderer_DeltaTime, age);\n\n    // normalizedAge < 0.0: stale TF slot whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 1.0 || normalizedAge < 0.0) {\n        v_FeedbackPosition = a_FeedbackPosition;\n        v_FeedbackVelocity = a_FeedbackVelocity;\n        gl_Position = vec4(0.0);\n        return;\n    }\n\n    vec4 worldRotation;\n    if (renderer_SimulationSpace == 0) {\n        worldRotation = renderer_WorldRotation;\n    } else {\n        worldRotation = a_SimulationWorldRotation;\n    }\n    vec4 invWorldRotation = quaternionConjugate(worldRotation);\n\n    // Read previous frame state (initialized by CPU on particle birth)\n    vec3 localVelocity = a_FeedbackVelocity;\n\n    // =====================================================\n    // Step 1: Apply velocity module deltas (VOL + FOL + Gravity)\n    // =====================================================\n\n    // Gravity (world space)\n    vec3 gravityDelta = renderer_Gravity * a_Random0.x * dt;\n\n    // VOL instantaneous velocity (animated velocity, not persisted)\n    vec3 volLocal = vec3(0.0);\n    vec3 volWorld = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 vol = getVOLVelocity(normalizedAge);\n        if (renderer_VOLSpace == 0) {\n            volLocal = vol;\n        } else {\n            volWorld = vol;\n        }\n    #endif\n\n    // FOL acceleration → velocity delta (always persisted, like gravity)\n    vec3 folDeltaLocal = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 folAcc = getFOLAcceleration(normalizedAge);\n        vec3 folVelDelta = folAcc * dt;\n        if (renderer_FOLSpace == 0) {\n            folDeltaLocal = folVelDelta;\n        } else {\n            // World FOL: convert to local and persist, same as gravity\n            folDeltaLocal = rotationByQuaternions(folVelDelta, invWorldRotation);\n        }\n    #endif\n\n    // Gravity and FOL contribute to base velocity (persisted, subject to dampen/drag).\n    vec3 gravityLocal = rotationByQuaternions(gravityDelta, invWorldRotation);\n    localVelocity += folDeltaLocal + gravityLocal;\n\n    // =====================================================\n    // Step 2 & 3: Dampen (Limit Velocity) + Drag\n    // VOL must be projected into the LVL target space so that\n    // limit/drag see the full velocity regardless of VOL.space vs LVL.space.\n    // =====================================================\n    #ifdef RENDERER_LVL_MODULE_ENABLED\n        // Precompute VOL in both spaces\n        vec3 volAsLocal = volLocal + rotationByQuaternions(volWorld, invWorldRotation);\n        vec3 volAsWorld = rotationByQuaternions(volLocal, worldRotation) + volWorld;\n\n        float limitRand = a_Random2.w;\n        float dampen = renderer_LVLDampen;\n        // Frame-rate independent dampen (30fps as reference)\n        float effectiveDampen = 1.0 - pow(1.0 - dampen, dt * 30.0);\n\n        if (renderer_LVLSpace == 0) {\n            // Local space: total = base + all VOL projected to local\n            vec3 totalLocal = localVelocity + volAsLocal;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalLocal, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = dampenedTotal - volAsLocal;\n        } else {\n            // World space: total = rotated base + all VOL projected to world\n            vec3 totalWorld = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalWorld, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = rotationByQuaternions(dampenedTotal - volAsWorld, invWorldRotation);\n        }\n\n        // Drag: same space as dampen\n        {\n            float dragCoeff = evaluateLVLDrag(normalizedAge, a_Random2.w);\n            if (dragCoeff > 0.0) {\n                vec3 totalVel;\n                if (renderer_LVLSpace == 0) {\n                    totalVel = localVelocity + volAsLocal;\n                } else {\n                    totalVel = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n                }\n                float velMagSqr = dot(totalVel, totalVel);\n                float velMag = sqrt(velMagSqr);\n\n                float drag = dragCoeff;\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_SIZE\n                    float maxDim = max(a_StartSize.x, max(a_StartSize.y, a_StartSize.z));\n                    float radius = maxDim * 0.5;\n                    drag *= 3.14159265 * radius * radius;\n                #endif\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_VELOCITY\n                    drag *= velMagSqr;\n                #endif\n\n                if (velMag > 0.0) {\n                    float newVelMag = max(0.0, velMag - drag * dt);\n                    vec3 draggedTotal = totalVel * (newVelMag / velMag);\n                    if (renderer_LVLSpace == 0) {\n                        localVelocity = draggedTotal - volAsLocal;\n                    } else {\n                        localVelocity = rotationByQuaternions(draggedTotal - volAsWorld, invWorldRotation);\n                    }\n                }\n            }\n        }\n    #endif\n\n    // =====================================================\n    // Step 4: Integrate position in simulation space\n    // Local mode: position in local space, velocity rotated to local\n    // World mode: position in world space, velocity rotated to world\n    // =====================================================\n    // FOL is now fully in localVelocity (both local and world-space FOL).\n    // Only VOL overlay needs to be added here.\n    vec3 totalVelocity;\n    if (renderer_SimulationSpace == 0) {\n      // Local: integrate in local space\n      totalVelocity = localVelocity + volLocal\n        + rotationByQuaternions(volWorld, invWorldRotation);\n    } else {\n      // World: integrate in world space\n      totalVelocity = rotationByQuaternions(localVelocity + volLocal, worldRotation) + volWorld;\n    }\n    vec3 position = a_FeedbackPosition + totalVelocity * dt;\n\n    v_FeedbackPosition = position;\n    v_FeedbackVelocity = localVelocity;\n    gl_Position = vec4(0.0);\n}\n"; // eslint-disable-line
 
 var sphere_billboard = "#ifdef RENDERER_MODE_SPHERE_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 sideVector = normalize(cross(camera_Forward, camera_Up));\n\tvec3 upVector = normalize(cross(sideVector, camera_Forward));\n\tcorner *= computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n    #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n        if (renderer_ThreeDStartRotation) {\n            vec3 rotation = radians(vec3(a_StartRotation0.xy, computeParticleRotationFloat(a_StartRotation0.z, age, normalizedAge)));\n            center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, rotation);\n        } else {\n            float rot = radians(computeParticleRotationFloat(a_StartRotation0.x, age, normalizedAge));\n            float c = cos(rot);\n            float s = sin(rot);\n            mat2 rotation = mat2(c, -s, s, c);\n            corner = rotation * corner;\n            center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n        }\n    #else\n        if (renderer_ThreeDStartRotation) {\n            center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, radians(a_StartRotation0));\n        } else {\n            float c = cos(radians(a_StartRotation0.x));\n            float s = sin(radians(a_StartRotation0.x));\n            mat2 rotation = mat2(c, -s, s, c);\n            corner = rotation * corner;\n            center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n        }\n    #endif\n#endif"; // eslint-disable-line
 
@@ -4934,6 +4938,8 @@ var ParticleShaderLib = {
     color_over_lifetime_module: color_over_lifetime_module,
     texture_sheet_animation_module: texture_sheet_animation_module,
     force_over_lifetime_module: force_over_lifetime_module,
+    limit_velocity_over_lifetime_module: limit_velocity_over_lifetime_module,
+    particle_feedback_simulation: particle_feedback_simulation,
     sphere_billboard: sphere_billboard,
     stretched_billboard: stretched_billboard,
     vertical_billboard: vertical_billboard,
@@ -5000,6 +5006,41 @@ var ShaderFactory = /*#__PURE__*/ function() {
             return "#define " + (m.value ? m.name + " " + m.value : m.name) + "\n";
         }).join("");
     };
+    /**
+   * @internal
+   * Compile vertex and fragment source with standard macros, includes, and version header.
+   * @param engine - Engine instance
+   * @param macroCollection - Current macro collection
+   * @param vertexSource - Raw vertex shader source (may contain #include)
+   * @param fragmentSource - Raw fragment shader source
+   * @returns Compiled { vertexSource, fragmentSource } ready for ShaderProgram
+   */ ShaderFactory.compilePlatformSource = function compilePlatformSource(engine, macroCollection, vertexSource, fragmentSource) {
+        var isWebGL2 = engine._hardwareRenderer.isWebGL2;
+        var shaderMacroList = new Array();
+        ShaderMacro._getMacrosElements(macroCollection, shaderMacroList);
+        shaderMacroList.push(ShaderMacro.getByName(isWebGL2 ? "GRAPHICS_API_WEBGL2" : "GRAPHICS_API_WEBGL1"));
+        if (engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
+            shaderMacroList.push(ShaderMacro.getByName("HAS_TEX_LOD"));
+        }
+        if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
+            shaderMacroList.push(ShaderMacro.getByName("HAS_DERIVATIVES"));
+        }
+        var noIncludeVertex = ShaderFactory.parseIncludes(vertexSource);
+        var noIncludeFrag = ShaderFactory.parseIncludes(fragmentSource);
+        var macroStr = ShaderFactory.parseCustomMacros(shaderMacroList);
+        noIncludeVertex = macroStr + noIncludeVertex;
+        noIncludeFrag = macroStr + noIncludeFrag;
+        if (isWebGL2) {
+            noIncludeVertex = ShaderFactory.convertTo300(noIncludeVertex);
+            noIncludeFrag = ShaderFactory.convertTo300(noIncludeFrag, true);
+        }
+        var versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
+        var 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";
+        return {
+            vertexSource: versionStr + "\nprecision highp float;\n" + noIncludeVertex,
+            fragmentSource: versionStr + "\n" + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + precisionStr + noIncludeFrag
+        };
+    };
     ShaderFactory.registerInclude = function registerInclude(includeName, includeSource) {
         if (ShaderLib[includeName]) {
             throw 'The "' + includeName + '" shader include already exist';
@@ -5332,7 +5373,7 @@ ShaderTagKey._nameMap = Object.create(null);
  * Shader program, corresponding to the GPU shader program.
  * @internal
  */ var ShaderProgram = /*#__PURE__*/ function() {
-    function ShaderProgram(engine, vertexSource, fragmentSource) {
+    function ShaderProgram(engine, vertexSource, fragmentSource, transformFeedbackVaryings) {
         this.sceneUniformBlock = new ShaderUniformBlock();
         this.cameraUniformBlock = new ShaderUniformBlock();
         this.rendererUniformBlock = new ShaderUniformBlock();
@@ -5348,7 +5389,7 @@ ShaderTagKey._nameMap = Object.create(null);
         this._activeTextureUint = 0;
         this._engine = engine;
         this._gl = engine._hardwareRenderer.gl;
-        this._glProgram = this._createProgram(vertexSource, fragmentSource);
+        this._glProgram = this._createProgram(vertexSource, fragmentSource, transformFeedbackVaryings);
         if (this._glProgram) {
             this._isValid = true;
             this._recordLocation();
@@ -5494,7 +5535,7 @@ ShaderTagKey._nameMap = Object.create(null);
     };
     /**
    * Init and link program with shader.
-   */ _proto._createProgram = function _createProgram(vertexSource, fragmentSource) {
+   */ _proto._createProgram = function _createProgram(vertexSource, fragmentSource, transformFeedbackVaryings) {
         var gl = this._gl;
         // Create and compile shader
         var vertexShader = this._createShader(gl.VERTEX_SHADER, vertexSource);
@@ -5512,6 +5553,10 @@ ShaderTagKey._nameMap = Object.create(null);
         }
         gl.attachShader(program, vertexShader);
         gl.attachShader(program, fragmentShader);
+        // Set Transform Feedback varyings before linking (WebGL2 only)
+        if (transformFeedbackVaryings == null ? void 0 : transformFeedbackVaryings.length) {
+            gl.transformFeedbackVaryings(program, transformFeedbackVaryings, gl.INTERLEAVED_ATTRIBS);
+        }
         gl.linkProgram(program);
         gl.validateProgram(program);
         gl.deleteShader(vertexShader);
@@ -5775,7 +5820,7 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
     /**
    * @internal
    */ _proto._getShaderProgram = function _getShaderProgram(engine, macroCollection) {
-        var shaderProgramPool = engine._getShaderProgramPool(this);
+        var shaderProgramPool = engine._getShaderProgramPool(this._shaderPassId, this._shaderProgramPools);
         var shaderProgram = shaderProgramPool.get(macroCollection);
         if (shaderProgram) {
             return shaderProgram;
@@ -5797,6 +5842,13 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         shaderProgramPools.length = 0;
     };
     _proto._getCanonicalShaderProgram = function _getCanonicalShaderProgram(engine, macroCollection) {
+        if (this._platformTarget != undefined) {
+            return this._getShaderLabProgram(engine, macroCollection);
+        }
+        var _ShaderFactory_compilePlatformSource = ShaderFactory.compilePlatformSource(engine, macroCollection, this._vertexSource, this._fragmentSource), vertexSource = _ShaderFactory_compilePlatformSource.vertexSource, fragmentSource = _ShaderFactory_compilePlatformSource.fragmentSource;
+        return new ShaderProgram(engine, vertexSource, fragmentSource);
+    };
+    _proto._getShaderLabProgram = function _getShaderLabProgram(engine, macroCollection) {
         var isWebGL2 = engine._hardwareRenderer.isWebGL2;
         var shaderMacroList = new Array();
         ShaderMacro._getMacrosElements(macroCollection, shaderMacroList);
@@ -5807,32 +5859,22 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
             shaderMacroList.push(ShaderMacro.getByName("HAS_DERIVATIVES"));
         }
-        // Compatible with non-shaderlab syntax
         var noIncludeVertex = ShaderFactory.parseIncludes(this._vertexSource);
         var noIncludeFrag = ShaderFactory.parseIncludes(this._fragmentSource);
-        // Parse macros when use shaderlab
-        if (this._platformTarget != undefined) {
-            noIncludeVertex = Shader._shaderLab._parseMacros(noIncludeVertex, shaderMacroList);
-            noIncludeFrag = Shader._shaderLab._parseMacros(noIncludeFrag, shaderMacroList);
-        } else {
-            var macroNameStr = ShaderFactory.parseCustomMacros(shaderMacroList);
-            noIncludeVertex = macroNameStr + noIncludeVertex;
-            noIncludeFrag = macroNameStr + noIncludeFrag;
-        }
-        // Need to convert to 300 es when the target is GLSL ES 100 or unkdown
-        if (isWebGL2 && (this._platformTarget == undefined || this._platformTarget === ShaderLanguage.GLSLES100)) {
+        noIncludeVertex = Shader._shaderLab._parseMacros(noIncludeVertex, shaderMacroList);
+        noIncludeFrag = Shader._shaderLab._parseMacros(noIncludeFrag, shaderMacroList);
+        if (isWebGL2 && this._platformTarget === ShaderLanguage.GLSLES100) {
             noIncludeVertex = ShaderFactory.convertTo300(noIncludeVertex);
             noIncludeFrag = ShaderFactory.convertTo300(noIncludeFrag, true);
         }
         var versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
-        var vertexSource = " " + versionStr + " \n        " + noIncludeVertex + "\n      ";
+        var vertexSource = " " + versionStr + "\n        " + noIncludeVertex + "\n      ";
         var fragmentSource = " " + versionStr + "\n        " + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + "\n        " + precisionStr + "\n        " + noIncludeFrag + "\n      ";
-        var shaderProgram = new ShaderProgram(engine, vertexSource, fragmentSource);
-        return shaderProgram;
+        return new ShaderProgram(engine, vertexSource, fragmentSource);
     };
     return ShaderPass;
 }(ShaderPart);
-ShaderPass._shaderPassCounter = 0;
+/** @internal */ ShaderPass._shaderPassCounter = 0;
 /** @internal */ ShaderPass._shaderRootPath = "shaders://root/";
 
 /**
@@ -18471,6 +18513,15 @@ var TextChunk = function TextChunk() {
         this._platformBuffer.getData(data, bufferByteOffset, dataOffset, dataLength);
     };
     /**
+   * Copy data from another buffer on the GPU.
+   * @param srcBuffer - Source buffer
+   * @param srcByteOffset - Byte offset in the source buffer
+   * @param dstByteOffset - Byte offset in this buffer
+   * @param byteLength - Number of bytes to copy
+   */ _proto.copyFromBuffer = function copyFromBuffer(srcBuffer, srcByteOffset, dstByteOffset, byteLength) {
+        this._platformBuffer.copyFromBuffer(srcBuffer._platformBuffer, srcByteOffset, dstByteOffset, byteLength);
+    };
+    /**
    * Mark buffer as readable, the `data` property will be not accessible anymore.
    */ _proto.markAsUnreadable = function markAsUnreadable() {
         this._data = null;
@@ -18765,8 +18816,8 @@ var BufferUtil = /*#__PURE__*/ function() {
 /**
  * Buffer binding flag.
  */ var BufferBindFlag = /*#__PURE__*/ function(BufferBindFlag) {
-    /** Vertex buffer binding flag */ BufferBindFlag[BufferBindFlag["VertexBuffer"] = 0] = "VertexBuffer";
-    /** Index buffer binding flag */ BufferBindFlag[BufferBindFlag["IndexBuffer"] = 1] = "IndexBuffer";
+    /** Vertex buffer binding flag. */ BufferBindFlag[BufferBindFlag["VertexBuffer"] = 0] = "VertexBuffer";
+    /** Index buffer binding flag. */ BufferBindFlag[BufferBindFlag["IndexBuffer"] = 1] = "IndexBuffer";
     return BufferBindFlag;
 }({});
 
@@ -26202,6 +26253,15 @@ PointerEventEmitter._tempRay = new engineMath.Ray();
     return ParticleBillboardVertexAttribute;
 }({});
 
+/**
+ * @internal
+ * Vertex attributes for the Transform Feedback buffer.
+ */ var ParticleFeedbackVertexAttribute = /*#__PURE__*/ function(ParticleFeedbackVertexAttribute) {
+    ParticleFeedbackVertexAttribute["Position"] = "a_FeedbackPosition";
+    ParticleFeedbackVertexAttribute["Velocity"] = "a_FeedbackVelocity";
+    return ParticleFeedbackVertexAttribute;
+}({});
+
 /**
  * @internal
  */ var ParticleInstanceVertexAttribute = /*#__PURE__*/ function(ParticleInstanceVertexAttribute) {
@@ -26296,6 +26356,22 @@ PointerEventEmitter._tempRay = new engineMath.Ray();
         return _class;
     }(ContentRestorer))());
 };
+ParticleBufferUtils.feedbackVertexStride = 24;
+ParticleBufferUtils.feedbackVertexElements = [
+    new VertexElement(ParticleFeedbackVertexAttribute.Position, 0, VertexElementFormat.Vector3, 0),
+    new VertexElement(ParticleFeedbackVertexAttribute.Velocity, 12, VertexElementFormat.Vector3, 0)
+];
+ParticleBufferUtils.feedbackInstanceElements = [
+    new VertexElement(ParticleInstanceVertexAttribute.ShapePositionStartLifeTime, 0, VertexElementFormat.Vector4, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.DirectionTime, 16, VertexElementFormat.Vector4, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.StartSize, 48, VertexElementFormat.Vector3, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.StartSpeed, 72, VertexElementFormat.Float, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.Random0, 76, VertexElementFormat.Vector4, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.Random1, 92, VertexElementFormat.Vector4, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.SimulationWorldPosition, 108, VertexElementFormat.Vector3, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.SimulationWorldRotation, 120, VertexElementFormat.Vector4, 0),
+    new VertexElement(ParticleInstanceVertexAttribute.Random2, 152, VertexElementFormat.Vector4, 0)
+];
 ParticleBufferUtils.instanceVertexStride = 168;
 ParticleBufferUtils.instanceVertexFloatStride = ParticleBufferUtils.instanceVertexStride / 4;
 ParticleBufferUtils.startLifeTimeOffset = 3;
@@ -26328,7 +26404,7 @@ var depthOnlyVs = "#define MATERIAL_OMIT_NORMAL\n#include <common>\n#include <co
 
 var particleFs = "#include <common>\n\nvarying vec4 v_Color;\nvarying vec2 v_TextureCoordinate;\nuniform sampler2D material_BaseTexture;\nuniform vec4 material_BaseColor;\n \nuniform mediump vec3 material_EmissiveColor;\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n    uniform sampler2D material_EmissiveTexture;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n\tvarying vec4 v_MeshColor;\n#endif\n\nvoid main() {\n\tvec4 color = material_BaseColor * v_Color;\n\n\t#if defined(RENDERER_MODE_MESH) && defined(RENDERER_ENABLE_VERTEXCOLOR)\n\t\tcolor *= v_MeshColor;\n\t#endif\n\n\t#ifdef MATERIAL_HAS_BASETEXTURE\n\t\tcolor *= texture2DSRGB(material_BaseTexture, v_TextureCoordinate);\n\t#endif\n\t\n\t// Emissive\n\tvec3 emissiveRadiance = material_EmissiveColor;\n\t#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n\t\temissiveRadiance *= texture2DSRGB(material_EmissiveTexture, v_TextureCoordinate).rgb;\n\t#endif\n\n\tcolor.rgb += emissiveRadiance;\n\n\tgl_FragColor = color;\n}"; // eslint-disable-line
 
-var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec2 u_DragConstant;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n\nvec3 getStartPosition(vec3 startVelocity, float age, vec3 dragData) {\n    vec3 startPosition;\n    float lastTime = min(startVelocity.x / dragData.x, age); // todo 0/0\n    startPosition = lastTime * (startVelocity - 0.5 * dragData * lastTime);\n    return startPosition;\n}\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, vec3 dragData, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = getStartPosition(startVelocity, age, dragData);\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    if (normalizedAge < 1.0) {\n        vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n        vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity = startVelocity;\n        vec3 worldVelocity = gravityVelocity;\n\n        //drag\n        vec3 dragData = a_DirectionTime.xyz * mix(u_DragConstant.x, u_DragConstant.y, a_Random0.x);\n        vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, dragData, localVelocity, worldVelocity);\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
+var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\n#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE) || defined(RENDERER_LVL_MODULE_ENABLED)\n    attribute vec4 a_Random2;\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\n#ifdef RENDERER_TRANSFORM_FEEDBACK\n    attribute vec3 a_FeedbackPosition;\n    attribute vec3 a_FeedbackVelocity;\n#endif\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = startVelocity * age;\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    // normalizedAge >= 0.0: skip stale TF slots whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 0.0 && normalizedAge < 1.0) {\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity;\n        vec3 worldVelocity;\n\n        #ifdef RENDERER_TRANSFORM_FEEDBACK\n            // Transform Feedback mode: position in simulation space (local or world).\n            // Local: transform to world; World: use directly.\n            vec3 center;\n            if (renderer_SimulationSpace == 0) {\n                center = rotationByQuaternions(a_FeedbackPosition, worldRotation) + renderer_WorldPosition;\n            } else if (renderer_SimulationSpace == 1) {\n                center = a_FeedbackPosition;\n            }\n            localVelocity = a_FeedbackVelocity;\n            worldVelocity = vec3(0.0);\n\n            #ifdef _VOL_MODULE_ENABLED\n                vec3 instantVOLVelocity;\n                computeVelocityPositionOffset(normalizedAge, age, instantVOLVelocity);\n                if (renderer_VOLSpace == 0) {\n                    localVelocity += instantVOLVelocity;\n                } else {\n                    worldVelocity += instantVOLVelocity;\n                }\n            #endif\n        #else\n            // Original analytical path\n            vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n            vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n            localVelocity = startVelocity;\n            worldVelocity = gravityVelocity;\n            vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, localVelocity, worldVelocity);\n        #endif\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
 
 var pbrSpecularFs = "#include <common>\n#include <camera_declare>\n\n#include <FogFragmentDeclaration>\n\n#include <uv_share>\n#include <normal_share>\n#include <color_share>\n#include <worldpos_share>\n\n#include <light_frag_define>\n\n\n#include <pbr_frag_define>\n#include <pbr_helper>\n\nvoid main() {\n    #include <pbr_frag>\n    #include <FogFragment>\n}\n"; // eslint-disable-line
 
@@ -26364,12 +26440,46 @@ var unlitFs = "#include <common>\n#include <uv_share>\n#include <FogFragmentDecl
 
 var unlitVs = "#include <common>\n#include <common_vert>\n#include <blendShape_input>\n#include <uv_share>\n#include <FogVertexDeclaration>\n\nvoid main() {\n\n    #include <begin_position_vert>\n    #include <blendShape_vert>\n    #include <skinning_vert>\n    #include <uv_vert>\n    #include <position_vert>\n\n    #include <FogVertex>\n}\n"; // eslint-disable-line
 
+/**
+ * @internal
+ * Shared shader definition for Transform Feedback simulation.
+ * Multiple simulators using the same shader share a single program pool per engine.
+ */ var TransformFeedbackShader = /*#__PURE__*/ function() {
+    function TransformFeedbackShader(vertexSource, fragmentSource, feedbackVaryings) {
+        this._id = ShaderPass._shaderPassCounter++;
+        this.vertexSource = vertexSource;
+        this.fragmentSource = fragmentSource;
+        this.feedbackVaryings = feedbackVaryings;
+    }
+    var _proto = TransformFeedbackShader.prototype;
+    /**
+   * Get or compile a shader program for the given engine and macro combination.
+   */ _proto.getProgram = function getProgram(engine, macroCollection) {
+        var pool = engine._getShaderProgramPool(this._id);
+        var program = pool.get(macroCollection);
+        if (program) return program;
+        var _ShaderFactory_compilePlatformSource = ShaderFactory.compilePlatformSource(engine, macroCollection, this.vertexSource, this.fragmentSource), vertexSource = _ShaderFactory_compilePlatformSource.vertexSource, fragmentSource = _ShaderFactory_compilePlatformSource.fragmentSource;
+        program = new ShaderProgram(engine, vertexSource, fragmentSource, this.feedbackVaryings);
+        if (!program.isValid) {
+            Logger.error("TransformFeedbackShader: Failed to compile shader program.");
+            return null;
+        }
+        pool.cache(program);
+        return program;
+    };
+    return TransformFeedbackShader;
+}();
+
 /**
  * Internal shader pool.
  * @internal
  */ var ShaderPool = /*#__PURE__*/ function() {
     function ShaderPool() {}
     ShaderPool.init = function init() {
+        ShaderPool.particleFeedbackShader = new TransformFeedbackShader("#include <particle_feedback_simulation>", "void main() { discard; }", [
+            "v_FeedbackPosition",
+            "v_FeedbackVelocity"
+        ]);
         var shadowCasterPass = new ShaderPass("ShadowCaster", shadowMapVs, shadowMapFs, {
             pipelineStage: PipelineStage.ShadowCaster
         });
@@ -26862,8 +26972,7 @@ ShaderPool.init();
     };
     /**
    * @internal
-   */ _proto._getShaderProgramPool = function _getShaderProgramPool(shaderPass) {
-        var index = shaderPass._shaderPassId;
+   */ _proto._getShaderProgramPool = function _getShaderProgramPool(index, trackPools) {
         var shaderProgramPools = this._shaderProgramPools;
         var pool = shaderProgramPools[index];
         if (!pool) {
@@ -26872,7 +26981,7 @@ ShaderPool.init();
                 shaderProgramPools.length = length;
             }
             shaderProgramPools[index] = pool = new ShaderProgramPool(this);
-            shaderPass._shaderProgramPools.push(pool);
+            trackPools == null ? void 0 : trackPools.push(pool);
         }
         return pool;
     };
@@ -33263,6 +33372,10 @@ var ParticleStopMode = /*#__PURE__*/ function(ParticleStopMode) {
         shaderData.setFloat(ParticleRenderer._currentTime, this.generator._playTime);
         shaderData.setVector3(ParticleRenderer._pivotOffsetProperty, this.pivot);
         this.generator._updateShaderData(shaderData);
+        // Run Transform Feedback simulation after shader data is up to date
+        if (generator._useTransformFeedback) {
+            generator._updateFeedback(shaderData, this.engine.time.deltaTime * generator.main.simulationSpeed);
+        }
     };
     _proto._render = function _render(context) {
         var generator = this.generator;
@@ -33271,7 +33384,9 @@ var ParticleStopMode = /*#__PURE__*/ function(ParticleStopMode) {
         if (!aliveParticleCount) {
             return;
         }
-        generator._primitive.instanceCount = aliveParticleCount;
+        // Transform Feedback: render all slots (instance buffer not compacted, dead particles discarded in shader)
+        // Non-Transform Feedback: render only alive particles (instance buffer compacted)
+        generator._primitive.instanceCount = generator._useTransformFeedback ? generator._firstActiveElement <= generator._firstFreeElement ? generator._firstFreeElement : generator._currentParticleCount : aliveParticleCount;
         var material = this.getMaterial();
         if (!material || this._renderMode === ParticleRenderMode.Mesh && !this._mesh) {
             return;
@@ -33427,6 +33542,331 @@ __decorate([
     return ParticleUpdateFlags;
 }({});
 
+/**
+ * Transform Feedback object for GPU-based data capture.
+ * @internal
+ */ var TransformFeedback = /*#__PURE__*/ function(GraphicsResource) {
+    _inherits(TransformFeedback, GraphicsResource);
+    function TransformFeedback(engine) {
+        var _this;
+        _this = GraphicsResource.call(this, engine) || this;
+        _this._platformTransformFeedback = engine._hardwareRenderer.createPlatformTransformFeedback();
+        return _this;
+    }
+    var _proto = TransformFeedback.prototype;
+    /**
+   * Bind this Transform Feedback object as active.
+   */ _proto.bind = function bind() {
+        this._platformTransformFeedback.bind();
+    };
+    /**
+   * Bind a buffer range as output at the given index.
+   * @param index - Output binding point index (corresponds to varying index in shader)
+   * @param buffer - Output buffer to capture data into
+   * @param byteOffset - Starting byte offset in the buffer
+   * @param byteSize - Size in bytes of the capture range
+   */ _proto.bindBufferRange = function bindBufferRange(index, buffer, byteOffset, byteSize) {
+        this._platformTransformFeedback.bindBufferRange(index, buffer._platformBuffer, byteOffset, byteSize);
+    };
+    /**
+   * Begin a Transform Feedback pass.
+   * @param primitiveMode - Primitive topology mode
+   */ _proto.begin = function begin(primitiveMode) {
+        this._platformTransformFeedback.begin(primitiveMode);
+    };
+    /**
+   * End the current Transform Feedback pass.
+   */ _proto.end = function end() {
+        this._platformTransformFeedback.end();
+    };
+    /**
+   * Unbind the output buffer at the given index from the Transform Feedback target.
+   * @param index - Output binding point index
+   */ _proto.unbindBuffer = function unbindBuffer(index) {
+        this._platformTransformFeedback.unbindBuffer(index);
+    };
+    /**
+   * Unbind this Transform Feedback object.
+   */ _proto.unbind = function unbind() {
+        this._platformTransformFeedback.unbind();
+    };
+    _proto._rebuild = function _rebuild() {
+        this._platformTransformFeedback = this._engine._hardwareRenderer.createPlatformTransformFeedback();
+    };
+    _proto._onDestroy = function _onDestroy() {
+        GraphicsResource.prototype._onDestroy.call(this);
+        this._platformTransformFeedback.destroy();
+    };
+    return TransformFeedback;
+}(GraphicsResource);
+
+/**
+ * @internal
+ * Primitive for Transform Feedback simulation with read/write buffer swapping.
+ */ var TransformFeedbackPrimitive = /*#__PURE__*/ function(GraphicsResource) {
+    _inherits(TransformFeedbackPrimitive, GraphicsResource);
+    function TransformFeedbackPrimitive(engine, byteStride) {
+        var _this;
+        _this = GraphicsResource.call(this, engine) || this, _this._readIsA = true;
+        _this._byteStride = byteStride;
+        _this._transformFeedback = new TransformFeedback(engine);
+        _this._transformFeedback.isGCIgnored = true;
+        _this._platformPrimitive = engine._hardwareRenderer.createPlatformTransformFeedbackPrimitive();
+        _this.isGCIgnored = true;
+        return _this;
+    }
+    var _proto = TransformFeedbackPrimitive.prototype;
+    /**
+   * Resize read and write buffers.
+   * @param vertexCount - Number of vertices to allocate
+   */ _proto.resize = function resize(vertexCount) {
+        var byteLength = this._byteStride * vertexCount;
+        var bufferA = new Buffer(this._engine, BufferBindFlag.VertexBuffer, byteLength, BufferUsage.Dynamic, false);
+        bufferA.isGCIgnored = true;
+        var bufferB = new Buffer(this._engine, BufferBindFlag.VertexBuffer, byteLength, BufferUsage.Dynamic, false);
+        bufferB.isGCIgnored = true;
+        this._bindingA = new VertexBufferBinding(bufferA, this._byteStride);
+        this._bindingB = new VertexBufferBinding(bufferB, this._byteStride);
+        this._readIsA = true;
+        this._platformPrimitive.invalidate();
+    };
+    /**
+   * Update vertex layout, only rebuilds when program changes.
+   * @param program - Shader program for attribute locations
+   * @param feedbackElements - Vertex elements describing the read/write buffer
+   * @param inputBinding - Additional input buffer binding
+   * @param inputElements - Vertex elements describing the input buffer
+   */ _proto.updateVertexLayout = function updateVertexLayout(program, feedbackElements, inputBinding, inputElements) {
+        this._platformPrimitive.updateVertexLayout(program, this._bindingA, this._bindingB, feedbackElements, inputBinding, inputElements);
+    };
+    /**
+   * Bind state before issuing draw calls.
+   */ _proto.beginDraw = function beginDraw() {
+        this._engine._hardwareRenderer.enableRasterizerDiscard();
+        this._transformFeedback.bind();
+        this._platformPrimitive.bind(this._readIsA);
+    };
+    /**
+   * Issue a draw call for a vertex range, capturing output to the write buffer.
+   * @param mode - Primitive topology
+   * @param first - First vertex index
+   * @param count - Number of vertices
+   */ _proto.draw = function draw(mode, first, count) {
+        var transformFeedback = this._transformFeedback;
+        transformFeedback.bindBufferRange(0, this.writeBinding.buffer, first * this._byteStride, count * this._byteStride);
+        transformFeedback.begin(mode);
+        this._platformPrimitive.draw(mode, first, count);
+        transformFeedback.end();
+    };
+    /**
+   * Unbind state after draw calls.
+   */ _proto.endDraw = function endDraw() {
+        this._platformPrimitive.unbind();
+        this._transformFeedback.unbindBuffer(0);
+        this._transformFeedback.unbind();
+        this._engine._hardwareRenderer.disableRasterizerDiscard();
+        this._engine._hardwareRenderer.invalidateShaderProgramState();
+    };
+    /**
+   * Swap read and write buffers.
+   */ _proto.swap = function swap() {
+        this._readIsA = !this._readIsA;
+    };
+    _proto._rebuild = function _rebuild() {
+        this._platformPrimitive = this._engine._hardwareRenderer.createPlatformTransformFeedbackPrimitive();
+    };
+    _proto._onDestroy = function _onDestroy() {
+        var _this__platformPrimitive, _this__bindingA, _this__bindingB, _this__transformFeedback;
+        GraphicsResource.prototype._onDestroy.call(this);
+        (_this__platformPrimitive = this._platformPrimitive) == null ? void 0 : _this__platformPrimitive.destroy();
+        (_this__bindingA = this._bindingA) == null ? void 0 : _this__bindingA.buffer.destroy();
+        (_this__bindingB = this._bindingB) == null ? void 0 : _this__bindingB.buffer.destroy();
+        (_this__transformFeedback = this._transformFeedback) == null ? void 0 : _this__transformFeedback.destroy();
+    };
+    _create_class(TransformFeedbackPrimitive, [
+        {
+            key: "readBinding",
+            get: /**
+   * The current read buffer binding.
+   */ function get() {
+                return this._readIsA ? this._bindingA : this._bindingB;
+            }
+        },
+        {
+            key: "writeBinding",
+            get: /**
+   * The current write buffer binding.
+   */ function get() {
+                return this._readIsA ? this._bindingB : this._bindingA;
+            }
+        }
+    ]);
+    return TransformFeedbackPrimitive;
+}(GraphicsResource);
+
+/**
+ * @internal
+ * General-purpose Transform Feedback simulator.
+ * Manages per-frame simulation with shared shader program caching.
+ */ var TransformFeedbackSimulator = /*#__PURE__*/ function() {
+    function TransformFeedbackSimulator(engine, byteStride, shader) {
+        this._engine = engine;
+        this._primitive = new TransformFeedbackPrimitive(engine, byteStride);
+        this._shader = shader;
+    }
+    var _proto = TransformFeedbackSimulator.prototype;
+    /**
+   * Resize feedback buffers.
+   * @param vertexCount - Number of vertices to allocate
+   */ _proto.resize = function resize(vertexCount) {
+        this._primitive.resize(vertexCount);
+    };
+    /**
+   * Begin a simulation step: get/compile program, bind, upload uniforms, update layout.
+   * @param shaderData - Shader data with current macros and uniforms
+   * @param feedbackElements - Vertex elements for the feedback buffer
+   * @param inputBinding - Input buffer binding
+   * @param inputElements - Vertex elements for the input buffer
+   */ _proto.beginUpdate = function beginUpdate(shaderData, feedbackElements, inputBinding, inputElements) {
+        var program = this._shader.getProgram(this._engine, shaderData._macroCollection);
+        if (!program) return false;
+        program.bind();
+        program.uploadUniforms(program.rendererUniformBlock, shaderData);
+        program.uploadUniforms(program.otherUniformBlock, shaderData);
+        this._primitive.updateVertexLayout(program, feedbackElements, inputBinding, inputElements);
+        this._primitive.beginDraw();
+        return true;
+    };
+    /**
+   * Issue a draw call for a vertex range.
+   * @param mode - Primitive topology
+   * @param first - First vertex index
+   * @param count - Number of vertices
+   */ _proto.draw = function draw(mode, first, count) {
+        this._primitive.draw(mode, first, count);
+    };
+    /**
+   * End the simulation step: unbind state and swap buffers.
+   */ _proto.endUpdate = function endUpdate() {
+        this._primitive.endDraw();
+        this._primitive.swap();
+    };
+    _proto.destroy = function destroy() {
+        var _this__primitive;
+        (_this__primitive = this._primitive) == null ? void 0 : _this__primitive.destroy();
+    };
+    _create_class(TransformFeedbackSimulator, [
+        {
+            key: "readBinding",
+            get: /**
+   * The current read buffer binding.
+   */ function get() {
+                return this._primitive.readBinding;
+            }
+        },
+        {
+            key: "writeBinding",
+            get: /**
+   * The current write buffer binding.
+   */ function get() {
+                return this._primitive.writeBinding;
+            }
+        }
+    ]);
+    return TransformFeedbackSimulator;
+}();
+
+/**
+ * @internal
+ * Particle-specific Transform Feedback simulation.
+ */ var ParticleTransformFeedbackSimulator = /*#__PURE__*/ function() {
+    function ParticleTransformFeedbackSimulator(engine) {
+        this._particleInitData = new Float32Array(6);
+        this._simulator = new TransformFeedbackSimulator(engine, ParticleBufferUtils.feedbackVertexStride, ShaderPool.particleFeedbackShader);
+    }
+    var _proto = ParticleTransformFeedbackSimulator.prototype;
+    /**
+   * Resize feedback buffers.
+   * Saves pre-resize buffers internally for subsequent `copyOldBufferData` / `destroyOldBuffers` calls.
+   * @param particleCount - Number of particles to allocate
+   * @param instanceBinding - New instance vertex buffer binding
+   */ _proto.resize = function resize(particleCount, instanceBinding) {
+        var _this__simulator_readBinding, _this__simulator_writeBinding;
+        this._oldReadBuffer = (_this__simulator_readBinding = this._simulator.readBinding) == null ? void 0 : _this__simulator_readBinding.buffer;
+        this._oldWriteBuffer = (_this__simulator_writeBinding = this._simulator.writeBinding) == null ? void 0 : _this__simulator_writeBinding.buffer;
+        this._simulator.resize(particleCount);
+        this._instanceBinding = instanceBinding;
+    };
+    /**
+   * Write initial position and velocity for a newly emitted particle.
+   */ _proto.writeParticleData = function writeParticleData(index, position, vx, vy, vz) {
+        var data = this._particleInitData;
+        data[0] = position.x;
+        data[1] = position.y;
+        data[2] = position.z;
+        data[3] = vx;
+        data[4] = vy;
+        data[5] = vz;
+        var simulator = this._simulator;
+        var byteOffset = index * ParticleBufferUtils.feedbackVertexStride;
+        simulator.readBinding.buffer.setData(data, byteOffset);
+        simulator.writeBinding.buffer.setData(data, byteOffset);
+    };
+    /**
+   * Copy data from pre-resize buffers to current buffers.
+   * Must be called after `resize` which saves the old buffers.
+   */ _proto.copyOldBufferData = function copyOldBufferData(srcByteOffset, dstByteOffset, byteLength) {
+        this._simulator.readBinding.buffer.copyFromBuffer(this._oldReadBuffer, srcByteOffset, dstByteOffset, byteLength);
+        this._simulator.writeBinding.buffer.copyFromBuffer(this._oldWriteBuffer, srcByteOffset, dstByteOffset, byteLength);
+    };
+    /**
+   * Destroy pre-resize buffers saved during `resize`.
+   */ _proto.destroyOldBuffers = function destroyOldBuffers() {
+        var _this__oldReadBuffer, _this__oldWriteBuffer;
+        (_this__oldReadBuffer = this._oldReadBuffer) == null ? void 0 : _this__oldReadBuffer.destroy();
+        (_this__oldWriteBuffer = this._oldWriteBuffer) == null ? void 0 : _this__oldWriteBuffer.destroy();
+        this._oldReadBuffer = null;
+        this._oldWriteBuffer = null;
+    };
+    /**
+   * Run one simulation step.
+   * @param shaderData - Shader data with current macros and uniforms
+   * @param particleCount - Total particle slot count
+   * @param firstActive - First active particle index in ring buffer
+   * @param firstFree - First free particle index in ring buffer
+   * @param deltaTime - Frame delta time
+   */ _proto.update = function update(shaderData, particleCount, firstActive, firstFree, deltaTime) {
+        if (firstActive === firstFree) return;
+        shaderData.setFloat(ParticleTransformFeedbackSimulator._deltaTimeProperty, deltaTime);
+        if (!this._simulator.beginUpdate(shaderData, ParticleBufferUtils.feedbackVertexElements, this._instanceBinding, ParticleBufferUtils.feedbackInstanceElements)) return;
+        if (firstActive < firstFree) {
+            this._simulator.draw(MeshTopology.Points, firstActive, firstFree - firstActive);
+        } else {
+            this._simulator.draw(MeshTopology.Points, firstActive, particleCount - firstActive);
+            if (firstFree > 0) {
+                this._simulator.draw(MeshTopology.Points, 0, firstFree);
+            }
+        }
+        this._simulator.endUpdate();
+    };
+    _proto.destroy = function destroy() {
+        var _this__simulator;
+        (_this__simulator = this._simulator) == null ? void 0 : _this__simulator.destroy();
+    };
+    _create_class(ParticleTransformFeedbackSimulator, [
+        {
+            key: "readBinding",
+            get: /**
+   * The current read buffer binding for the render pass.
+   */ function get() {
+                return this._simulator.readBinding;
+            }
+        }
+    ]);
+    return ParticleTransformFeedbackSimulator;
+}();
+ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName("renderer_DeltaTime");
+
 /**
  * Particle curve mode.
  */ var ParticleCurveMode = /*#__PURE__*/ function(ParticleCurveMode) {
@@ -33466,6 +33906,7 @@ __decorate([
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["Shape"] = 2941263940] = "Shape";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["GravityModifier"] = 2759560269] = "GravityModifier";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
+    ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
     return ParticleRandomSubSeeds;
 }({});
 
@@ -34523,6 +34964,415 @@ __decorate([
     deepClone
 ], ForceOverLifetimeModule.prototype, "_forceZ", void 0);
 
+/**
+ * Limit velocity over lifetime module.
+ */ var LimitVelocityOverLifetimeModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+    _inherits(LimitVelocityOverLifetimeModule, ParticleGeneratorModule);
+    function LimitVelocityOverLifetimeModule(generator) {
+        var _this;
+        _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._speedRand = new engineMath.Rand(0, ParticleRandomSubSeeds.LimitVelocityOverLifetime), _this._speedMinConstantVec = new engineMath.Vector3(), _this._speedMaxConstantVec = new engineMath.Vector3(), _this._dragConstantVec = new engineMath.Vector2(), _this._separateAxes = false, _this._dampen = 0, _this._multiplyDragByParticleSize = false, _this._multiplyDragByParticleVelocity = false, _this._space = ParticleSimulationSpace.Local;
+        _this.speedX = new ParticleCompositeCurve(1);
+        _this.speedY = new ParticleCompositeCurve(1);
+        _this.speedZ = new ParticleCompositeCurve(1);
+        _this.drag = new ParticleCompositeCurve(0);
+        return _this;
+    }
+    var _proto = LimitVelocityOverLifetimeModule.prototype;
+    /**
+   * @internal
+   */ _proto._isDragRandomMode = function _isDragRandomMode() {
+        return this._drag.mode === ParticleCurveMode.TwoConstants || this._drag.mode === ParticleCurveMode.TwoCurves;
+    };
+    /**
+   * @internal
+   */ _proto._isSpeedRandomMode = function _isSpeedRandomMode() {
+        if (this._separateAxes) {
+            return (this._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves) && (this._speedY.mode === ParticleCurveMode.TwoConstants || this._speedY.mode === ParticleCurveMode.TwoCurves) && (this._speedZ.mode === ParticleCurveMode.TwoConstants || this._speedZ.mode === ParticleCurveMode.TwoCurves);
+        }
+        return this._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves;
+    };
+    /**
+   * @internal
+   */ _proto._updateShaderData = function _updateShaderData(shaderData) {
+        var enabledModuleMacro = null;
+        var separateAxesMacro = null;
+        var speedModeMacro = null;
+        var speedRandomMacro = null;
+        var dragCurveMacro = null;
+        var dragRandomMacro = null;
+        var dragSizeMacro = null;
+        var dragVelocityMacro = null;
+        if (this.enabled) {
+            enabledModuleMacro = LimitVelocityOverLifetimeModule._enabledMacro;
+            // Dampen
+            shaderData.setFloat(LimitVelocityOverLifetimeModule._dampenProperty, this._dampen);
+            // Space
+            shaderData.setInt(LimitVelocityOverLifetimeModule._spaceProperty, this._space);
+            // Limit speed
+            if (this._separateAxes) {
+                separateAxesMacro = LimitVelocityOverLifetimeModule._separateAxesMacro;
+                var result = this._uploadSeparateAxisSpeeds(shaderData);
+                speedModeMacro = result.modeMacro;
+                speedRandomMacro = result.randomMacro;
+            } else {
+                var result1 = this._uploadScalarSpeed(shaderData);
+                speedModeMacro = result1.modeMacro;
+                speedRandomMacro = result1.randomMacro;
+            }
+            // Drag
+            var dragResult = this._uploadDrag(shaderData);
+            dragCurveMacro = dragResult.curveMacro;
+            dragRandomMacro = dragResult.randomMacro;
+            // Drag modifiers
+            if (this._multiplyDragByParticleSize) {
+                dragSizeMacro = LimitVelocityOverLifetimeModule._multiplyDragBySizeMacro;
+            }
+            if (this._multiplyDragByParticleVelocity) {
+                dragVelocityMacro = LimitVelocityOverLifetimeModule._multiplyDragByVelocityMacro;
+            }
+        }
+        this._enabledModuleMacro = this._enableMacro(shaderData, this._enabledModuleMacro, enabledModuleMacro);
+        this._separateAxesCachedMacro = this._enableMacro(shaderData, this._separateAxesCachedMacro, separateAxesMacro);
+        this._speedModeMacro = this._enableMacro(shaderData, this._speedModeMacro, speedModeMacro);
+        this._speedRandomMacro = this._enableMacro(shaderData, this._speedRandomMacro, speedRandomMacro);
+        this._dragCurveCachedMacro = this._enableMacro(shaderData, this._dragCurveCachedMacro, dragCurveMacro);
+        this._dragRandomCachedMacro = this._enableMacro(shaderData, this._dragRandomCachedMacro, dragRandomMacro);
+        this._dragSizeMacro = this._enableMacro(shaderData, this._dragSizeMacro, dragSizeMacro);
+        this._dragVelocityMacro = this._enableMacro(shaderData, this._dragVelocityMacro, dragVelocityMacro);
+    };
+    /**
+   * @internal
+   */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
+        this._speedRand.reset(seed, ParticleRandomSubSeeds.LimitVelocityOverLifetime);
+    };
+    _proto._uploadScalarSpeed = function _uploadScalarSpeed(shaderData) {
+        var speedX = this._speedX;
+        var modeMacro = null;
+        var randomMacro = null;
+        var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves;
+        if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve) {
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMaxCurveProperty, speedX.curveMax._getTypeArray());
+            modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
+            if (isRandomCurveMode) {
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMinCurveProperty, speedX.curveMin._getTypeArray());
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
+            }
+        } else {
+            shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMaxConstProperty, speedX.constantMax);
+            modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
+            if (speedX.mode === ParticleCurveMode.TwoConstants) {
+                shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMinConstProperty, speedX.constantMin);
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
+            }
+        }
+        return {
+            modeMacro: modeMacro,
+            randomMacro: randomMacro
+        };
+    };
+    _proto._uploadSeparateAxisSpeeds = function _uploadSeparateAxisSpeeds(shaderData) {
+        var speedX = this._speedX;
+        var speedY = this._speedY;
+        var speedZ = this._speedZ;
+        var modeMacro = null;
+        var randomMacro = null;
+        var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves && speedY.mode === ParticleCurveMode.TwoCurves && speedZ.mode === ParticleCurveMode.TwoCurves;
+        if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve && speedY.mode === ParticleCurveMode.Curve && speedZ.mode === ParticleCurveMode.Curve) {
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMaxCurveProperty, speedX.curveMax._getTypeArray());
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMaxCurveProperty, speedY.curveMax._getTypeArray());
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMaxCurveProperty, speedZ.curveMax._getTypeArray());
+            modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
+            if (isRandomCurveMode) {
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMinCurveProperty, speedX.curveMin._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMinCurveProperty, speedY.curveMin._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMinCurveProperty, speedZ.curveMin._getTypeArray());
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
+            }
+        } else {
+            var constantMax = this._speedMaxConstantVec;
+            constantMax.set(speedX.constantMax, speedY.constantMax, speedZ.constantMax);
+            shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMaxConstVecProperty, constantMax);
+            modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
+            if (speedX.mode === ParticleCurveMode.TwoConstants && speedY.mode === ParticleCurveMode.TwoConstants && speedZ.mode === ParticleCurveMode.TwoConstants) {
+                var constantMin = this._speedMinConstantVec;
+                constantMin.set(speedX.constantMin, speedY.constantMin, speedZ.constantMin);
+                shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMinConstVecProperty, constantMin);
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
+            }
+        }
+        return {
+            modeMacro: modeMacro,
+            randomMacro: randomMacro
+        };
+    };
+    _proto._uploadDrag = function _uploadDrag(shaderData) {
+        var drag = this._drag;
+        var curveMacro = null;
+        var randomMacro = null;
+        var isRandomCurveMode = drag.mode === ParticleCurveMode.TwoCurves;
+        if (isRandomCurveMode || drag.mode === ParticleCurveMode.Curve) {
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._dragMaxCurveProperty, drag.curveMax._getTypeArray());
+            curveMacro = LimitVelocityOverLifetimeModule._dragCurveModeMacro;
+            if (isRandomCurveMode) {
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._dragMinCurveProperty, drag.curveMin._getTypeArray());
+                randomMacro = LimitVelocityOverLifetimeModule._dragIsRandomMacro;
+            }
+        } else {
+            var dragVec = this._dragConstantVec;
+            if (drag.mode === ParticleCurveMode.TwoConstants) {
+                dragVec.set(drag.constantMin, drag.constantMax);
+            } else {
+                dragVec.set(drag.constantMax, drag.constantMax);
+            }
+            shaderData.setVector2(LimitVelocityOverLifetimeModule._dragConstantProperty, dragVec);
+        }
+        return {
+            curveMacro: curveMacro,
+            randomMacro: randomMacro
+        };
+    };
+    _create_class(LimitVelocityOverLifetimeModule, [
+        {
+            key: "separateAxes",
+            get: /**
+   * Whether to limit velocity on each axis separately.
+   */ function get() {
+                return this._separateAxes;
+            },
+            set: function set(value) {
+                if (value !== this._separateAxes) {
+                    this._separateAxes = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "speed",
+            get: /**
+   * Speed limit when separateAxes is false.
+   */ function get() {
+                return this._speedX;
+            },
+            set: function set(value) {
+                this.speedX = value;
+            }
+        },
+        {
+            key: "speedX",
+            get: /**
+   * Speed limit for the x-axis (or overall limit when separateAxes is false).
+   */ function get() {
+                return this._speedX;
+            },
+            set: function set(value) {
+                var lastValue = this._speedX;
+                if (value !== lastValue) {
+                    this._speedX = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "speedY",
+            get: /**
+   * Speed limit for the y-axis.
+   */ function get() {
+                return this._speedY;
+            },
+            set: function set(value) {
+                var lastValue = this._speedY;
+                if (value !== lastValue) {
+                    this._speedY = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "speedZ",
+            get: /**
+   * Speed limit for the z-axis.
+   */ function get() {
+                return this._speedZ;
+            },
+            set: function set(value) {
+                var lastValue = this._speedZ;
+                if (value !== lastValue) {
+                    this._speedZ = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "dampen",
+            get: /**
+   * Controls how much the velocity is dampened when it exceeds the limit.
+   * @remarks Value is clamped to [0, 1]. 0 means no damping, 1 means full damping.
+   */ function get() {
+                return this._dampen;
+            },
+            set: function set(value) {
+                value = Math.max(0, Math.min(1, value));
+                if (value !== this._dampen) {
+                    this._dampen = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "drag",
+            get: /**
+   * Controls the amount of drag applied to particle velocities.
+   */ function get() {
+                return this._drag;
+            },
+            set: function set(value) {
+                var lastValue = this._drag;
+                if (value !== lastValue) {
+                    this._drag = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "multiplyDragByParticleSize",
+            get: /**
+   * Adjust the amount of drag based on particle sizes.
+   */ function get() {
+                return this._multiplyDragByParticleSize;
+            },
+            set: function set(value) {
+                if (value !== this._multiplyDragByParticleSize) {
+                    this._multiplyDragByParticleSize = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "multiplyDragByParticleVelocity",
+            get: /**
+   * Adjust the amount of drag based on particle speeds.
+   */ function get() {
+                return this._multiplyDragByParticleVelocity;
+            },
+            set: function set(value) {
+                if (value !== this._multiplyDragByParticleVelocity) {
+                    this._multiplyDragByParticleVelocity = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "space",
+            get: /**
+   * Specifies if the velocity limits are in local space or world space.
+   * @remarks Only takes effect when 'separateAxes' is enabled.
+   */ function get() {
+                return this._space;
+            },
+            set: function set(value) {
+                if (value !== this._space) {
+                    this._space = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "enabled",
+            get: /**
+   * Specifies whether the module is enabled.
+   * @remarks This module requires WebGL2, On WebGL1, enabling will be silently ignored.
+   */ function get() {
+                return this._enabled;
+            },
+            set: function set(value) {
+                if (value !== this._enabled) {
+                    if (value && !this._generator._renderer.engine._hardwareRenderer.isWebGL2) {
+                        return;
+                    }
+                    this._enabled = value;
+                    this._generator._setTransformFeedback(value);
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        }
+    ]);
+    return LimitVelocityOverLifetimeModule;
+}(ParticleGeneratorModule);
+LimitVelocityOverLifetimeModule._enabledMacro = ShaderMacro.getByName("RENDERER_LVL_MODULE_ENABLED");
+LimitVelocityOverLifetimeModule._separateAxesMacro = ShaderMacro.getByName("RENDERER_LVL_SEPARATE_AXES");
+LimitVelocityOverLifetimeModule._speedConstantModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CONSTANT_MODE");
+LimitVelocityOverLifetimeModule._speedCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CURVE_MODE");
+LimitVelocityOverLifetimeModule._speedIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_IS_RANDOM_TWO");
+LimitVelocityOverLifetimeModule._dragCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_CURVE_MODE");
+LimitVelocityOverLifetimeModule._dragIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_IS_RANDOM_TWO");
+LimitVelocityOverLifetimeModule._multiplyDragBySizeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_SIZE");
+LimitVelocityOverLifetimeModule._multiplyDragByVelocityMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_VELOCITY");
+LimitVelocityOverLifetimeModule._speedMaxConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConst");
+LimitVelocityOverLifetimeModule._speedMinConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConst");
+LimitVelocityOverLifetimeModule._speedMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxCurve");
+LimitVelocityOverLifetimeModule._speedMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMinCurve");
+LimitVelocityOverLifetimeModule._speedMaxConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConstVector");
+LimitVelocityOverLifetimeModule._speedMinConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConstVector");
+LimitVelocityOverLifetimeModule._speedXMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMaxCurve");
+LimitVelocityOverLifetimeModule._speedXMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMinCurve");
+LimitVelocityOverLifetimeModule._speedYMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMaxCurve");
+LimitVelocityOverLifetimeModule._speedYMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMinCurve");
+LimitVelocityOverLifetimeModule._speedZMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMaxCurve");
+LimitVelocityOverLifetimeModule._speedZMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMinCurve");
+LimitVelocityOverLifetimeModule._dampenProperty = ShaderProperty.getByName("renderer_LVLDampen");
+LimitVelocityOverLifetimeModule._dragConstantProperty = ShaderProperty.getByName("renderer_LVLDragConstant");
+LimitVelocityOverLifetimeModule._dragMaxCurveProperty = ShaderProperty.getByName("renderer_LVLDragMaxCurve");
+LimitVelocityOverLifetimeModule._dragMinCurveProperty = ShaderProperty.getByName("renderer_LVLDragMinCurve");
+LimitVelocityOverLifetimeModule._spaceProperty = ShaderProperty.getByName("renderer_LVLSpace");
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedRand", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedMinConstantVec", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedMaxConstantVec", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_dragConstantVec", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_enabledModuleMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_separateAxesCachedMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedModeMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedRandomMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_dragCurveCachedMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_dragRandomCachedMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_dragSizeMacro", void 0);
+__decorate([
+    ignoreClone
+], LimitVelocityOverLifetimeModule.prototype, "_dragVelocityMacro", void 0);
+__decorate([
+    deepClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedX", void 0);
+__decorate([
+    deepClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedY", void 0);
+__decorate([
+    deepClone
+], LimitVelocityOverLifetimeModule.prototype, "_speedZ", void 0);
+__decorate([
+    deepClone
+], LimitVelocityOverLifetimeModule.prototype, "_drag", void 0);
+
 /**
  * Control how Particle Generator apply transform scale.
  */ var ParticleScaleMode = /*#__PURE__*/ function(ParticleScaleMode) {
@@ -35571,6 +36421,8 @@ __decorate([
         /** @internal */ this._firstRetiredElement = 0;
         /** @internal */ this._vertexBufferBindings = new Array();
         /** @internal */ this._subPrimitive = new SubMesh(0, 0, MeshTopology.Triangles);
+        /** @internal */ this._useTransformFeedback = false;
+        /** @internal */ this._feedbackBindingIndex = -1;
         this._isPlaying = false;
         this._instanceBufferResized = false;
         this._waitProcessRetiredElementCount = 0;
@@ -35589,6 +36441,7 @@ __decorate([
         this.velocityOverLifetime = new VelocityOverLifetimeModule(this);
         this.forceOverLifetime = new ForceOverLifetimeModule(this);
         this.sizeOverLifetime = new SizeOverLifetimeModule(this);
+        this.limitVelocityOverLifetime = new LimitVelocityOverLifetimeModule(this);
         this.emission.enabled = true;
     }
     var _proto = ParticleGenerator.prototype;
@@ -35627,11 +36480,7 @@ __decorate([
         } else {
             this._isPlaying = false;
             if (stopMode === ParticleStopMode.StopEmittingAndClear) {
-                // Move the pointer to free immediately
-                var firstFreeElement = this._firstFreeElement;
-                this._firstRetiredElement = firstFreeElement;
-                this._firstActiveElement = firstFreeElement;
-                this._firstNewElement = firstFreeElement;
+                this._clearActiveParticles();
                 this._playTime = 0;
                 this._firstActiveTransformedBoundingBox = this._firstFreeTransformedBoundingBox;
                 this.emission._reset();
@@ -35715,6 +36564,16 @@ __decorate([
                 this._isPlaying = false;
             }
         }
+        // Retire all particles on device restore before bounds/volume bookkeeping
+        var isContentLost = this._instanceVertexBufferBinding._buffer.isContentLost;
+        if (isContentLost) {
+            this._firstActiveElement = 0;
+            this._firstNewElement = 0;
+            this._firstFreeElement = 0;
+            this._firstRetiredElement = 0;
+            this._waitProcessRetiredElementCount = 0;
+            this._firstActiveTransformedBoundingBox = this._firstFreeTransformedBoundingBox;
+        }
         if (this.isAlive) {
             if (main.simulationSpace === ParticleSimulationSpace.World) {
                 this._generateTransformedBounds();
@@ -35728,16 +36587,21 @@ __decorate([
         if (this.isAlive !== lastAlive) {
             this._renderer._onWorldVolumeChanged();
         }
-        // Add new particles to vertex buffer when has wait process retired element or new particle
-        //
-        // Another choice is just add new particles to vertex buffer and render all particles ignore the retired particle in shader, especially billboards
-        // But webgl don't support map buffer range, so this choice don't have performance advantage even less set data to GPU
-        if (this._firstNewElement != this._firstFreeElement || this._waitProcessRetiredElementCount > 0 || this._instanceBufferResized || this._instanceVertexBufferBinding._buffer.isContentLost) {
+        if (this._firstNewElement != this._firstFreeElement || this._waitProcessRetiredElementCount > 0 || this._instanceBufferResized) {
             this._addActiveParticlesToVertexBuffer();
         }
     };
     /**
    * @internal
+   * Run Transform Feedback simulation pass.
+   */ _proto._updateFeedback = function _updateFeedback(shaderData, deltaTime) {
+        this._feedbackSimulator.update(shaderData, this._currentParticleCount, this._firstActiveElement, this._firstFreeElement, deltaTime);
+        // After swap, update the render pass buffer binding to point to the latest output.
+        // VAO is disabled in TF mode so direct assignment is safe (no stale VAO issue).
+        this._primitive.vertexBufferBindings[this._feedbackBindingIndex] = this._feedbackSimulator.readBinding;
+    };
+    /**
+   * @internal
    */ _proto._reorganizeGeometryBuffers = function _reorganizeGeometryBuffers() {
         var _this = this, renderer = _this._renderer, primitive = _this._primitive, vertexBufferBindings = _this._vertexBufferBindings;
         var _renderer_engine = renderer.engine, particleUtils = _renderer_engine._particleBufferUtils;
@@ -35789,6 +36653,15 @@ __decorate([
         if (this._instanceVertexBufferBinding) {
             vertexBufferBindings.push(this._instanceVertexBufferBinding);
         }
+        // Add feedback buffer binding for render pass
+        if (this._useTransformFeedback) {
+            this._feedbackBindingIndex = vertexBufferBindings.length;
+            primitive.addVertexElement(new VertexElement(ParticleFeedbackVertexAttribute.Position, 0, VertexElementFormat.Vector3, this._feedbackBindingIndex, 1));
+            primitive.addVertexElement(new VertexElement(ParticleFeedbackVertexAttribute.Velocity, 12, VertexElementFormat.Vector3, this._feedbackBindingIndex, 1));
+            vertexBufferBindings.push(this._feedbackSimulator.readBinding);
+        } else {
+            this._feedbackBindingIndex = -1;
+        }
         primitive.setVertexBufferBindings(vertexBufferBindings);
     };
     /**
@@ -35804,18 +36677,28 @@ __decorate([
         vertexInstanceBuffer.isGCIgnored = true;
         var vertexBufferBindings = this._primitive.vertexBufferBindings;
         var vertexBufferBinding = new VertexBufferBinding(vertexInstanceBuffer, stride);
-        var instanceVertices = new Float32Array(newByteLength / 4);
         var lastInstanceVertices = this._instanceVertices;
+        var useFeedback = this._useTransformFeedback;
+        var instanceVertices = new Float32Array(newByteLength / 4);
+        if (useFeedback) {
+            this._feedbackSimulator.resize(newParticleCount, vertexBufferBinding);
+        }
         if (lastInstanceVertices) {
-            var floatStride = ParticleBufferUtils.instanceVertexFloatStride;
+            var floatStride = ParticleBufferUtils.instanceVertexFloatStride, feedbackVertexStride = ParticleBufferUtils.feedbackVertexStride;
             var firstFreeElement = this._firstFreeElement;
             var firstRetiredElement = this._firstRetiredElement;
             if (isIncrease) {
+                // Copy front segment [0, firstFreeElement)
                 instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, 0, firstFreeElement * floatStride));
+                // Copy tail segment shifted by increaseCount
                 var nextFreeElement = firstFreeElement + 1;
-                var freeEndOffset = (nextFreeElement + increaseCount) * floatStride;
-                instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, nextFreeElement * floatStride * 4), freeEndOffset);
-                // Maintain expanded pointers
+                var tailCount = this._currentParticleCount - nextFreeElement;
+                var tailDstElement = nextFreeElement + increaseCount;
+                instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, nextFreeElement * floatStride * 4), tailDstElement * floatStride);
+                if (useFeedback) {
+                    this._feedbackSimulator.copyOldBufferData(0, 0, firstFreeElement * feedbackVertexStride);
+                    this._feedbackSimulator.copyOldBufferData(nextFreeElement * feedbackVertexStride, tailDstElement * feedbackVertexStride, tailCount * feedbackVertexStride);
+                }
                 this._firstNewElement > firstFreeElement && (this._firstNewElement += increaseCount);
                 this._firstActiveElement > firstFreeElement && (this._firstActiveElement += increaseCount);
                 firstRetiredElement > firstFreeElement && (this._firstRetiredElement += increaseCount);
@@ -35824,7 +36707,6 @@ __decorate([
                 if (firstRetiredElement <= firstFreeElement) {
                     migrateCount = firstFreeElement - firstRetiredElement;
                     bufferOffset = 0;
-                    // Maintain expanded pointers
                     this._firstFreeElement -= firstRetiredElement;
                     this._firstNewElement -= firstRetiredElement;
                     this._firstActiveElement -= firstRetiredElement;
@@ -35832,20 +36714,29 @@ __decorate([
                 } else {
                     migrateCount = this._currentParticleCount - firstRetiredElement;
                     bufferOffset = firstFreeElement;
-                    // Maintain expanded pointers
                     this._firstNewElement > firstFreeElement && (this._firstNewElement -= firstFreeElement);
                     this._firstActiveElement > firstFreeElement && (this._firstActiveElement -= firstFreeElement);
                     firstRetiredElement > firstFreeElement && (this._firstRetiredElement -= firstFreeElement);
                 }
                 instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, firstRetiredElement * floatStride * 4, migrateCount * floatStride), bufferOffset * floatStride);
+                if (useFeedback) {
+                    this._feedbackSimulator.copyOldBufferData(firstRetiredElement * feedbackVertexStride, bufferOffset * feedbackVertexStride, migrateCount * feedbackVertexStride);
+                }
+            }
+            if (useFeedback) {
+                this._feedbackSimulator.destroyOldBuffers();
             }
             this._instanceBufferResized = true;
         }
-        // Instance buffer always at last
-        this._primitive.setVertexBufferBinding(lastInstanceVertices ? vertexBufferBindings.length - 1 : vertexBufferBindings.length, vertexBufferBinding);
+        // Update instance buffer binding
+        var instanceBindingIndex = lastInstanceVertices ? vertexBufferBindings.length - 1 - (useFeedback ? 1 : 0) : vertexBufferBindings.length;
+        this._primitive.setVertexBufferBinding(instanceBindingIndex, vertexBufferBinding);
         this._instanceVertices = instanceVertices;
         this._instanceVertexBufferBinding = vertexBufferBinding;
         this._currentParticleCount = newParticleCount;
+        if (useFeedback) {
+            this._primitive.setVertexBufferBinding(this._feedbackBindingIndex, this._feedbackSimulator.readBinding);
+        }
     };
     /**
    * @internal
@@ -35853,6 +36744,7 @@ __decorate([
         this.main._updateShaderData(shaderData);
         this.velocityOverLifetime._updateShaderData(shaderData);
         this.forceOverLifetime._updateShaderData(shaderData);
+        this.limitVelocityOverLifetime._updateShaderData(shaderData);
         this.textureSheetAnimation._updateShaderData(shaderData);
         this.sizeOverLifetime._updateShaderData(shaderData);
         this.rotationOverLifetime._updateShaderData(shaderData);
@@ -35867,11 +36759,41 @@ __decorate([
         this.textureSheetAnimation._resetRandomSeed(seed);
         this.velocityOverLifetime._resetRandomSeed(seed);
         this.forceOverLifetime._resetRandomSeed(seed);
+        this.limitVelocityOverLifetime._resetRandomSeed(seed);
         this.rotationOverLifetime._resetRandomSeed(seed);
         this.colorOverLifetime._resetRandomSeed(seed);
     };
     /**
    * @internal
+   */ _proto._setTransformFeedback = function _setTransformFeedback(enabled) {
+        this._useTransformFeedback = enabled;
+        // Switching TF mode invalidates all active particle state: feedback buffers and instance
+        // buffer layout are incompatible between the two paths. Clear rather than show a one-frame
+        // jump; new particles will fill in naturally from the next emit cycle.
+        this._clearActiveParticles();
+        if (enabled) {
+            if (!this._feedbackSimulator) {
+                this._feedbackSimulator = new ParticleTransformFeedbackSimulator(this._renderer.engine);
+            }
+            var simulator = this._feedbackSimulator;
+            var readBinding = simulator.readBinding;
+            if (!readBinding || readBinding.buffer.byteLength !== this._currentParticleCount * ParticleBufferUtils.feedbackVertexStride) {
+                simulator.resize(this._currentParticleCount, this._instanceVertexBufferBinding);
+                simulator.destroyOldBuffers();
+            } else {
+                simulator._instanceBinding = this._instanceVertexBufferBinding;
+            }
+            this._renderer.shaderData.enableMacro(ParticleGenerator._transformFeedbackMacro);
+            // Feedback buffer swaps every frame; VAO caching would bake stale buffer handles.
+            this._primitive.enableVAO = false;
+        } else {
+            this._renderer.shaderData.disableMacro(ParticleGenerator._transformFeedbackMacro);
+            this._primitive.enableVAO = true;
+        }
+        this._reorganizeGeometryBuffers();
+    };
+    /**
+   * @internal
    */ _proto._getAliveParticleCount = function _getAliveParticleCount() {
         if (this._firstActiveElement <= this._firstFreeElement) {
             return this._firstFreeElement - this._firstActiveElement;
@@ -35898,10 +36820,19 @@ __decorate([
     };
     /**
    * @internal
+   */ _proto._cloneTo = function _cloneTo(target) {
+        if (target.limitVelocityOverLifetime.enabled) {
+            target._setTransformFeedback(true);
+        }
+    };
+    /**
+   * @internal
    */ _proto._destroy = function _destroy() {
+        var _this__feedbackSimulator;
         this._instanceVertexBufferBinding.buffer.destroy();
         this._primitive.destroy();
         this.emission._destroy();
+        (_this__feedbackSimulator = this._feedbackSimulator) == null ? void 0 : _this__feedbackSimulator.destroy();
     };
     /**
    * @internal
@@ -36133,8 +37064,34 @@ __decorate([
             instanceVertices[offset + 39] = rand1.random();
             instanceVertices[offset + 40] = rand1.random();
         }
+        var limitVelocityOverLifetime = this.limitVelocityOverLifetime;
+        if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isSpeedRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
+            instanceVertices[offset + 41] = limitVelocityOverLifetime._speedRand.random();
+        }
+        // Initialize feedback buffer for this particle
+        if (this._useTransformFeedback) {
+            this._addFeedbackParticle(firstFreeElement, position, direction, startSpeed, transform);
+        }
         this._firstFreeElement = nextFreeElement;
     };
+    _proto._addFeedbackParticle = function _addFeedbackParticle(index, shapePosition, direction, startSpeed, transform) {
+        var position;
+        if (this.main.simulationSpace === ParticleSimulationSpace.Local) {
+            position = shapePosition;
+        } else {
+            position = ParticleGenerator._tempVector32;
+            engineMath.Vector3.transformByQuat(shapePosition, transform.worldRotationQuaternion, position);
+            position.add(transform.worldPosition);
+        }
+        this._feedbackSimulator.writeParticleData(index, position, direction.x * startSpeed, direction.y * startSpeed, direction.z * startSpeed);
+    };
+    _proto._clearActiveParticles = function _clearActiveParticles() {
+        var firstFreeElement = this._firstFreeElement;
+        this._firstRetiredElement = firstFreeElement;
+        this._firstActiveElement = firstFreeElement;
+        this._firstNewElement = firstFreeElement;
+        this._firstActiveTransformedBoundingBox = this._firstFreeTransformedBoundingBox;
+    };
     _proto._retireActiveParticles = function _retireActiveParticles() {
         var engine = this._renderer.engine;
         var frameCount = engine.time.frameCount;
@@ -36178,16 +37135,19 @@ __decorate([
             return;
         }
         var byteStride = ParticleBufferUtils.instanceVertexStride;
-        var start = firstActiveElement * byteStride;
         var instanceBuffer = this._instanceVertexBufferBinding.buffer;
         var dataBuffer = this._instanceVertices.buffer;
+        // Feedback mode: upload in-place (indices match feedback buffer slots)
+        // Non-feedback mode: compact to GPU offset 0
+        var compact = !this._useTransformFeedback;
+        var start = firstActiveElement * byteStride;
         if (firstActiveElement < firstFreeElement) {
-            instanceBuffer.setData(dataBuffer, 0, start, (firstFreeElement - firstActiveElement) * byteStride, SetDataOptions.Discard);
+            instanceBuffer.setData(dataBuffer, compact ? 0 : start, start, (firstFreeElement - firstActiveElement) * byteStride, SetDataOptions.Discard);
         } else {
-            var firstSegmentCount = (this._currentParticleCount - firstActiveElement) * byteStride;
-            instanceBuffer.setData(dataBuffer, 0, start, firstSegmentCount, SetDataOptions.Discard);
+            var firstSegmentSize = (this._currentParticleCount - firstActiveElement) * byteStride;
+            instanceBuffer.setData(dataBuffer, compact ? 0 : start, start, firstSegmentSize, SetDataOptions.Discard);
             if (firstFreeElement > 0) {
-                instanceBuffer.setData(dataBuffer, firstSegmentCount, 0, firstFreeElement * byteStride);
+                instanceBuffer.setData(dataBuffer, compact ? firstSegmentSize : 0, 0, firstFreeElement * byteStride);
             }
         }
         this._firstNewElement = firstFreeElement;
@@ -36405,11 +37365,13 @@ ParticleGenerator._tempVector21 = new engineMath.Vector2();
 ParticleGenerator._tempVector22 = new engineMath.Vector2();
 ParticleGenerator._tempVector30 = new engineMath.Vector3();
 ParticleGenerator._tempVector31 = new engineMath.Vector3();
+ParticleGenerator._tempVector32 = new engineMath.Vector3();
 ParticleGenerator._tempMat = new engineMath.Matrix();
 ParticleGenerator._tempColor0 = new engineMath.Color();
 ParticleGenerator._tempParticleRenderers = new Array();
 ParticleGenerator._particleIncreaseCount = 128;
 ParticleGenerator._transformedBoundsIncreaseCount = 16;
+ParticleGenerator._transformFeedbackMacro = ShaderMacro.getByName("RENDERER_TRANSFORM_FEEDBACK");
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "main", void 0);
@@ -36422,6 +37384,9 @@ __decorate([
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "forceOverLifetime", void 0);
+__decorate([
+    deepClone
+], ParticleGenerator.prototype, "limitVelocityOverLifetime", void 0);
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "sizeOverLifetime", void 0);
@@ -36458,6 +37423,15 @@ __decorate([
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_subPrimitive", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_feedbackSimulator", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_useTransformFeedback", void 0);
+__decorate([
+    ignoreClone
+], ParticleGenerator.prototype, "_feedbackBindingIndex", void 0);
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_isPlaying", void 0);
@@ -38615,6 +39589,7 @@ exports.Keys = Keys;
 exports.Layer = Layer;
 exports.LayerPathMask = LayerPathMask;
 exports.Light = Light;
+exports.LimitVelocityOverLifetimeModule = LimitVelocityOverLifetimeModule;
 exports.Loader = Loader;
 exports.Logger = Logger;
 exports.MSAASamples = MSAASamples;