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

package/dist/module.js

@@ -4912,7 +4912,7 @@ var texture_sheet_animation_module = "#if defined(RENDERER_TSA_FRAME_CURVE) || d
 
 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 limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n    uniform int renderer_LVLSpace;\n    uniform float renderer_LVLDampen;\n\n    // Scalar limit\n    #ifndef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform float renderer_LVLSpeedMaxConst;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform float renderer_LVLSpeedMinConst;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Per-axis limit\n    #ifdef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform vec3 renderer_LVLSpeedMaxConstVector;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec3 renderer_LVLSpeedMinConstVector;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedXMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedYMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedZMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedXMinCurve[4];\n                uniform vec2 renderer_LVLSpeedYMinCurve[4];\n                uniform vec2 renderer_LVLSpeedZMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Drag curve\n    #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n        uniform vec2 renderer_LVLDragMaxCurve[4];\n        #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n            uniform vec2 renderer_LVLDragMinCurve[4];\n        #endif\n    #endif\n\n    float evaluateLVLDrag(float normalizedAge, float dragRand) {\n        #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n            float dragMax = evaluateParticleCurve(renderer_LVLDragMaxCurve, normalizedAge);\n            #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n                float dragMin = evaluateParticleCurve(renderer_LVLDragMinCurve, normalizedAge);\n                return mix(dragMin, dragMax, dragRand);\n            #else\n                return dragMax;\n            #endif\n        #else\n            return mix(renderer_LVLDragConstant.x, renderer_LVLDragConstant.y, dragRand);\n        #endif\n    }\n\n    vec3 applyLVLSpeedLimitTF(vec3 velocity, float normalizedAge, float limitRand, float effectiveDampen) {\n        #ifdef RENDERER_LVL_SEPARATE_AXES\n            vec3 limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConstVector;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConstVector, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = vec3(\n                    evaluateParticleCurve(renderer_LVLSpeedXMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedYMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedZMaxCurve, normalizedAge)\n                );\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    vec3 minLimitSpeed = vec3(\n                        evaluateParticleCurve(renderer_LVLSpeedXMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedYMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedZMinCurve, normalizedAge)\n                    );\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            vec3 absVel = abs(velocity);\n            vec3 excess = max(absVel - limitSpeed, vec3(0.0));\n            velocity = sign(velocity) * (absVel - excess * effectiveDampen);\n        #else\n            float limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConst;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConst, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = evaluateParticleCurve(renderer_LVLSpeedMaxCurve, normalizedAge);\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    float minLimitSpeed = evaluateParticleCurve(renderer_LVLSpeedMinCurve, normalizedAge);\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            float speed = length(velocity);\n            if (speed > limitSpeed && speed > 0.0) {\n                float excess = speed - limitSpeed;\n                velocity = velocity * ((speed - excess * effectiveDampen) / speed);\n            }\n        #endif\n        return velocity;\n    }\n\n#endif\n"; // eslint-disable-line
 
 var particle_feedback_simulation = "// Transform Feedback update shader for particle simulation.\n// Update order: VOL/FOL → Dampen → Drag → Position.\n// Runs once per particle per frame (no rasterization).\n\n// Previous frame TF data\nattribute vec3 a_FeedbackPosition;\nattribute vec3 a_FeedbackVelocity;\n\n// Per-particle instance data\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec3 a_StartSize;\nattribute float a_StartSpeed;\nattribute vec4 a_Random0;\nattribute vec4 a_Random1;\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\nattribute vec4 a_Random2;\n\n// Uniforms\nuniform float renderer_CurrentTime;\nuniform float renderer_DeltaTime;\nuniform vec3 renderer_Gravity;\nuniform vec2 renderer_LVLDragConstant;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform int renderer_SimulationSpace;\n\n// TF outputs\nvarying vec3 v_FeedbackPosition;\nvarying vec3 v_FeedbackVelocity;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <limit_velocity_over_lifetime_module>\n\n// Get VOL instantaneous velocity at normalizedAge\nvec3 getVOLVelocity(float normalizedAge) {\n    vec3 vel = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        #ifdef RENDERER_VOL_CONSTANT_MODE\n            vel = renderer_VOLMaxConst;\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vel = mix(renderer_VOLMinConst, vel, a_Random1.yzw);\n            #endif\n        #endif\n        #ifdef RENDERER_VOL_CURVE_MODE\n            vel = vec3(\n                evaluateParticleCurve(renderer_VOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vec3 minVel = vec3(\n                    evaluateParticleCurve(renderer_VOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientZ, normalizedAge)\n                );\n                vel = mix(minVel, vel, a_Random1.yzw);\n            #endif\n        #endif\n    #endif\n    return vel;\n}\n\n// Get FOL instantaneous acceleration at normalizedAge\nvec3 getFOLAcceleration(float normalizedAge) {\n    vec3 acc = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        #ifdef RENDERER_FOL_CONSTANT_MODE\n            acc = renderer_FOLMaxConst;\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                acc = mix(renderer_FOLMinConst, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        #ifdef RENDERER_FOL_CURVE_MODE\n            acc = vec3(\n                evaluateParticleCurve(renderer_FOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minAcc = vec3(\n                    evaluateParticleCurve(renderer_FOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientZ, normalizedAge)\n                );\n                acc = mix(minAcc, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n    #endif\n    return acc;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float lifetime = a_ShapePositionStartLifeTime.w;\n    float normalizedAge = age / lifetime;\n    // Clamp to age on the first TF pass: particles emitted mid-frame have age < dt,\n    // so using the full dt would over-integrate. Subsequent passes are unaffected (age >= dt).\n    float dt = min(renderer_DeltaTime, age);\n\n    // normalizedAge < 0.0: stale TF slot whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 1.0 || normalizedAge < 0.0) {\n        v_FeedbackPosition = a_FeedbackPosition;\n        v_FeedbackVelocity = a_FeedbackVelocity;\n        gl_Position = vec4(0.0);\n        return;\n    }\n\n    vec4 worldRotation;\n    if (renderer_SimulationSpace == 0) {\n        worldRotation = renderer_WorldRotation;\n    } else {\n        worldRotation = a_SimulationWorldRotation;\n    }\n    vec4 invWorldRotation = quaternionConjugate(worldRotation);\n\n    // Read previous frame state (initialized by CPU on particle birth)\n    vec3 localVelocity = a_FeedbackVelocity;\n\n    // =====================================================\n    // Step 1: Apply velocity module deltas (VOL + FOL + Gravity)\n    // =====================================================\n\n    // Gravity (world space)\n    vec3 gravityDelta = renderer_Gravity * a_Random0.x * dt;\n\n    // VOL instantaneous velocity (animated velocity, not persisted)\n    vec3 volLocal = vec3(0.0);\n    vec3 volWorld = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 vol = getVOLVelocity(normalizedAge);\n        if (renderer_VOLSpace == 0) {\n            volLocal = vol;\n        } else {\n            volWorld = vol;\n        }\n    #endif\n\n    // FOL acceleration → velocity delta (always persisted, like gravity)\n    vec3 folDeltaLocal = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 folAcc = getFOLAcceleration(normalizedAge);\n        vec3 folVelDelta = folAcc * dt;\n        if (renderer_FOLSpace == 0) {\n            folDeltaLocal = folVelDelta;\n        } else {\n            // World FOL: convert to local and persist, same as gravity\n            folDeltaLocal = rotationByQuaternions(folVelDelta, invWorldRotation);\n        }\n    #endif\n\n    // Gravity and FOL contribute to base velocity (persisted, subject to dampen/drag).\n    vec3 gravityLocal = rotationByQuaternions(gravityDelta, invWorldRotation);\n    localVelocity += folDeltaLocal + gravityLocal;\n\n    // =====================================================\n    // Step 2 & 3: Dampen (Limit Velocity) + Drag\n    // VOL must be projected into the LVL target space so that\n    // limit/drag see the full velocity regardless of VOL.space vs LVL.space.\n    // =====================================================\n    #ifdef RENDERER_LVL_MODULE_ENABLED\n        // Precompute VOL in both spaces\n        vec3 volAsLocal = volLocal + rotationByQuaternions(volWorld, invWorldRotation);\n        vec3 volAsWorld = rotationByQuaternions(volLocal, worldRotation) + volWorld;\n\n        float limitRand = a_Random2.w;\n        float dampen = renderer_LVLDampen;\n        // Frame-rate independent dampen (30fps as reference)\n        float effectiveDampen = 1.0 - pow(1.0 - dampen, dt * 30.0);\n\n        if (renderer_LVLSpace == 0) {\n            // Local space: total = base + all VOL projected to local\n            vec3 totalLocal = localVelocity + volAsLocal;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalLocal, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = dampenedTotal - volAsLocal;\n        } else {\n            // World space: total = rotated base + all VOL projected to world\n            vec3 totalWorld = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalWorld, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = rotationByQuaternions(dampenedTotal - volAsWorld, invWorldRotation);\n        }\n\n        // Drag: same space as dampen\n        {\n            float dragCoeff = evaluateLVLDrag(normalizedAge, a_Random2.w);\n            if (dragCoeff > 0.0) {\n                vec3 totalVel;\n                if (renderer_LVLSpace == 0) {\n                    totalVel = localVelocity + volAsLocal;\n                } else {\n                    totalVel = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n                }\n                float velMagSqr = dot(totalVel, totalVel);\n                float velMag = sqrt(velMagSqr);\n\n                float drag = dragCoeff;\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_SIZE\n                    float maxDim = max(a_StartSize.x, max(a_StartSize.y, a_StartSize.z));\n                    float radius = maxDim * 0.5;\n                    drag *= 3.14159265 * radius * radius;\n                #endif\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_VELOCITY\n                    drag *= velMagSqr;\n                #endif\n\n                if (velMag > 0.0) {\n                    float newVelMag = max(0.0, velMag - drag * dt);\n                    vec3 draggedTotal = totalVel * (newVelMag / velMag);\n                    if (renderer_LVLSpace == 0) {\n                        localVelocity = draggedTotal - volAsLocal;\n                    } else {\n                        localVelocity = rotationByQuaternions(draggedTotal - volAsWorld, invWorldRotation);\n                    }\n                }\n            }\n        }\n    #endif\n\n    // =====================================================\n    // Step 4: Integrate position in simulation space\n    // Local mode: position in local space, velocity rotated to local\n    // World mode: position in world space, velocity rotated to world\n    // =====================================================\n    // FOL is now fully in localVelocity (both local and world-space FOL).\n    // Only VOL overlay needs to be added here.\n    vec3 totalVelocity;\n    if (renderer_SimulationSpace == 0) {\n      // Local: integrate in local space\n      totalVelocity = localVelocity + volLocal\n        + rotationByQuaternions(volWorld, invWorldRotation);\n    } else {\n      // World: integrate in world space\n      totalVelocity = rotationByQuaternions(localVelocity + volLocal, worldRotation) + volWorld;\n    }\n    vec3 position = a_FeedbackPosition + totalVelocity * dt;\n\n    v_FeedbackPosition = position;\n    v_FeedbackVelocity = localVelocity;\n    gl_Position = vec4(0.0);\n}\n"; // eslint-disable-line
 
@@ -34966,10 +34966,10 @@ __decorate([
     _inherits(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 = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._speedRand = new Rand(0, ParticleRandomSubSeeds.LimitVelocityOverLifetime), _this._speedMinConstantVec = new Vector3(), _this._speedMaxConstantVec = new Vector3(), _this._dragConstantVec = new Vector2(), _this._separateAxes = false, _this._dampen = 0, _this._multiplyDragByParticleSize = false, _this._multiplyDragByParticleVelocity = false, _this._space = ParticleSimulationSpace.Local;
+        _this.speedX = new ParticleCompositeCurve(1);
+        _this.speedY = new ParticleCompositeCurve(1);
+        _this.speedZ = new ParticleCompositeCurve(1);
         _this.drag = new ParticleCompositeCurve(0);
         return _this;
     }
@@ -34981,19 +34981,19 @@ __decorate([
     };
     /**
    * @internal
-   */ _proto._isLimitRandomMode = function _isLimitRandomMode() {
+   */ _proto._isSpeedRandomMode = function _isSpeedRandomMode() {
         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._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves) && (this._speedY.mode === ParticleCurveMode.TwoConstants || this._speedY.mode === ParticleCurveMode.TwoCurves) && (this._speedZ.mode === ParticleCurveMode.TwoConstants || this._speedZ.mode === ParticleCurveMode.TwoCurves);
         }
-        return this._limitX.mode === ParticleCurveMode.TwoConstants || this._limitX.mode === ParticleCurveMode.TwoCurves;
+        return this._speedX.mode === ParticleCurveMode.TwoConstants || this._speedX.mode === ParticleCurveMode.TwoCurves;
     };
     /**
    * @internal
    */ _proto._updateShaderData = function _updateShaderData(shaderData) {
         var enabledModuleMacro = null;
         var separateAxesMacro = null;
-        var limitModeMacro = null;
-        var limitRandomMacro = null;
+        var speedModeMacro = null;
+        var speedRandomMacro = null;
         var dragCurveMacro = null;
         var dragRandomMacro = null;
         var dragSizeMacro = null;
@@ -35004,16 +35004,16 @@ __decorate([
             shaderData.setFloat(LimitVelocityOverLifetimeModule._dampenProperty, this._dampen);
             // Space
             shaderData.setInt(LimitVelocityOverLifetimeModule._spaceProperty, this._space);
-            // Limit
+            // Limit speed
             if (this._separateAxes) {
                 separateAxesMacro = LimitVelocityOverLifetimeModule._separateAxesMacro;
-                var result = this._uploadSeparateAxisLimits(shaderData);
-                limitModeMacro = result.modeMacro;
-                limitRandomMacro = result.randomMacro;
+                var result = this._uploadSeparateAxisSpeeds(shaderData);
+                speedModeMacro = result.modeMacro;
+                speedRandomMacro = result.randomMacro;
             } else {
-                var result1 = this._uploadScalarLimit(shaderData);
-                limitModeMacro = result1.modeMacro;
-                limitRandomMacro = result1.randomMacro;
+                var result1 = this._uploadScalarSpeed(shaderData);
+                speedModeMacro = result1.modeMacro;
+                speedRandomMacro = result1.randomMacro;
             }
             // Drag
             var dragResult = this._uploadDrag(shaderData);
@@ -35029,8 +35029,8 @@ __decorate([
         }
         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._speedModeMacro = this._enableMacro(shaderData, this._speedModeMacro, speedModeMacro);
+        this._speedRandomMacro = this._enableMacro(shaderData, this._speedRandomMacro, speedRandomMacro);
         this._dragCurveCachedMacro = this._enableMacro(shaderData, this._dragCurveCachedMacro, dragCurveMacro);
         this._dragRandomCachedMacro = this._enableMacro(shaderData, this._dragRandomCachedMacro, dragRandomMacro);
         this._dragSizeMacro = this._enableMacro(shaderData, this._dragSizeMacro, dragSizeMacro);
@@ -35039,26 +35039,26 @@ __decorate([
     /**
    * @internal
    */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
-        this._limitRand.reset(seed, ParticleRandomSubSeeds.LimitVelocityOverLifetime);
+        this._speedRand.reset(seed, ParticleRandomSubSeeds.LimitVelocityOverLifetime);
     };
-    _proto._uploadScalarLimit = function _uploadScalarLimit(shaderData) {
-        var limitX = this._limitX;
+    _proto._uploadScalarSpeed = function _uploadScalarSpeed(shaderData) {
+        var speedX = this._speedX;
         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;
+        var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves;
+        if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve) {
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMaxCurveProperty, speedX.curveMax._getTypeArray());
+            modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
             if (isRandomCurveMode) {
-                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitMinCurveProperty, limitX.curveMin._getTypeArray());
-                randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedMinCurveProperty, speedX.curveMin._getTypeArray());
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
             }
         } else {
-            shaderData.setFloat(LimitVelocityOverLifetimeModule._limitMaxConstProperty, limitX.constantMax);
-            modeMacro = LimitVelocityOverLifetimeModule._limitConstantModeMacro;
-            if (limitX.mode === ParticleCurveMode.TwoConstants) {
-                shaderData.setFloat(LimitVelocityOverLifetimeModule._limitMinConstProperty, limitX.constantMin);
-                randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+            shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMaxConstProperty, speedX.constantMax);
+            modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
+            if (speedX.mode === ParticleCurveMode.TwoConstants) {
+                shaderData.setFloat(LimitVelocityOverLifetimeModule._speedMinConstProperty, speedX.constantMin);
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
             }
         }
         return {
@@ -35066,34 +35066,34 @@ __decorate([
             randomMacro: randomMacro
         };
     };
-    _proto._uploadSeparateAxisLimits = function _uploadSeparateAxisLimits(shaderData) {
-        var limitX = this._limitX;
-        var limitY = this._limitY;
-        var limitZ = this._limitZ;
+    _proto._uploadSeparateAxisSpeeds = function _uploadSeparateAxisSpeeds(shaderData) {
+        var speedX = this._speedX;
+        var speedY = this._speedY;
+        var speedZ = this._speedZ;
         var modeMacro = null;
         var randomMacro = null;
-        var isRandomCurveMode = 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;
+        var isRandomCurveMode = speedX.mode === ParticleCurveMode.TwoCurves && speedY.mode === ParticleCurveMode.TwoCurves && speedZ.mode === ParticleCurveMode.TwoCurves;
+        if (isRandomCurveMode || speedX.mode === ParticleCurveMode.Curve && speedY.mode === ParticleCurveMode.Curve && speedZ.mode === ParticleCurveMode.Curve) {
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMaxCurveProperty, speedX.curveMax._getTypeArray());
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMaxCurveProperty, speedY.curveMax._getTypeArray());
+            shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMaxCurveProperty, speedZ.curveMax._getTypeArray());
+            modeMacro = LimitVelocityOverLifetimeModule._speedCurveModeMacro;
             if (isRandomCurveMode) {
-                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitXMinCurveProperty, limitX.curveMin._getTypeArray());
-                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitYMinCurveProperty, limitY.curveMin._getTypeArray());
-                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._limitZMinCurveProperty, limitZ.curveMin._getTypeArray());
-                randomMacro = LimitVelocityOverLifetimeModule._limitIsRandomMacro;
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedXMinCurveProperty, speedX.curveMin._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedYMinCurveProperty, speedY.curveMin._getTypeArray());
+                shaderData.setFloatArray(LimitVelocityOverLifetimeModule._speedZMinCurveProperty, speedZ.curveMin._getTypeArray());
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
             }
         } else {
-            var constantMax = this._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;
+            var constantMax = this._speedMaxConstantVec;
+            constantMax.set(speedX.constantMax, speedY.constantMax, speedZ.constantMax);
+            shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMaxConstVecProperty, constantMax);
+            modeMacro = LimitVelocityOverLifetimeModule._speedConstantModeMacro;
+            if (speedX.mode === ParticleCurveMode.TwoConstants && speedY.mode === ParticleCurveMode.TwoConstants && speedZ.mode === ParticleCurveMode.TwoConstants) {
+                var constantMin = this._speedMinConstantVec;
+                constantMin.set(speedX.constantMin, speedY.constantMin, speedZ.constantMin);
+                shaderData.setVector3(LimitVelocityOverLifetimeModule._speedMinConstVecProperty, constantMin);
+                randomMacro = LimitVelocityOverLifetimeModule._speedIsRandomMacro;
             }
         }
         return {
@@ -35143,57 +35143,57 @@ __decorate([
             }
         },
         {
-            key: "limit",
+            key: "speed",
             get: /**
    * Speed limit when separateAxes is false.
    */ function get() {
-                return this._limitX;
+                return this._speedX;
             },
             set: function set(value) {
-                this.limitX = value;
+                this.speedX = value;
             }
         },
         {
-            key: "limitX",
+            key: "speedX",
             get: /**
    * Speed limit for the x-axis (or overall limit when separateAxes is false).
    */ function get() {
-                return this._limitX;
+                return this._speedX;
             },
             set: function set(value) {
-                var lastValue = this._limitX;
+                var lastValue = this._speedX;
                 if (value !== lastValue) {
-                    this._limitX = value;
+                    this._speedX = value;
                     this._onCompositeCurveChange(lastValue, value);
                 }
             }
         },
         {
-            key: "limitY",
+            key: "speedY",
             get: /**
    * Speed limit for the y-axis.
    */ function get() {
-                return this._limitY;
+                return this._speedY;
             },
             set: function set(value) {
-                var lastValue = this._limitY;
+                var lastValue = this._speedY;
                 if (value !== lastValue) {
-                    this._limitY = value;
+                    this._speedY = value;
                     this._onCompositeCurveChange(lastValue, value);
                 }
             }
         },
         {
-            key: "limitZ",
+            key: "speedZ",
             get: /**
    * Speed limit for the z-axis.
    */ function get() {
-                return this._limitZ;
+                return this._speedZ;
             },
             set: function set(value) {
-                var lastValue = this._limitZ;
+                var lastValue = this._speedZ;
                 if (value !== lastValue) {
-                    this._limitZ = value;
+                    this._speedZ = value;
                     this._onCompositeCurveChange(lastValue, value);
                 }
             }
@@ -35261,6 +35261,7 @@ __decorate([
             key: "space",
             get: /**
    * Specifies if the velocity limits are in local space or world space.
+   * @remarks Only takes effect when 'separateAxes' is enabled.
    */ function get() {
                 return this._space;
             },
@@ -35295,25 +35296,25 @@ __decorate([
 }(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._speedConstantModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CONSTANT_MODE");
+LimitVelocityOverLifetimeModule._speedCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_CURVE_MODE");
+LimitVelocityOverLifetimeModule._speedIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_SPEED_IS_RANDOM_TWO");
 LimitVelocityOverLifetimeModule._dragCurveModeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_CURVE_MODE");
 LimitVelocityOverLifetimeModule._dragIsRandomMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_IS_RANDOM_TWO");
 LimitVelocityOverLifetimeModule._multiplyDragBySizeMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_SIZE");
 LimitVelocityOverLifetimeModule._multiplyDragByVelocityMacro = ShaderMacro.getByName("RENDERER_LVL_DRAG_MULTIPLY_VELOCITY");
-LimitVelocityOverLifetimeModule._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._speedMaxConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConst");
+LimitVelocityOverLifetimeModule._speedMinConstProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConst");
+LimitVelocityOverLifetimeModule._speedMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxCurve");
+LimitVelocityOverLifetimeModule._speedMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedMinCurve");
+LimitVelocityOverLifetimeModule._speedMaxConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMaxConstVector");
+LimitVelocityOverLifetimeModule._speedMinConstVecProperty = ShaderProperty.getByName("renderer_LVLSpeedMinConstVector");
+LimitVelocityOverLifetimeModule._speedXMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMaxCurve");
+LimitVelocityOverLifetimeModule._speedXMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedXMinCurve");
+LimitVelocityOverLifetimeModule._speedYMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMaxCurve");
+LimitVelocityOverLifetimeModule._speedYMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedYMinCurve");
+LimitVelocityOverLifetimeModule._speedZMaxCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMaxCurve");
+LimitVelocityOverLifetimeModule._speedZMinCurveProperty = ShaderProperty.getByName("renderer_LVLSpeedZMinCurve");
 LimitVelocityOverLifetimeModule._dampenProperty = ShaderProperty.getByName("renderer_LVLDampen");
 LimitVelocityOverLifetimeModule._dragConstantProperty = ShaderProperty.getByName("renderer_LVLDragConstant");
 LimitVelocityOverLifetimeModule._dragMaxCurveProperty = ShaderProperty.getByName("renderer_LVLDragMaxCurve");
@@ -35321,13 +35322,13 @@ LimitVelocityOverLifetimeModule._dragMinCurveProperty = ShaderProperty.getByName
 LimitVelocityOverLifetimeModule._spaceProperty = ShaderProperty.getByName("renderer_LVLSpace");
 __decorate([
     ignoreClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitRand", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedRand", void 0);
 __decorate([
     ignoreClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitMinConstantVec", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedMinConstantVec", void 0);
 __decorate([
     ignoreClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitMaxConstantVec", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedMaxConstantVec", void 0);
 __decorate([
     ignoreClone
 ], LimitVelocityOverLifetimeModule.prototype, "_dragConstantVec", void 0);
@@ -35339,10 +35340,10 @@ __decorate([
 ], LimitVelocityOverLifetimeModule.prototype, "_separateAxesCachedMacro", void 0);
 __decorate([
     ignoreClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitModeMacro", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedModeMacro", void 0);
 __decorate([
     ignoreClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitRandomMacro", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedRandomMacro", void 0);
 __decorate([
     ignoreClone
 ], LimitVelocityOverLifetimeModule.prototype, "_dragCurveCachedMacro", void 0);
@@ -35357,13 +35358,13 @@ __decorate([
 ], LimitVelocityOverLifetimeModule.prototype, "_dragVelocityMacro", void 0);
 __decorate([
     deepClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitX", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedX", void 0);
 __decorate([
     deepClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitY", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedY", void 0);
 __decorate([
     deepClone
-], LimitVelocityOverLifetimeModule.prototype, "_limitZ", void 0);
+], LimitVelocityOverLifetimeModule.prototype, "_speedZ", void 0);
 __decorate([
     deepClone
 ], LimitVelocityOverLifetimeModule.prototype, "_drag", void 0);
@@ -37060,8 +37061,8 @@ __decorate([
             instanceVertices[offset + 40] = rand1.random();
         }
         var limitVelocityOverLifetime = this.limitVelocityOverLifetime;
-        if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isLimitRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
-            instanceVertices[offset + 41] = limitVelocityOverLifetime._limitRand.random();
+        if (limitVelocityOverLifetime.enabled && (limitVelocityOverLifetime._isSpeedRandomMode() || limitVelocityOverLifetime._isDragRandomMode())) {
+            instanceVertices[offset + 41] = limitVelocityOverLifetime._speedRand.random();
         }
         // Initialize feedback buffer for this particle
         if (this._useTransformFeedback) {