@galacean/engine 2.0.0-alpha.15 → 2.0.0-alpha.17

package/dist/browser.js

@@ -5324,74 +5324,69 @@
             return cloneModes;
         };
         CloneManager.cloneProperty = function cloneProperty(source, target, k, cloneMode, srcRoot, targetRoot, deepInstanceMap) {
-            if (cloneMode === CloneMode.Ignore) {
+            var sourceProperty = source[k];
+            // Remappable references (Entity/Component) are always remapped, regardless of clone decorator
+            if (_instanceof1$2(sourceProperty, Object) && sourceProperty._remap) {
+                target[k] = sourceProperty._remap(srcRoot, targetRoot);
                 return;
             }
-            var sourceProperty = source[k];
-            if (_instanceof1$2(sourceProperty, Object)) {
-                if (cloneMode === undefined || cloneMode === CloneMode.Assignment) {
-                    target[k] = sourceProperty;
-                    return;
-                }
-                var type = sourceProperty.constructor;
-                switch(type){
-                    case Uint8Array:
-                    case Uint16Array:
-                    case Uint32Array:
-                    case Int8Array:
-                    case Int16Array:
-                    case Int32Array:
-                    case Float32Array:
-                    case Float64Array:
-                        var targetPropertyT = target[k];
-                        if (targetPropertyT == null || targetPropertyT.length !== sourceProperty.length) {
-                            target[k] = sourceProperty.slice();
-                        } else {
-                            targetPropertyT.set(sourceProperty);
-                        }
-                        break;
-                    case Array:
-                        var targetPropertyA = target[k];
-                        var length = sourceProperty.length;
-                        if (targetPropertyA == null) {
-                            target[k] = targetPropertyA = new Array(length);
-                        } else {
-                            targetPropertyA.length = length;
-                        }
-                        for(var i = 0; i < length; i++){
-                            CloneManager.cloneProperty(sourceProperty, targetPropertyA, i, cloneMode, srcRoot, targetRoot, deepInstanceMap);
-                        }
-                        break;
-                    default:
-                        var targetProperty = target[k];
-                        // If the target property is undefined, create new instance and keep reference sharing like the source
+            if (cloneMode === CloneMode.Ignore) return;
+            // Primitives, undecorated, or @assignmentClone: direct assign
+            if (!_instanceof1$2(sourceProperty, Object) || cloneMode === undefined || cloneMode === CloneMode.Assignment) {
+                target[k] = sourceProperty;
+                return;
+            }
+            // @shallowClone / @deepClone: deep copy complex objects
+            var type = sourceProperty.constructor;
+            switch(type){
+                case Uint8Array:
+                case Uint16Array:
+                case Uint32Array:
+                case Int8Array:
+                case Int16Array:
+                case Int32Array:
+                case Float32Array:
+                case Float64Array:
+                    var targetPropertyT = target[k];
+                    if (targetPropertyT == null || targetPropertyT.length !== sourceProperty.length) {
+                        target[k] = sourceProperty.slice();
+                    } else {
+                        targetPropertyT.set(sourceProperty);
+                    }
+                    break;
+                case Array:
+                    var targetPropertyA = target[k];
+                    var length = sourceProperty.length;
+                    if (targetPropertyA == null) {
+                        target[k] = targetPropertyA = new Array(length);
+                    } else {
+                        targetPropertyA.length = length;
+                    }
+                    for(var i = 0; i < length; i++){
+                        CloneManager.cloneProperty(sourceProperty, targetPropertyA, i, cloneMode, srcRoot, targetRoot, deepInstanceMap);
+                    }
+                    break;
+                default:
+                    var targetProperty = target[k];
+                    // If the target property is undefined, create new instance and keep reference sharing like the source
+                    if (!targetProperty) {
+                        targetProperty = deepInstanceMap.get(sourceProperty);
                         if (!targetProperty) {
-                            targetProperty = deepInstanceMap.get(sourceProperty);
-                            if (!targetProperty) {
-                                targetProperty = new sourceProperty.constructor();
-                                deepInstanceMap.set(sourceProperty, targetProperty);
-                            }
-                            target[k] = targetProperty;
+                            targetProperty = new sourceProperty.constructor();
+                            deepInstanceMap.set(sourceProperty, targetProperty);
                         }
-                        if (sourceProperty.copyFrom) {
-                            // Custom clone
-                            targetProperty.copyFrom(sourceProperty);
-                        } else {
-                            // Universal clone
-                            var cloneModes = CloneManager.getCloneMode(sourceProperty.constructor);
-                            for(var _$k in sourceProperty){
-                                CloneManager.cloneProperty(sourceProperty, targetProperty, _$k, cloneModes[_$k], srcRoot, targetRoot, deepInstanceMap);
-                            }
-                            // Custom incremental clone
-                            if (sourceProperty._cloneTo) {
-                                sourceProperty._cloneTo(targetProperty, srcRoot, targetRoot);
-                            }
+                        target[k] = targetProperty;
+                    }
+                    if (sourceProperty.copyFrom) {
+                        targetProperty.copyFrom(sourceProperty);
+                    } else {
+                        var cloneModes = CloneManager.getCloneMode(sourceProperty.constructor);
+                        for(var _$k in sourceProperty){
+                            CloneManager.cloneProperty(sourceProperty, targetProperty, _$k, cloneModes[_$k], srcRoot, targetRoot, deepInstanceMap);
                         }
-                        break;
-                }
-            } else {
-                // null, undefined, primitive type, function
-                target[k] = sourceProperty;
+                        sourceProperty._cloneTo == null ? void 0 : sourceProperty._cloneTo.call(sourceProperty, targetProperty, srcRoot, targetRoot);
+                    }
+                    break;
             }
         };
         CloneManager.deepCloneObject = function deepCloneObject(source, target, deepInstanceMap) {
@@ -9885,13 +9880,15 @@
         ShadowVertexDeclaration: ShadowVertexDeclaration,
         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
     var rotation_over_lifetime_module = "#if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n    #ifdef RENDERER_ROL_CURVE_MODE\n        uniform vec2 renderer_ROLMaxCurveZ[4];\n        #ifdef RENDERER_ROL_IS_SEPARATE\n            uniform vec2 renderer_ROLMaxCurveX[4];\n            uniform vec2 renderer_ROLMaxCurveY[4];\n        #endif\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec2 renderer_ROLMinCurveZ[4];\n            #ifdef RENDERER_ROL_IS_SEPARATE\n                uniform vec2 renderer_ROLMinCurveX[4];\n                uniform vec2 renderer_ROLMinCurveY[4];\n            #endif\n        #endif\n    #else\n        uniform vec3 renderer_ROLMaxConst;\n        #ifdef RENDERER_ROL_IS_RANDOM_TWO\n            uniform vec3 renderer_ROLMinConst;\n        #endif\n    #endif\n#endif\n\nfloat computeParticleRotationFloat(in float rotation, in float age, in float normalizedAge) {\n    #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #else\n            float lifeRotation = renderer_ROLMaxConst.z;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(renderer_ROLMinConst.z, lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * age;\n        #endif\n    #endif\n    return rotation;\n}\n\n\n#if defined(RENDERER_MODE_MESH) && (defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE))\nvec3 computeParticleRotationVec3(in vec3 rotation, in float age, in float normalizedAge) {\n    #ifdef RENDERER_ROL_IS_SEPARATE\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                vec3 ageRot = mix(renderer_ROLMinConst, renderer_ROLMaxConst, a_Random0.w) * age;\n            #else\n                vec3 ageRot = renderer_ROLMaxConst * age;\n            #endif\n            rotation += ageRot;\n        #endif\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifetime = a_ShapePositionStartLifeTime.w;\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                rotation += vec3(\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveX, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveY, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue), a_Random0.w),\n                    mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue),\n                        evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue), a_Random0.w)) * lifetime;\n            #else\n                rotation += vec3(\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveX, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveY, normalizedAge, currentValue),\n                    evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue)) * lifetime;\n            #endif\n        #endif\n    #else\n        #ifdef RENDERER_ROL_CONSTANT_MODE\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                float ageRot = mix(renderer_ROLMinConst.z, renderer_ROLMaxConst.z, a_Random0.w) * age;\n            #else\n                float ageRot = renderer_ROLMaxConst.z * age;\n            #endif\n            rotation += ageRot;\n        #endif\n\n        #ifdef RENDERER_ROL_CURVE_MODE\n            float currentValue;\n            float lifeRotation = evaluateParticleCurveCumulative(renderer_ROLMaxCurveZ, normalizedAge, currentValue);\n            #ifdef RENDERER_ROL_IS_RANDOM_TWO\n                lifeRotation = mix(evaluateParticleCurveCumulative(renderer_ROLMinCurveZ, normalizedAge, currentValue), lifeRotation, a_Random0.w);\n            #endif\n            rotation += lifeRotation * a_ShapePositionStartLifeTime.w;\n        #endif\n    #endif\n    return rotation;\n}\n#endif\n"; // eslint-disable-line
     var size_over_lifetime_module = "#ifdef RENDERER_SOL_CURVE_MODE\n    uniform vec2 renderer_SOLMaxCurveX[4]; // x:time y:value\n    #ifdef RENDERER_SOL_IS_SEPARATE\n        uniform vec2 renderer_SOLMaxCurveY[4]; // x:time y:value\n        uniform vec2 renderer_SOLMaxCurveZ[4]; // x:time y:value\n    #endif\n\n    #ifdef RENDERER_SOL_IS_RANDOM_TWO\n        uniform vec2 renderer_SOLMinCurveX[4]; // x:time y:value\n        #ifdef RENDERER_SOL_IS_SEPARATE\n            uniform vec2 renderer_SOLMinCurveY[4]; // x:time y:value\n            uniform vec2 renderer_SOLMinCurveZ[4]; // x:time y:value\n        #endif\n    #endif\n#endif\n\nvec2 computeParticleSizeBillboard(in vec2 size, in float normalizedAge) {\n    #ifdef RENDERER_SOL_CURVE_MODE\n        float lifeSizeX = evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge);\n        #ifdef RENDERER_SOL_IS_RANDOM_TWO\n            lifeSizeX = mix(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge), lifeSizeX, a_Random0.z);\n        #endif\n\n        #ifdef RENDERER_SOL_IS_SEPARATE\n            float lifeSizeY = evaluateParticleCurve(renderer_SOLMaxCurveY, normalizedAge);\n            #ifdef RENDERER_SOL_IS_RANDOM_TWO\n                lifeSizeY = mix(evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge), lifeSizeY, a_Random0.z);\n            #endif\n            size *= vec2(lifeSizeX, lifeSizeY);\n        #else\n            size *= lifeSizeX;\n        #endif\n    #endif\n    return size;\n}\n\n#ifdef RENDERER_MODE_MESH\n    vec3 computeParticleSizeMesh(in vec3 size, in float normalizedAge) {\n        #ifdef RENDERER_SOL_CURVE\n            size *= evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge);\n        #endif\n        #ifdef RENDERER_SOL_RANDOM_CURVES\n            size *= mix(evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge),\n            evaluateParticleCurve(u_SOLSizeGradientMax, normalizedAge),\n            a_Random0.z);\n        #endif\n        #ifdef RENDERER_SOL_CURVE_SEPARATE\n            size *= vec3(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge),\n            evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge),\n            evaluateParticleCurve(renderer_SOLMinCurveZ, normalizedAge));\n        #endif\n        #ifdef RENDERER_SOL_RANDOM_CURVES_SEPARATE\n            size *= vec3(mix(evaluateParticleCurve(renderer_SOLMinCurveX, normalizedAge),\n                    evaluateParticleCurve(renderer_SOLMaxCurveX, normalizedAge),\n                    a_Random0.z),\n            mix(evaluateParticleCurve(renderer_SOLMinCurveY, normalizedAge),\n                evaluateParticleCurve(renderer_SOLMaxCurveY, normalizedAge),\n                a_Random0.z),\n            mix(evaluateParticleCurve(renderer_SOLMinCurveZ, normalizedAge),\n                evaluateParticleCurve(renderer_SOLMaxCurveZ, normalizedAge),\n                a_Random0.z));\n        #endif\n        return size;\n    }\n#endif"; // eslint-disable-line
     var color_over_lifetime_module = "#if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n    uniform vec4 renderer_COLMaxGradientColor[4]; // x:time y:r z:g w:b\n    uniform vec2 renderer_COLMaxGradientAlpha[4]; // x:time y:alpha\n\n    #ifdef RENDERER_COL_RANDOM_GRADIENTS\n        uniform vec4 renderer_COLMinGradientColor[4]; // x:time y:r z:g w:b\n        uniform vec2 renderer_COLMinGradientAlpha[4]; // x:time y:alpha\n    #endif\n\n    uniform vec4 renderer_COLGradientKeysMaxTime; // x: minColorKeysMaxTime, y: minAlphaKeysMaxTime, z: maxColorKeysMaxTime, w: maxAlphaKeysMaxTime\n#endif\n\n\nvec4 computeParticleColor(in vec4 color, in float normalizedAge) {\n    #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n       vec4 gradientColor = evaluateParticleGradient(renderer_COLMaxGradientColor, renderer_COLGradientKeysMaxTime.z, renderer_COLMaxGradientAlpha, renderer_COLGradientKeysMaxTime.w, normalizedAge);\n    #endif\n\n    #ifdef RENDERER_COL_RANDOM_GRADIENTS\n        gradientColor = mix(evaluateParticleGradient(renderer_COLMinGradientColor,renderer_COLGradientKeysMaxTime.x, renderer_COLMinGradientAlpha, renderer_COLGradientKeysMaxTime.y, normalizedAge), gradientColor, a_Random0.y);\n    #endif\n\n    #if defined(RENDERER_COL_GRADIENT) || defined(RENDERER_COL_RANDOM_GRADIENTS)\n       color *= gradientColor;\n    #endif\n\n    return color;\n}\n"; // eslint-disable-line
     var texture_sheet_animation_module = "#if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n    uniform float renderer_TSACycles;\n    uniform vec3 renderer_TSATillingParams; // x:subU y:subV z:tileCount\n    uniform vec2 renderer_TSAFrameMaxCurve[4]; // x:time y:value\n\n    #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n        uniform vec2 renderer_TSAFrameMinCurve[4]; // x:time y:value\n    #endif\n#endif\n\nvec2 computeParticleUV(in vec2 uv, in float normalizedAge) {\n    #if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n        float scaledNormalizedAge = normalizedAge * renderer_TSACycles;\n        float cycleNormalizedAge = scaledNormalizedAge - floor(scaledNormalizedAge);\n        float normalizedFrame = evaluateParticleCurve(renderer_TSAFrameMaxCurve, cycleNormalizedAge);\n        #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n            normalizedFrame = mix(evaluateParticleCurve(renderer_TSAFrameMinCurve, cycleNormalizedAge), normalizedFrame, a_Random1.x);\n        #endif\n\n        float frame = floor(normalizedFrame * renderer_TSATillingParams.z);\n\n        float tileRow = frame * renderer_TSATillingParams.x;\n        float tileRowIndex = floor(tileRow);\n        uv.x += tileRow - tileRowIndex;\n        uv.y += tileRowIndex * renderer_TSATillingParams.y;\n    #endif\n    \n    return uv;\n}\n"; // eslint-disable-line
-    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_LIMIT_CONSTANT_MODE\n            uniform float renderer_LVLLimitMaxConst;\n            #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                uniform float renderer_LVLLimitMinConst;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_LIMIT_CURVE_MODE\n            uniform vec2 renderer_LVLLimitMaxCurve[4];\n            #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLLimitMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Per-axis limit\n    #ifdef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_LIMIT_CONSTANT_MODE\n            uniform vec3 renderer_LVLLimitMaxConstVector;\n            #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                uniform vec3 renderer_LVLLimitMinConstVector;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_LIMIT_CURVE_MODE\n            uniform vec2 renderer_LVLLimitXMaxCurve[4];\n            uniform vec2 renderer_LVLLimitYMaxCurve[4];\n            uniform vec2 renderer_LVLLimitZMaxCurve[4];\n            #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLLimitXMinCurve[4];\n                uniform vec2 renderer_LVLLimitYMinCurve[4];\n                uniform vec2 renderer_LVLLimitZMinCurve[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 limitValue;\n            #ifdef RENDERER_LVL_LIMIT_CONSTANT_MODE\n                limitValue = renderer_LVLLimitMaxConstVector;\n                #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                    limitValue = mix(renderer_LVLLimitMinConstVector, limitValue, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_LIMIT_CURVE_MODE\n                limitValue = vec3(\n                    evaluateParticleCurve(renderer_LVLLimitXMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLLimitYMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLLimitZMaxCurve, normalizedAge)\n                );\n                #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                    vec3 minLimitValue = vec3(\n                        evaluateParticleCurve(renderer_LVLLimitXMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLLimitYMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLLimitZMinCurve, normalizedAge)\n                    );\n                    limitValue = mix(minLimitValue, limitValue, limitRand);\n                #endif\n            #endif\n\n            vec3 absVel = abs(velocity);\n            vec3 excess = max(absVel - limitValue, vec3(0.0));\n            velocity = sign(velocity) * (absVel - excess * effectiveDampen);\n        #else\n            float limitValue;\n            #ifdef RENDERER_LVL_LIMIT_CONSTANT_MODE\n                limitValue = renderer_LVLLimitMaxConst;\n                #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                    limitValue = mix(renderer_LVLLimitMinConst, limitValue, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_LIMIT_CURVE_MODE\n                limitValue = evaluateParticleCurve(renderer_LVLLimitMaxCurve, normalizedAge);\n                #ifdef RENDERER_LVL_LIMIT_IS_RANDOM_TWO\n                    float minLimitValue = evaluateParticleCurve(renderer_LVLLimitMinCurve, normalizedAge);\n                    limitValue = mix(minLimitValue, limitValue, limitRand);\n                #endif\n            #endif\n\n            float speed = length(velocity);\n            if (speed > limitValue && speed > 0.0) {\n                float excess = speed - limitValue;\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
     var stretched_billboard = "#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 velocity = rotationByQuaternions(renderer_SizeScale * localVelocity, worldRotation) + worldVelocity;\n\tvec3 cameraUpVector = normalize(velocity);\n\tvec3 direction = normalize(center - camera_Position);\n\tvec3 sideVector = normalize(cross(direction, normalize(velocity)));\n\n\tsideVector = renderer_SizeScale.xzy * sideVector;\n\tcameraUpVector = length(vec3(renderer_SizeScale.x, 0.0, 0.0)) * cameraUpVector;\n\n\tvec2 size = computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n\n\tconst mat2 rotationZHalfPI = mat2(0.0, -1.0, 1.0, 0.0);\n\tcorner = rotationZHalfPI * corner;\n\tcorner.y = corner.y - abs(corner.y);\n\n\tfloat speed = length(velocity); // TODO:\n\tcenter += sign(renderer_SizeScale.x) * (sign(renderer_StretchedBillboardLengthScale) * size.x * corner.x * sideVector\n\t        + (speed * renderer_StretchedBillboardSpeedScale + size.y * renderer_StretchedBillboardLengthScale) * corner.y * cameraUpVector);\n#endif"; // eslint-disable-line
     var vertical_billboard = "#ifdef RENDERER_MODE_VERTICAL_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy; // Billboard模式z轴无效\n\tconst vec3 cameraUpVector = vec3(0.0, 1.0, 0.0);\n\tvec3 sideVector = normalize(cross(camera_Forward, cameraUpVector));\n\n\tfloat rot = radians(computeParticleRotationFloat(a_StartRotation0.x, age, normalizedAge));\n\tfloat c = cos(rot);\n\tfloat s = sin(rot);\n\tmat2 rotation = mat2(c, -s, s, c);\n\tcorner = rotation * corner * cos(0.78539816339744830961566084581988); // TODO:临时缩小cos45,不确定U3D原因\n\tcorner *= computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n\tcenter += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * cameraUpVector);\n#endif"; // eslint-disable-line
@@ -9905,6 +9902,8 @@
         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,
@@ -9968,6 +9967,41 @@
                 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';
@@ -10295,7 +10329,7 @@
      * 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();
@@ -10311,7 +10345,7 @@
             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();
@@ -10457,7 +10491,7 @@
         };
         /**
        * 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);
@@ -10475,6 +10509,10 @@
             }
             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);
@@ -10737,7 +10775,7 @@
         /**
        * @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;
@@ -10759,6 +10797,13 @@
             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);
@@ -10769,32 +10814,22 @@
             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/";
     /**
      * Sub shader.
@@ -12338,6 +12373,44 @@
         return Background;
     }();
     /** @internal */ Background._premultiplySolidColor = new Color();
+    /**
+     * @internal
+     * Utility functions for remapping Entity/Component references during cloning.
+     */ var CloneUtils = /*#__PURE__*/ function() {
+        function CloneUtils() {}
+        CloneUtils.remapEntity = function remapEntity(srcRoot, targetRoot, entity) {
+            var path = CloneUtils._tempRemapPath;
+            if (!CloneUtils._getEntityHierarchyPath(srcRoot, entity, path)) return entity;
+            return CloneUtils._getEntityByHierarchyPath(targetRoot, path);
+        };
+        CloneUtils.remapComponent = function remapComponent(srcRoot, targetRoot, component) {
+            var path = CloneUtils._tempRemapPath;
+            var srcEntity = component.entity;
+            if (!CloneUtils._getEntityHierarchyPath(srcRoot, srcEntity, path)) return component;
+            return CloneUtils._getEntityByHierarchyPath(targetRoot, path)._components[srcEntity._components.indexOf(component)];
+        };
+        CloneUtils._getEntityHierarchyPath = function _getEntityHierarchyPath(rootEntity, searchEntity, inversePath) {
+            inversePath.length = 0;
+            while(searchEntity !== rootEntity){
+                var parent = searchEntity.parent;
+                if (!parent) {
+                    return false;
+                }
+                inversePath.push(searchEntity.siblingIndex);
+                searchEntity = parent;
+            }
+            return true;
+        };
+        CloneUtils._getEntityByHierarchyPath = function _getEntityByHierarchyPath(rootEntity, inversePath) {
+            var entity = rootEntity;
+            for(var i = inversePath.length - 1; i >= 0; i--){
+                entity = entity.children[inversePath[i]];
+            }
+            return entity;
+        };
+        return CloneUtils;
+    }();
+    CloneUtils._tempRemapPath = [];
     var ActiveChangeFlag = /*#__PURE__*/ function(ActiveChangeFlag) {
         ActiveChangeFlag[ActiveChangeFlag["None"] = 0] = "None";
         ActiveChangeFlag[ActiveChangeFlag["Scene"] = 1] = "Scene";
@@ -12412,6 +12485,11 @@
                 }
             }
         };
+        /**
+       * @internal
+       */ _proto._remap = function _remap(srcRoot, targetRoot) {
+            return CloneUtils.remapComponent(srcRoot, targetRoot, this);
+        };
         _proto._addResourceReferCount = function _addResourceReferCount(resource, count) {
             this._entity._isTemplate || resource._addReferCount(count);
         };
@@ -12485,9 +12563,6 @@
         ]);
         return Component;
     }(EngineObject);
-    __decorate$1([
-        ignoreClone
-    ], Component.prototype, "_entity", void 0);
     __decorate$1([
         ignoreClone
     ], Component.prototype, "_awoken", void 0);
@@ -12851,7 +12926,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             var position = target._position, rotation = target._rotation, scale = target._scale;
             // @ts-ignore
             position._onValueChanged = rotation._onValueChanged = scale._onValueChanged = null;
@@ -13463,9 +13538,6 @@
     __decorate$1([
         ignoreClone
     ], Transform.prototype, "_isParentDirty", void 0);
-    __decorate$1([
-        ignoreClone
-    ], Transform.prototype, "_parentTransformCache", void 0);
     __decorate$1([
         ignoreClone
     ], Transform.prototype, "_dirtyFlag", void 0);
@@ -13924,7 +13996,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             var _this__renderTarget;
             (_this__renderTarget = this._renderTarget) == null ? void 0 : _this__renderTarget._addReferCount(1);
         };
@@ -17127,9 +17199,6 @@
         return ColliderShape;
     }();
     ColliderShape._idGenerator = 0;
-    __decorate$1([
-        ignoreClone
-    ], ColliderShape.prototype, "_collider", void 0);
     __decorate$1([
         ignoreClone
     ], ColliderShape.prototype, "_nativeShape", void 0);
@@ -21511,7 +21580,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             var materials = this._materials;
             for(var i = 0, n = materials.length; i < n; i++){
                 target._setMaterial(i, materials[i]);
@@ -21766,9 +21835,6 @@
     __decorate$1([
         ignoreClone
     ], exports.Renderer.prototype, "_bounds", void 0);
-    __decorate$1([
-        ignoreClone
-    ], exports.Renderer.prototype, "_transformEntity", void 0);
     __decorate$1([
         deepClone
     ], exports.Renderer.prototype, "_shaderData", void 0);
@@ -21827,8 +21893,8 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            Renderer.prototype._cloneTo.call(this, target, srcRoot, targetRoot);
+       */ _proto._cloneTo = function _cloneTo(target) {
+            Renderer.prototype._cloneTo.call(this, target);
             target.sprite = this._sprite;
         };
         /**
@@ -22138,8 +22204,8 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            Renderer.prototype._cloneTo.call(this, target, srcRoot, targetRoot);
+       */ _proto._cloneTo = function _cloneTo(target) {
+            Renderer.prototype._cloneTo.call(this, target);
             target.sprite = this._sprite;
             target.drawMode = this._drawMode;
         };
@@ -22561,8 +22627,8 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            Renderer.prototype._cloneTo.call(this, target, srcRoot, targetRoot);
+       */ _proto._cloneTo = function _cloneTo(target) {
+            Renderer.prototype._cloneTo.call(this, target);
             target.font = this._font;
             target._subFont = this._subFont;
         };
@@ -23278,6 +23344,15 @@
             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;
@@ -23567,8 +23642,8 @@
     /**
      * 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;
     }({});
     /**
@@ -24244,8 +24319,8 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            Renderer.prototype._cloneTo.call(this, target, srcRoot, targetRoot);
+       */ _proto._cloneTo = function _cloneTo(target) {
+            Renderer.prototype._cloneTo.call(this, target);
             target.mesh = this._mesh;
         };
         /**
@@ -27100,44 +27175,6 @@
     ]);
     PrimitiveMesh._sphereEdgeIdx = 0;
     PrimitiveMesh._spherePoleIdx = 0;
-    /**
-     * @internal
-     * Utility functions for remapping Entity/Component references during cloning.
-     */ var CloneUtils = /*#__PURE__*/ function() {
-        function CloneUtils() {}
-        CloneUtils.remapEntity = function remapEntity(srcRoot, targetRoot, entity) {
-            var paths = CloneUtils._tempRemapPath;
-            var success = CloneUtils._getEntityHierarchyPath(srcRoot, entity, paths);
-            return success ? CloneUtils._getEntityByHierarchyPath(targetRoot, paths) : entity;
-        };
-        CloneUtils.remapComponent = function remapComponent(srcRoot, targetRoot, component) {
-            var _CloneUtils__getEntityByHierarchyPath;
-            var paths = CloneUtils._tempRemapPath;
-            var success = CloneUtils._getEntityHierarchyPath(srcRoot, component.entity, paths);
-            return success ? (_CloneUtils__getEntityByHierarchyPath = CloneUtils._getEntityByHierarchyPath(targetRoot, paths)) == null ? void 0 : _CloneUtils__getEntityByHierarchyPath.getComponent(component.constructor) : component;
-        };
-        CloneUtils._getEntityHierarchyPath = function _getEntityHierarchyPath(rootEntity, searchEntity, inversePath) {
-            inversePath.length = 0;
-            while(searchEntity !== rootEntity){
-                var parent = searchEntity.parent;
-                if (!parent) {
-                    return false;
-                }
-                inversePath.push(searchEntity.siblingIndex);
-                searchEntity = parent;
-            }
-            return true;
-        };
-        CloneUtils._getEntityByHierarchyPath = function _getEntityByHierarchyPath(rootEntity, inversePath) {
-            var entity = rootEntity;
-            for(var i = inversePath.length - 1; i >= 0; i--){
-                entity = entity.children[inversePath[i]];
-            }
-            return entity;
-        };
-        return CloneUtils;
-    }();
-    CloneUtils._tempRemapPath = [];
     /**
      * Skin used for skinned mesh renderer.
      */ var Skin = /*#__PURE__*/ function(EngineObject) {
@@ -27169,25 +27206,6 @@
             }
             this._updateMark = renderer.engine.time.frameCount;
         };
-        /**
-       * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            // Clone rootBone
-            var rootBone = this.rootBone;
-            if (rootBone) {
-                target.rootBone = CloneUtils.remapEntity(srcRoot, targetRoot, rootBone);
-            }
-            // Clone bones
-            var bones = this.bones;
-            if (bones.length > 0) {
-                var boneCount = bones.length;
-                var destBones = new Array(boneCount);
-                for(var i = 0; i < boneCount; i++){
-                    destBones[i] = CloneUtils.remapEntity(srcRoot, targetRoot, bones[i]);
-                }
-                target.bones = destBones;
-            }
-        };
         _create_class$2(Skin, [
             {
                 key: "rootBone",
@@ -27251,10 +27269,7 @@
         ignoreClone
     ], Skin.prototype, "_updatedManager", void 0);
     __decorate$1([
-        ignoreClone
-    ], Skin.prototype, "_rootBone", void 0);
-    __decorate$1([
-        ignoreClone
+        deepClone
     ], Skin.prototype, "_bones", void 0);
     __decorate$1([
         ignoreClone
@@ -27303,8 +27318,8 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
-            MeshRenderer.prototype._cloneTo.call(this, target, srcRoot, targetRoot);
+       */ _proto._cloneTo = function _cloneTo(target) {
+            MeshRenderer.prototype._cloneTo.call(this, target);
             if (this.skin) {
                 target._applySkin(null, target.skin);
             }
@@ -27840,9 +27855,7 @@
             for(var k in source){
                 CloneManager.cloneProperty(source, target, k, cloneModes[k], srcRoot, targetRoot, deepInstanceMap);
             }
-            if (source._cloneTo) {
-                source._cloneTo(target, srcRoot, targetRoot);
-            }
+            source._cloneTo == null ? void 0 : source._cloneTo.call(source, target, srcRoot, targetRoot);
         };
         return ComponentCloner;
     }();
@@ -28026,6 +28039,11 @@
         };
         /**
        * @internal
+       */ _proto._remap = function _remap(srcRoot, targetRoot) {
+            return CloneUtils.remapEntity(srcRoot, targetRoot, this);
+        };
+        /**
+       * @internal
        */ _proto._markAsTemplate = function _markAsTemplate(templateResource) {
             this._isTemplate = true;
             this._templateResource = templateResource;
@@ -30997,6 +31015,14 @@
         ParticleBillboardVertexAttribute["cornerTextureCoordinate"] = "a_CornerTextureCoordinate";
         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) {
@@ -31089,6 +31115,22 @@
             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;
@@ -31109,7 +31151,7 @@
     var depthOnlyFs = "void main() {\n}"; // eslint-disable-line
     var depthOnlyVs = "#define MATERIAL_OMIT_NORMAL\n#include <common>\n#include <common_vert>\n#include <blendShape_input>\nuniform mat4 camera_VPMat;\n\n\nvoid main() {\n\n    #include <begin_position_vert>\n    #include <blendShape_vert>\n    #include <skinning_vert>\n    #include <position_vert>\n\n}\n"; // eslint-disable-line
     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
     var pbrFs = "#include <common>\n#include <camera_declare>\n#include <transform_declare>\n\n#include <FogFragmentDeclaration>\n#include <PositionClipSpaceDeclaration>\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#include <pbr_frag_define>\n#include <pbr_helper>\n\nvoid main() {\n    #include <pbr_frag>\n    #include <FogFragment>\n}\n"; // eslint-disable-line
     var pbrVs = "#include <common>\n#include <common_vert>\n#include <blendShape_input>\n#include <uv_share>\n#include <color_share>\n#include <normal_share>\n#include <worldpos_share>\n\n#include <ShadowVertexDeclaration>\n#include <FogVertexDeclaration>\n#include <PositionClipSpaceDeclaration>\n\nvoid main() {\n\n    #include <begin_position_vert>\n    #include <begin_normal_vert>\n    #include <blendShape_vert>\n    #include <skinning_vert>\n    #include <uv_vert>\n    #include <color_vert>\n    #include <normal_vert>\n    #include <worldpos_vert>\n    #include <position_vert>\n\n    #include <ShadowVertex>\n    #include <FogVertex>\n    #include <PositionClipSpaceVertex>\n}\n"; // eslint-disable-line
@@ -31127,12 +31169,45 @@
     var trailVs = "attribute vec4 a_PositionBirthTime; // xyz: World position, w: Birth time (used by CPU only)\nattribute vec4 a_CornerTangent;     // x: Corner (-1 or 1), yzw: Tangent direction\nattribute float a_Distance;         // Absolute cumulative distance (written once per point)\n\nuniform vec4 renderer_TrailParams;    // x: TextureMode (0: Stretch, 1: Tile), y: TextureScaleX, z: TextureScaleY\nuniform vec2 renderer_DistanceParams;   // x: HeadDistance, y: TailDistance\nuniform vec3 camera_Position;\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\nuniform vec2 renderer_WidthCurve[4];   // Width curve (4 keyframes max: x=time, y=value)\nuniform vec4 renderer_ColorKeys[4];   // Color gradient (x=time, yzw=rgb)\nuniform vec2 renderer_AlphaKeys[4];   // Alpha gradient (x=time, y=alpha)\nuniform vec4 renderer_CurveMaxTime; // x: colorMaxTime, y: alphaMaxTime, z: widthMaxTime\n\nvarying vec2 v_uv;\nvarying vec4 v_color;\n\n#include <particle_common>\n\nvoid main() {\n    vec3 position = a_PositionBirthTime.xyz;\n    float corner = a_CornerTangent.x;\n    vec3 tangent = a_CornerTangent.yzw;\n\n    // Distance-based relative position: 0=head(newest), 1=tail(oldest)\n    float distFromHead = renderer_DistanceParams.x - a_Distance;\n    float totalDist = renderer_DistanceParams.x - renderer_DistanceParams.y;\n    float relativePos = totalDist > 0.0 ? distFromHead / totalDist : 0.0;\n\n    // Billboard: expand perpendicular to tangent and view direction\n    vec3 toCamera = normalize(camera_Position - position);\n    vec3 right = cross(tangent, toCamera);\n    float rightLenSq = dot(right, right);\n    if (rightLenSq < 0.000001) {\n        right = cross(tangent, vec3(0.0, 1.0, 0.0));\n        rightLenSq = dot(right, right);\n        if (rightLenSq < 0.000001) {\n            right = cross(tangent, vec3(1.0, 0.0, 0.0));\n            rightLenSq = dot(right, right);\n        }\n    }\n    right = right * inversesqrt(rightLenSq);\n\n    float width = evaluateParticleCurve(renderer_WidthCurve, min(relativePos, renderer_CurveMaxTime.z));\n    vec3 worldPosition = position + right * width * 0.5 * corner;\n\n    gl_Position = camera_ProjMat * camera_ViewMat * vec4(worldPosition, 1.0);\n\n    // u = position along trail (affected by textureMode), v = corner side.\n    float u = renderer_TrailParams.x == 0.0 ? relativePos : distFromHead;\n    float v = corner * 0.5 + 0.5;\n    v_uv = vec2(u * renderer_TrailParams.y, v * renderer_TrailParams.z);\n\n    v_color = evaluateParticleGradient(renderer_ColorKeys, renderer_CurveMaxTime.x, renderer_AlphaKeys, renderer_CurveMaxTime.y, relativePos);\n}\n"; // eslint-disable-line
     var unlitFs = "#include <common>\n#include <uv_share>\n#include <FogFragmentDeclaration>\n\nuniform vec4 material_BaseColor;\nuniform float material_AlphaCutoff;\n\n#ifdef MATERIAL_HAS_BASETEXTURE\n    uniform sampler2D material_BaseTexture;\n#endif\n\nvoid main() {\n     vec4 baseColor = material_BaseColor;\n\n    #ifdef MATERIAL_HAS_BASETEXTURE\n        baseColor *= texture2DSRGB(material_BaseTexture, v_uv);\n    #endif\n\n    #ifdef MATERIAL_IS_ALPHA_CUTOFF\n        if( baseColor.a < material_AlphaCutoff ) {\n            discard;\n        }\n    #endif\n\n    gl_FragColor = baseColor;\n\n    #ifndef MATERIAL_IS_TRANSPARENT\n        gl_FragColor.a = 1.0;\n    #endif\n\n    #include <FogFragment>\n}\n"; // eslint-disable-line
     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
             });
@@ -31623,8 +31698,7 @@
         };
         /**
        * @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) {
@@ -31633,7 +31707,7 @@
                     shaderProgramPools.length = length;
                 }
                 shaderProgramPools[index] = pool = new ShaderProgramPool(this);
-                shaderPass._shaderProgramPools.push(pool);
+                trackPools == null ? void 0 : trackPools.push(pool);
             }
             return pool;
         };
@@ -33507,24 +33581,24 @@
     Scene._fogColorProperty = ShaderProperty.getByName("scene_FogColor");
     Scene._fogParamsProperty = ShaderProperty.getByName("scene_FogParams");
     Scene._prefilterdDFGProperty = ShaderProperty.getByName("scene_PrefilteredDFG");
-    function _array_like_to_array$1(arr, len) {
+    function _array_like_to_array$2(arr, len) {
         if (len == null || len > arr.length) len = arr.length;
         for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
         return arr2;
     }
-    function _unsupported_iterable_to_array$1(o, minLen) {
+    function _unsupported_iterable_to_array$2(o, minLen) {
         if (!o) return;
-        if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+        if (typeof o === "string") return _array_like_to_array$2(o, minLen);
         var n = Object.prototype.toString.call(o).slice(8, -1);
         if (n === "Object" && o.constructor) n = o.constructor.name;
         if (n === "Map" || n === "Set") return Array.from(n);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
     }
-    function _create_for_of_iterator_helper_loose$1(o, allowArrayLike) {
+    function _create_for_of_iterator_helper_loose$2(o, allowArrayLike) {
         var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
         if (it) return (it = it.call(o)).next.bind(it);
         // Fallback for engines without symbol support
-        if (Array.isArray(o) || (it = _unsupported_iterable_to_array$1(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (Array.isArray(o) || (it = _unsupported_iterable_to_array$2(o)) || allowArrayLike && o && typeof o.length === "number") {
             if (it) o = it;
             var i = 0;
             return function() {
@@ -33679,7 +33753,7 @@
             if (this.onPhysicsUpdate !== prototype.onPhysicsUpdate) {
                 componentsManager.addOnPhysicsUpdateScript(this);
             }
-            for(var _iterator = _create_for_of_iterator_helper_loose$1(Object.values(PointerMethods)), _step; !(_step = _iterator()).done;){
+            for(var _iterator = _create_for_of_iterator_helper_loose$2(Object.values(PointerMethods)), _step; !(_step = _iterator()).done;){
                 var pointerMethod = _step.value;
                 if (this[pointerMethod] === prototype[pointerMethod]) {
                     this[pointerMethod] = null;
@@ -36001,7 +36075,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             var animatorController = target._animatorController;
             if (animatorController) {
                 target._addResourceReferCount(animatorController, 1);
@@ -37933,6 +38007,10 @@
             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;
@@ -37941,7 +38019,9 @@
             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;
@@ -38096,6 +38176,327 @@
         /** On Generator Bounds Related Params Changed */ ParticleUpdateFlags[ParticleUpdateFlags["GeneratorVolume"] = 4] = "GeneratorVolume";
         return ParticleUpdateFlags;
     }({});
+    /**
+     * Transform Feedback object for GPU-based data capture.
+     * @internal
+     */ var TransformFeedback = /*#__PURE__*/ function(GraphicsResource) {
+        _inherits$2(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$2(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$2(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$2(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$2(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) {
@@ -38133,6 +38534,7 @@
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["Shape"] = 2941263940] = "Shape";
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["GravityModifier"] = 2759560269] = "GravityModifier";
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
+        ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
         return ParticleRandomSubSeeds;
     }({});
     /**
@@ -39182,6 +39584,413 @@
     __decorate$1([
         deepClone
     ], ForceOverLifetimeModule.prototype, "_forceZ", void 0);
+    /**
+     * Limit velocity over lifetime module.
+     */ var LimitVelocityOverLifetimeModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+        _inherits$2(LimitVelocityOverLifetimeModule, ParticleGeneratorModule);
+        function LimitVelocityOverLifetimeModule(generator) {
+            var _this;
+            _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._limitRand = new Rand(0, ParticleRandomSubSeeds.LimitVelocityOverLifetime), _this._limitMinConstantVec = new Vector3(), _this._limitMaxConstantVec = new Vector3(), _this._dragConstantVec = new Vector2(), _this._separateAxes = false, _this._dampen = 1, _this._multiplyDragByParticleSize = false, _this._multiplyDragByParticleVelocity = false, _this._space = ParticleSimulationSpace.Local;
+            _this.limitX = new ParticleCompositeCurve(1);
+            _this.limitY = new ParticleCompositeCurve(1);
+            _this.limitZ = 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._isLimitRandomMode = function _isLimitRandomMode() {
+            if (this._separateAxes) {
+                return (this._limitX.mode === ParticleCurveMode.TwoConstants || this._limitX.mode === ParticleCurveMode.TwoCurves) && (this._limitY.mode === ParticleCurveMode.TwoConstants || this._limitY.mode === ParticleCurveMode.TwoCurves) && (this._limitZ.mode === ParticleCurveMode.TwoConstants || this._limitZ.mode === ParticleCurveMode.TwoCurves);
+            }
+            return this._limitX.mode === ParticleCurveMode.TwoConstants || this._limitX.mode === ParticleCurveMode.TwoCurves;
+        };
+        /**
+       * @internal
+       */ _proto._updateShaderData = function _updateShaderData(shaderData) {
+            var enabledModuleMacro = null;
+            var separateAxesMacro = null;
+            var limitModeMacro = null;
+            var limitRandomMacro = 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
+                if (this._separateAxes) {
+                    separateAxesMacro = LimitVelocityOverLifetimeModule._separateAxesMacro;
+                    var result = this._uploadSeparateAxisLimits(shaderData);
+                    limitModeMacro = result.modeMacro;
+                    limitRandomMacro = result.randomMacro;
+                } else {
+                    var result1 = this._uploadScalarLimit(shaderData);
+                    limitModeMacro = result1.modeMacro;
+                    limitRandomMacro = 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._limitModeMacro = this._enableMacro(shaderData, this._limitModeMacro, limitModeMacro);
+            this._limitRandomMacro = this._enableMacro(shaderData, this._limitRandomMacro, limitRandomMacro);
+            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._limitRand.reset(seed, ParticleRandomSubSeeds.LimitVelocityOverLifetime);
+        };
+        _proto._uploadScalarLimit = function _uploadScalarLimit(shaderData) {
+            var limitX = this._limitX;
+            var modeMacro = null;
+            var randomMacro = null;
+            var isRandomCurveMode = limitX.mode === ParticleCurveMode.TwoCurves;
+            if (isRandomCurveMode || limitX.mode === ParticleCurveMode.Curve) {
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitMaxCurveProperty, limitX.curveMax._getTypeArray());
+                modeMacro = LimitVelocityOverLifetimeModule._limitCurveModeMacro;
+                if (isRandomCurveMode) {
+                    shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitMinCurveProperty, limitX.curveMin._getTypeArray());
+                    randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                }
+            } else {
+                shaderData.setFloat(LimitVelocityOverLifetimeModule._limitMaxConstProperty, limitX.constantMax);
+                modeMacro = LimitVelocityOverLifetimeModule._limitConstantModeMacro;
+                if (limitX.mode === ParticleCurveMode.TwoConstants) {
+                    shaderData.setFloat(LimitVelocityOverLifetimeModule._limitMinConstProperty, limitX.constantMin);
+                    randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                }
+            }
+            return {
+                modeMacro: modeMacro,
+                randomMacro: randomMacro
+            };
+        };
+        _proto._uploadSeparateAxisLimits = function _uploadSeparateAxisLimits(shaderData) {
+            var limitX = this._limitX;
+            var limitY = this._limitY;
+            var limitZ = this._limitZ;
+            var modeMacro = null;
+            var randomMacro = null;
+            var isRandomCurveMode = limitX.mode === ParticleCurveMode.TwoCurves && limitY.mode === ParticleCurveMode.TwoCurves && limitZ.mode === ParticleCurveMode.TwoCurves;
+            if (isRandomCurveMode || limitX.mode === ParticleCurveMode.Curve && limitY.mode === ParticleCurveMode.Curve && limitZ.mode === ParticleCurveMode.Curve) {
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitXMaxCurveProperty, limitX.curveMax._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitYMaxCurveProperty, limitY.curveMax._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitZMaxCurveProperty, limitZ.curveMax._getTypeArray());
+                modeMacro = LimitVelocityOverLifetimeModule._limitCurveModeMacro;
+                if (isRandomCurveMode) {
+                    shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitXMinCurveProperty, limitX.curveMin._getTypeArray());
+                    shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitYMinCurveProperty, limitY.curveMin._getTypeArray());
+                    shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitZMinCurveProperty, limitZ.curveMin._getTypeArray());
+                    randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                }
+            } else {
+                var constantMax = this._limitMaxConstantVec;
+                constantMax.set(limitX.constantMax, limitY.constantMax, limitZ.constantMax);
+                shaderData.setVector3(LimitVelocityOverLifetimeModule._limitMaxConstVecProperty, constantMax);
+                modeMacro = LimitVelocityOverLifetimeModule._limitConstantModeMacro;
+                if (limitX.mode === ParticleCurveMode.TwoConstants && limitY.mode === ParticleCurveMode.TwoConstants && limitZ.mode === ParticleCurveMode.TwoConstants) {
+                    var constantMin = this._limitMinConstantVec;
+                    constantMin.set(limitX.constantMin, limitY.constantMin, limitZ.constantMin);
+                    shaderData.setVector3(LimitVelocityOverLifetimeModule._limitMinConstVecProperty, constantMin);
+                    randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                }
+            }
+            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$2(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: "limit",
+                get: /**
+       * Speed limit when separateAxes is false.
+       */ function get() {
+                    return this._limitX;
+                },
+                set: function set(value) {
+                    this.limitX = value;
+                }
+            },
+            {
+                key: "limitX",
+                get: /**
+       * Speed limit for the x-axis (or overall limit when separateAxes is false).
+       */ function get() {
+                    return this._limitX;
+                },
+                set: function set(value) {
+                    var lastValue = this._limitX;
+                    if (value !== lastValue) {
+                        this._limitX = value;
+                        this._onCompositeCurveChange(lastValue, value);
+                    }
+                }
+            },
+            {
+                key: "limitY",
+                get: /**
+       * Speed limit for the y-axis.
+       */ function get() {
+                    return this._limitY;
+                },
+                set: function set(value) {
+                    var lastValue = this._limitY;
+                    if (value !== lastValue) {
+                        this._limitY = value;
+                        this._onCompositeCurveChange(lastValue, value);
+                    }
+                }
+            },
+            {
+                key: "limitZ",
+                get: /**
+       * Speed limit for the z-axis.
+       */ function get() {
+                    return this._limitZ;
+                },
+                set: function set(value) {
+                    var lastValue = this._limitZ;
+                    if (value !== lastValue) {
+                        this._limitZ = 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.
+       */ 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._limitConstantModeMacro = ShaderMacro.getByName("RENDERER_LVL_LIMIT_CONSTANT_MODE");
+    LimitVelocityOverLifetimeModule._limitCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_LIMIT_CURVE_MODE");
+    LimitVelocityOverLifetimeModule._limitIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_LIMIT_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._limitMaxConstProperty = ShaderProperty.getByName("renderer_LVLLimitMaxConst");
+    LimitVelocityOverLifetimeModule._limitMinConstProperty = ShaderProperty.getByName("renderer_LVLLimitMinConst");
+    LimitVelocityOverLifetimeModule._limitMaxCurveProperty = ShaderProperty.getByName("renderer_LVLLimitMaxCurve");
+    LimitVelocityOverLifetimeModule._limitMinCurveProperty = ShaderProperty.getByName("renderer_LVLLimitMinCurve");
+    LimitVelocityOverLifetimeModule._limitMaxConstVecProperty = ShaderProperty.getByName("renderer_LVLLimitMaxConstVector");
+    LimitVelocityOverLifetimeModule._limitMinConstVecProperty = ShaderProperty.getByName("renderer_LVLLimitMinConstVector");
+    LimitVelocityOverLifetimeModule._limitXMaxCurveProperty = ShaderProperty.getByName("renderer_LVLLimitXMaxCurve");
+    LimitVelocityOverLifetimeModule._limitXMinCurveProperty = ShaderProperty.getByName("renderer_LVLLimitXMinCurve");
+    LimitVelocityOverLifetimeModule._limitYMaxCurveProperty = ShaderProperty.getByName("renderer_LVLLimitYMaxCurve");
+    LimitVelocityOverLifetimeModule._limitYMinCurveProperty = ShaderProperty.getByName("renderer_LVLLimitYMinCurve");
+    LimitVelocityOverLifetimeModule._limitZMaxCurveProperty = ShaderProperty.getByName("renderer_LVLLimitZMaxCurve");
+    LimitVelocityOverLifetimeModule._limitZMinCurveProperty = ShaderProperty.getByName("renderer_LVLLimitZMinCurve");
+    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$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitRand", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitMinConstantVec", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitMaxConstantVec", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_dragConstantVec", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_enabledModuleMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_separateAxesCachedMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitModeMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitRandomMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_dragCurveCachedMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_dragRandomCachedMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_dragSizeMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_dragVelocityMacro", void 0);
+    __decorate$1([
+        deepClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitX", void 0);
+    __decorate$1([
+        deepClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitY", void 0);
+    __decorate$1([
+        deepClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_limitZ", void 0);
+    __decorate$1([
+        deepClone
+    ], LimitVelocityOverLifetimeModule.prototype, "_drag", void 0);
     /**
      * Control how Particle Generator apply transform scale.
      */ var ParticleScaleMode = /*#__PURE__*/ function(ParticleScaleMode) {
@@ -40223,6 +41032,8 @@
             /** @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;
@@ -40241,6 +41052,7 @@
             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;
@@ -40279,11 +41091,7 @@
             } 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();
@@ -40367,6 +41175,16 @@
                     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();
@@ -40380,16 +41198,21 @@
             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;
@@ -40441,6 +41264,15 @@
             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);
         };
         /**
@@ -40456,18 +41288,28 @@
             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);
@@ -40476,7 +41318,6 @@
                     if (firstRetiredElement <= firstFreeElement) {
                         migrateCount = firstFreeElement - firstRetiredElement;
                         bufferOffset = 0;
-                        // Maintain expanded pointers
                         this._firstFreeElement -= firstRetiredElement;
                         this._firstNewElement -= firstRetiredElement;
                         this._firstActiveElement -= firstRetiredElement;
@@ -40484,20 +41325,29 @@
                     } 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
@@ -40505,6 +41355,7 @@
             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);
@@ -40519,11 +41370,41 @@
             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;
@@ -40550,10 +41431,19 @@
         };
         /**
        * @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
@@ -40785,8 +41675,34 @@
                 instanceVertices[offset + 39] = rand1.random();
                 instanceVertices[offset + 40] = rand1.random();
             }
+            var limitVelocityOverLifetime = this.limitVelocityOverLifetime;
+            if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isLimitRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
+                instanceVertices[offset + 41] = limitVelocityOverLifetime._limitRand.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;
+                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;
@@ -40830,16 +41746,19 @@
                 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;
@@ -41057,11 +41976,13 @@
     ParticleGenerator._tempVector22 = new Vector2();
     ParticleGenerator._tempVector30 = new Vector3();
     ParticleGenerator._tempVector31 = new Vector3();
+    ParticleGenerator._tempVector32 = new Vector3();
     ParticleGenerator._tempMat = new Matrix();
     ParticleGenerator._tempColor0 = new Color();
     ParticleGenerator._tempParticleRenderers = new Array();
     ParticleGenerator._particleIncreaseCount = 128;
     ParticleGenerator._transformedBoundsIncreaseCount = 16;
+    ParticleGenerator._transformFeedbackMacro = ShaderMacro.getByName("RENDERER_TRANSFORM_FEEDBACK");
     __decorate$1([
         deepClone
     ], ParticleGenerator.prototype, "main", void 0);
@@ -41074,6 +41995,9 @@
     __decorate$1([
         deepClone
     ], ParticleGenerator.prototype, "forceOverLifetime", void 0);
+    __decorate$1([
+        deepClone
+    ], ParticleGenerator.prototype, "limitVelocityOverLifetime", void 0);
     __decorate$1([
         deepClone
     ], ParticleGenerator.prototype, "sizeOverLifetime", void 0);
@@ -41112,7 +42036,13 @@
     ], ParticleGenerator.prototype, "_subPrimitive", void 0);
     __decorate$1([
         ignoreClone
-    ], ParticleGenerator.prototype, "_renderer", void 0);
+    ], ParticleGenerator.prototype, "_feedbackSimulator", void 0);
+    __decorate$1([
+        ignoreClone
+    ], ParticleGenerator.prototype, "_useTransformFeedback", void 0);
+    __decorate$1([
+        ignoreClone
+    ], ParticleGenerator.prototype, "_feedbackBindingIndex", void 0);
     __decorate$1([
         ignoreClone
     ], ParticleGenerator.prototype, "_isPlaying", void 0);
@@ -41839,7 +42769,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, _, __) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             target.mesh = this._mesh;
         };
         _create_class$2(MeshShape, [
@@ -42806,7 +43736,7 @@
         };
         /**
        * @internal
-       */ _proto._cloneTo = function _cloneTo(target, srcRoot, targetRoot) {
+       */ _proto._cloneTo = function _cloneTo(target) {
             var _target__clip;
             (_target__clip = target._clip) == null ? void 0 : _target__clip._addReferCount(1);
             target._gainNode.gain.setValueAtTime(target._volume, AudioManager.getContext().currentTime);
@@ -43260,6 +44190,7 @@
         Layer: Layer,
         LayerPathMask: LayerPathMask,
         Light: Light,
+        LimitVelocityOverLifetimeModule: LimitVelocityOverLifetimeModule,
         Loader: Loader,
         Logger: Logger,
         MSAASamples: MSAASamples,
@@ -43710,6 +44641,14 @@
                 throw "Buffer is write-only on WebGL1.0 platforms.";
             }
         };
+        _proto.copyFromBuffer = function copyFromBuffer(srcBuffer, srcByteOffset, dstByteOffset, byteLength) {
+            var gl = this._gl;
+            gl.bindBuffer(gl.COPY_READ_BUFFER, srcBuffer._glBuffer);
+            gl.bindBuffer(gl.COPY_WRITE_BUFFER, this._glBuffer);
+            gl.copyBufferSubData(gl.COPY_READ_BUFFER, gl.COPY_WRITE_BUFFER, srcByteOffset, dstByteOffset, byteLength);
+            gl.bindBuffer(gl.COPY_READ_BUFFER, null);
+            gl.bindBuffer(gl.COPY_WRITE_BUFFER, null);
+        };
         _proto.destroy = function destroy() {
             this._gl.deleteBuffer(this._glBuffer);
             this._gl = null;
@@ -45200,6 +46139,150 @@
         };
         return GLTextureCube;
     }(GLTexture);
+    /**
+     * @internal
+     * WebGL2 implementation of Transform Feedback.
+     */ var GLTransformFeedback = /*#__PURE__*/ function() {
+        function GLTransformFeedback(rhi) {
+            var gl = rhi.gl;
+            this._gl = gl;
+            this._glTransformFeedback = gl.createTransformFeedback();
+        }
+        var _proto = GLTransformFeedback.prototype;
+        _proto.bindBufferRange = function bindBufferRange(index, buffer, byteOffset, byteSize) {
+            var gl = this._gl;
+            gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, index, buffer._glBuffer, byteOffset, byteSize);
+        };
+        _proto.unbindBuffer = function unbindBuffer(index) {
+            var gl = this._gl;
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, index, null);
+        };
+        _proto.begin = function begin(primitiveMode) {
+            this._gl.beginTransformFeedback(primitiveMode);
+        };
+        _proto.end = function end() {
+            this._gl.endTransformFeedback();
+        };
+        _proto.bind = function bind() {
+            var gl = this._gl;
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this._glTransformFeedback);
+        };
+        _proto.unbind = function unbind() {
+            var gl = this._gl;
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        };
+        _proto.destroy = function destroy() {
+            if (this._glTransformFeedback) {
+                this._gl.deleteTransformFeedback(this._glTransformFeedback);
+                this._glTransformFeedback = null;
+            }
+        };
+        return GLTransformFeedback;
+    }();
+    function _array_like_to_array$1(arr, len) {
+        if (len == null || len > arr.length) len = arr.length;
+        for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+        return arr2;
+    }
+    function _unsupported_iterable_to_array$1(o, minLen) {
+        if (!o) return;
+        if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+        var n = Object.prototype.toString.call(o).slice(8, -1);
+        if (n === "Object" && o.constructor) n = o.constructor.name;
+        if (n === "Map" || n === "Set") return Array.from(n);
+        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+    }
+    function _create_for_of_iterator_helper_loose$1(o, allowArrayLike) {
+        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+        if (it) return (it = it.call(o)).next.bind(it);
+        // Fallback for engines without symbol support
+        if (Array.isArray(o) || (it = _unsupported_iterable_to_array$1(o)) || allowArrayLike && o && typeof o.length === "number") {
+            if (it) o = it;
+            var i = 0;
+            return function() {
+                if (i >= o.length) return {
+                    done: true
+                };
+                return {
+                    done: false,
+                    value: o[i++]
+                };
+            };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    /**
+     * @internal
+     * WebGL2 implementation of Transform Feedback primitive.
+     * Maintains two VAOs (one per read direction), auto-rebuilds when program changes.
+     */ var GLTransformFeedbackPrimitive = /*#__PURE__*/ function() {
+        function GLTransformFeedbackPrimitive(gl) {
+            this._lastProgramId = -1;
+            this._gl = gl;
+        }
+        var _proto = GLTransformFeedbackPrimitive.prototype;
+        _proto.updateVertexLayout = function updateVertexLayout(program, readBinding, writeBinding, feedbackElements, inputBinding, inputElements) {
+            if (program.id === this._lastProgramId) return;
+            this._deleteVAOs();
+            var attribs = program.attributeLocation;
+            this._vaoA = this._createVAO(attribs, readBinding, feedbackElements, inputBinding, inputElements);
+            this._vaoB = this._createVAO(attribs, writeBinding, feedbackElements, inputBinding, inputElements);
+            this._lastProgramId = program.id;
+            this._gl.bindVertexArray(null);
+        };
+        _proto.bind = function bind(readIsA) {
+            this._gl.bindVertexArray(readIsA ? this._vaoA : this._vaoB);
+        };
+        _proto.unbind = function unbind() {
+            this._gl.bindVertexArray(null);
+        };
+        _proto.draw = function draw(mode, first, count) {
+            this._gl.drawArrays(mode, first, count);
+        };
+        _proto.invalidate = function invalidate() {
+            this._deleteVAOs();
+        };
+        _proto.destroy = function destroy() {
+            this._deleteVAOs();
+        };
+        _proto._deleteVAOs = function _deleteVAOs() {
+            var gl = this._gl;
+            if (this._vaoA) {
+                gl.deleteVertexArray(this._vaoA);
+                this._vaoA = null;
+            }
+            if (this._vaoB) {
+                gl.deleteVertexArray(this._vaoB);
+                this._vaoB = null;
+            }
+            this._lastProgramId = -1;
+        };
+        _proto._createVAO = function _createVAO(attribs, feedbackBinding, feedbackElements, inputBinding, inputElements) {
+            var gl = this._gl;
+            var vao = gl.createVertexArray();
+            gl.bindVertexArray(vao);
+            // @ts-ignore: Access internal _platformBuffer across packages
+            gl.bindBuffer(gl.ARRAY_BUFFER, feedbackBinding.buffer._platformBuffer._glBuffer);
+            this._bindElements(gl, attribs, feedbackElements, feedbackBinding.stride);
+            // @ts-ignore: Access internal _platformBuffer across packages
+            gl.bindBuffer(gl.ARRAY_BUFFER, inputBinding.buffer._platformBuffer._glBuffer);
+            this._bindElements(gl, attribs, inputElements, inputBinding.stride);
+            gl.bindBuffer(gl.ARRAY_BUFFER, null);
+            return vao;
+        };
+        _proto._bindElements = function _bindElements(gl, attribs, elements, stride) {
+            for(var _iterator = _create_for_of_iterator_helper_loose$1(elements), _step; !(_step = _iterator()).done;){
+                var element = _step.value;
+                var loc = attribs[element.attribute];
+                if (loc !== undefined && loc !== -1) {
+                    var info = element._formatMetaInfo;
+                    gl.enableVertexAttribArray(loc);
+                    gl.vertexAttribPointer(loc, info.size, info.type, info.normalized, stride, element.offset);
+                }
+            }
+        };
+        return GLTransformFeedbackPrimitive;
+    }();
     /**
      * WebGL mode.
      */ var WebGLMode = /*#__PURE__*/ function(WebGLMode) {
@@ -45321,6 +46404,37 @@
             if (bufferUsage === void 0) bufferUsage = BufferUsage.Static;
             return new GLBuffer(this, type, byteLength, bufferUsage, data);
         };
+        _proto.createPlatformTransformFeedback = function createPlatformTransformFeedback() {
+            return new GLTransformFeedback(this);
+        };
+        _proto.createPlatformTransformFeedbackPrimitive = function createPlatformTransformFeedbackPrimitive() {
+            return new GLTransformFeedbackPrimitive(this._gl);
+        };
+        /**
+       * Enable GL_RASTERIZER_DISCARD (WebGL2 only).
+       */ _proto.enableRasterizerDiscard = function enableRasterizerDiscard() {
+            if (this._isWebGL2) {
+                var gl = this._gl;
+                gl.enable(gl.RASTERIZER_DISCARD);
+            }
+        };
+        /**
+       * Disable GL_RASTERIZER_DISCARD (WebGL2 only).
+       */ _proto.disableRasterizerDiscard = function disableRasterizerDiscard() {
+            if (this._isWebGL2) {
+                var gl = this._gl;
+                gl.disable(gl.RASTERIZER_DISCARD);
+            }
+        };
+        /**
+       * Invalidate the cached shader program state.
+       * Call this after using a custom program (e.g., Transform Feedback) outside the engine's pipeline.
+       */ _proto.invalidateShaderProgramState = function invalidateShaderProgramState() {
+            if (this._currentBindShaderProgram) {
+                this._gl.useProgram(null);
+                this._currentBindShaderProgram = null;
+            }
+        };
         _proto.requireExtension = function requireExtension(ext) {
             return this._extensions.requireExtension(ext);
         };
@@ -46507,11 +47621,14 @@
                         return resource;
                     });
                 } else if (ReflectionParser._isComponentRef(value)) {
-                    var _this__context_components_get;
-                    return Promise.resolve((_this__context_components_get = this._context.components.get(value.componentId)) != null ? _this__context_components_get : null);
+                    var entity = this._resolveEntityByPath(value.entityPath);
+                    if (!entity) return Promise.resolve(null);
+                    var type = Loader.getClass(value.componentType);
+                    if (!type) return Promise.resolve(null);
+                    var _entity_getComponents_value_componentIndex;
+                    return Promise.resolve((_entity_getComponents_value_componentIndex = entity.getComponents(type, [])[value.componentIndex]) != null ? _entity_getComponents_value_componentIndex : null);
                 } else if (ReflectionParser._isEntityRef(value)) {
-                    // entity reference
-                    return Promise.resolve(this._context.entityMap.get(value.entityId));
+                    return Promise.resolve(this._resolveEntityByPath(value.entityPath));
                 } else if (ReflectionParser._isSignalRef(value)) {
                     return this.parseSignal(value);
                 } else if (originValue) {
@@ -46569,6 +47686,16 @@
                 return Promise.resolve(entity);
             }
         };
+        _proto._resolveEntityByPath = function _resolveEntityByPath(entityPath) {
+            var _this__context = this._context, rootIds = _this__context.rootIds, entityMap = _this__context.entityMap;
+            if (!entityPath.length || entityPath[0] >= rootIds.length) return null;
+            var entity = entityMap.get(rootIds[entityPath[0]]);
+            for(var i = 1; i < entityPath.length; i++){
+                if (!entity || entityPath[i] >= entity.children.length) return null;
+                entity = entity.children[entityPath[i]];
+            }
+            return entity;
+        };
         ReflectionParser._isClass = function _isClass(value) {
             return value["class"] !== undefined;
         };
@@ -46579,10 +47706,10 @@
             return value["url"] !== undefined;
         };
         ReflectionParser._isEntityRef = function _isEntityRef(value) {
-            return value["entityId"] !== undefined;
+            return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
         };
         ReflectionParser._isComponentRef = function _isComponentRef(value) {
-            return value["ownerId"] !== undefined && value["componentId"] !== undefined;
+            return Array.isArray(value["entityPath"]) && value["componentType"] !== undefined;
         };
         ReflectionParser._isSignalRef = function _isSignalRef(value) {
             return value["listeners"] !== undefined;
@@ -46808,6 +47935,13 @@
                 for(var i = 0, l = entities.length; i < l; i++){
                     entityMap.set(entitiesConfig[i].id, entities[i]);
                 }
+                // Build rootIds in serialization order (not async completion order)
+                var rootIds = _this.context.rootIds;
+                for(var i1 = 0, l1 = entitiesConfig.length; i1 < l1; i1++){
+                    if (!entitiesConfig[i1].parent && !entitiesConfig[i1].strippedId) {
+                        rootIds.push(entitiesConfig[i1].id);
+                    }
+                }
                 return entities;
             });
         };
@@ -46933,7 +48067,6 @@
         _proto._parseEntity = function _parseEntity(entityConfig, engine) {
             var transform = entityConfig.transform;
             var entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
-            if (!entityConfig.parent) this.context.rootIds.push(entityConfig.id);
             this._addEntityPlugin(entityConfig.id, entity);
             return Promise.resolve(entity);
         };
@@ -46946,7 +48079,6 @@
             }).then(function(prefabResource) {
                 var entity = _instanceof1(prefabResource, PrefabResource) ? prefabResource.instantiate() : prefabResource.instantiateSceneRoot();
                 var instanceContext = new ParserContext(engine, ParserType.Prefab, null);
-                if (!entityConfig.parent) _this.context.rootIds.push(entityConfig.id);
                 _this._generateInstanceContext(entity, instanceContext, "");
                 _this._prefabContextMap.set(entity, instanceContext);
                 var cbArray = _this._prefabPromiseMap.get(entityConfig.id);
@@ -52926,7 +54058,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.15";
+    var version = "2.0.0-alpha.17";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);
@@ -53073,6 +54205,7 @@
     exports.Layer = Layer;
     exports.LayerPathMask = LayerPathMask;
     exports.Light = Light;
+    exports.LimitVelocityOverLifetimeModule = LimitVelocityOverLifetimeModule;
     exports.Loader = Loader;
     exports.Logger = Logger;
     exports.MSAASamples = MSAASamples;