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

package/dist/browser.js

@@ -9887,7 +9887,7 @@
     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    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
     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
@@ -17946,118 +17946,13 @@
             this._fixedTimeStep = 1 / 60;
             this._colliders = new DisorderedArray();
             this._gravity = new Vector3(0, -9.81, 0);
-            this._onContactEnter = function(nativeCollision) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape0Id = nativeCollision.shape0Id, shape1Id = nativeCollision.shape1Id;
-                var shape1 = physicalObjectsMap[shape0Id];
-                var shape2 = physicalObjectsMap[shape1Id];
-                var collision = PhysicsScene._collision;
-                collision._nativeCollision = nativeCollision;
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape2;
-                    element.onCollisionEnter(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape1;
-                    element.onCollisionEnter(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
-            this._onContactExit = function(nativeCollision) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape0Id = nativeCollision.shape0Id, shape1Id = nativeCollision.shape1Id;
-                var shape1 = physicalObjectsMap[shape0Id];
-                var shape2 = physicalObjectsMap[shape1Id];
-                var collision = PhysicsScene._collision;
-                collision._nativeCollision = nativeCollision;
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape2;
-                    element.onCollisionExit(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape1;
-                    element.onCollisionExit(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
-            this._onContactStay = function(nativeCollision) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape0Id = nativeCollision.shape0Id, shape1Id = nativeCollision.shape1Id;
-                var shape1 = physicalObjectsMap[shape0Id];
-                var shape2 = physicalObjectsMap[shape1Id];
-                var collision = PhysicsScene._collision;
-                collision._nativeCollision = nativeCollision;
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape2;
-                    element.onCollisionStay(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    collision.shape = shape1;
-                    element.onCollisionStay(collision);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
-            this._onTriggerEnter = function(obj1, obj2) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape1 = physicalObjectsMap[obj1];
-                var shape2 = physicalObjectsMap[obj2];
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerEnter(shape2);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerEnter(shape1);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
-            this._onTriggerExit = function(obj1, obj2) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape1 = physicalObjectsMap[obj1];
-                var shape2 = physicalObjectsMap[obj2];
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerExit(shape2);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerExit(shape1);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
-            this._onTriggerStay = function(obj1, obj2) {
-                var physicalObjectsMap = Engine._physicalObjectsMap;
-                var shape1 = physicalObjectsMap[obj1];
-                var shape2 = physicalObjectsMap[obj2];
-                shape1.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerStay(shape2);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-                shape2.collider.entity._scripts.forEach(function(element) {
-                    element.onTriggerStay(shape1);
-                }, function(element, index) {
-                    element._entityScriptsIndex = index;
-                });
-            };
             this._scene = scene;
             this._setGravity = this._setGravity.bind(this);
             //@ts-ignore
             this._gravity._onValueChanged = this._setGravity;
             var engine = scene.engine;
             if (engine._physicsInitialized) {
-                this._nativePhysicsScene = Engine._nativePhysics.createPhysicsScene(engine._nativePhysicsManager, this._onContactEnter, this._onContactExit, this._onContactStay, this._onTriggerEnter, this._onTriggerExit, this._onTriggerStay);
+                this._nativePhysicsScene = Engine._nativePhysics.createPhysicsScene(engine._nativePhysicsManager);
             }
         }
         var _proto = PhysicsScene.prototype;
@@ -18269,6 +18164,7 @@
                 this._callColliderOnUpdate();
                 nativePhysicsManager.update(fixedTimeStep);
                 this._callColliderOnLateUpdate();
+                this._dispatchEvents(nativePhysicsManager.updateEvents());
             }
         };
         /**
@@ -18332,7 +18228,9 @@
         /**
        * @internal
        */ _proto._gc = function _gc() {
+            var _this__nativePhysicsScene;
             this._colliders.garbageCollection();
+            (_this__nativePhysicsScene = this._nativePhysicsScene) == null ? void 0 : _this__nativePhysicsScene.gc();
         };
         /**
        * @internal
@@ -18340,6 +18238,92 @@
             var _this__nativePhysicsScene;
             (_this__nativePhysicsScene = this._nativePhysicsScene) == null ? void 0 : _this__nativePhysicsScene.destroy();
         };
+        _proto._dispatchEvents = function _dispatchEvents(events) {
+            var _loop = function _loop(i, n) {
+                var _shape1_collider, _shape2_collider;
+                var event = contactEvents[i];
+                var shape1 = physicalObjectsMap[event.shape0Id];
+                var shape2 = physicalObjectsMap[event.shape1Id];
+                // entity.destroy() is deferred, so shapes/colliders stay valid through the dispatch loop
+                // This guard covers synchronous removeShape()/clearShapes() which sets shape._collider = null
+                if (!(shape1 == null ? void 0 : (_shape1_collider = shape1.collider) == null ? void 0 : _shape1_collider.entity) || !(shape2 == null ? void 0 : (_shape2_collider = shape2.collider) == null ? void 0 : _shape2_collider.entity)) return "continue";
+                collision._nativeCollision = event;
+                switch(event.state){
+                    case 0:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape2;
+                            element.onCollisionEnter(collision);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape1;
+                            element.onCollisionEnter(collision);
+                        }, scriptIndexSetter);
+                        break;
+                    case 1:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape2;
+                            element.onCollisionStay(collision);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape1;
+                            element.onCollisionStay(collision);
+                        }, scriptIndexSetter);
+                        break;
+                    case 2:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape2;
+                            element.onCollisionExit(collision);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            collision.shape = shape1;
+                            element.onCollisionExit(collision);
+                        }, scriptIndexSetter);
+                        break;
+                }
+            }, _loop1 = function _loop1(i1, n1) {
+                var _shape1_collider, _shape2_collider;
+                var event = triggerEvents[i1];
+                var shape1 = physicalObjectsMap[event.index1];
+                var shape2 = physicalObjectsMap[event.index2];
+                // entity.destroy() is deferred, so shapes/colliders stay valid through the dispatch loop
+                // This guard covers synchronous removeShape()/clearShapes() which sets shape._collider = null
+                if (!(shape1 == null ? void 0 : (_shape1_collider = shape1.collider) == null ? void 0 : _shape1_collider.entity) || !(shape2 == null ? void 0 : (_shape2_collider = shape2.collider) == null ? void 0 : _shape2_collider.entity)) return "continue";
+                switch(event.dispatchState){
+                    case 0:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerEnter(shape2);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerEnter(shape1);
+                        }, scriptIndexSetter);
+                        break;
+                    case 1:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerStay(shape2);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerStay(shape1);
+                        }, scriptIndexSetter);
+                        break;
+                    case 2:
+                        shape1.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerExit(shape2);
+                        }, scriptIndexSetter);
+                        shape2.collider.entity._scripts.forEach(function(element) {
+                            element.onTriggerExit(shape1);
+                        }, scriptIndexSetter);
+                        break;
+                }
+            };
+            var physicalObjectsMap = Engine._physicalObjectsMap;
+            var collision = PhysicsScene._collision;
+            var scriptIndexSetter = PhysicsScene._scriptIndexSetter;
+            var contactEvents = events.contactEvents, contactEventCount = events.contactEventCount, triggerEvents = events.triggerEvents;
+            // Dispatch contact events
+            for(var i = 0, n = contactEventCount; i < n; i++)_loop(i);
+            // Dispatch trigger events
+            for(var i1 = 0, n1 = triggerEvents.length; i1 < n1; i1++)_loop1(i1);
+        };
         _proto._setGravity = function _setGravity() {
             this._nativePhysicsScene.setGravity(this._gravity);
         };
@@ -18399,6 +18383,9 @@
     }();
     PhysicsScene._collision = new Collision();
     PhysicsScene._identityQuaternion = new Quaternion(0, 0, 0, 1);
+    PhysicsScene._scriptIndexSetter = function(element, index) {
+        element._entityScriptsIndex = index;
+    };
     /**
      * A static collider component that will not move.
      * @remarks Mostly used for object which always stays at the same place and never moves around.
@@ -31832,6 +31819,11 @@
             this._textSubRenderElementPool.garbageCollection();
             this._renderElementPool.garbageCollection();
             this._renderContext.garbageCollection();
+            var scenes = this._sceneManager._scenes.getLoopArray();
+            for(var i = 0, n = scenes.length; i < n; i++){
+                var _scenes_i_physics, _scenes_i;
+                (_scenes_i = scenes[i]) == null ? void 0 : (_scenes_i_physics = _scenes_i.physics) == null ? void 0 : _scenes_i_physics._gc();
+            }
         };
         _create_class$2(Engine, [
             {
@@ -39590,10 +39582,10 @@
         _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 = 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;
         }
@@ -39605,19 +39597,19 @@
         };
         /**
        * @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;
@@ -39628,16 +39620,16 @@
                 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);
@@ -39653,8 +39645,8 @@
             }
             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);
@@ -39663,26 +39655,26 @@
         /**
        * @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 {
@@ -39690,34 +39682,34 @@
                 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 {
@@ -39767,57 +39759,57 @@
                 }
             },
             {
-                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);
                     }
                 }
@@ -39885,6 +39877,7 @@
                 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;
                 },
@@ -39919,25 +39912,25 @@
     }(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");
@@ -39945,13 +39938,13 @@
     LimitVelocityOverLifetimeModule._spaceProperty = ShaderProperty.getByName("renderer_LVLSpace");
     __decorate$1([
         ignoreClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitRand", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedRand", void 0);
     __decorate$1([
         ignoreClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitMinConstantVec", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedMinConstantVec", void 0);
     __decorate$1([
         ignoreClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitMaxConstantVec", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedMaxConstantVec", void 0);
     __decorate$1([
         ignoreClone
     ], LimitVelocityOverLifetimeModule.prototype, "_dragConstantVec", void 0);
@@ -39963,10 +39956,10 @@
     ], LimitVelocityOverLifetimeModule.prototype, "_separateAxesCachedMacro", void 0);
     __decorate$1([
         ignoreClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitModeMacro", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedModeMacro", void 0);
     __decorate$1([
         ignoreClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitRandomMacro", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedRandomMacro", void 0);
     __decorate$1([
         ignoreClone
     ], LimitVelocityOverLifetimeModule.prototype, "_dragCurveCachedMacro", void 0);
@@ -39981,13 +39974,13 @@
     ], LimitVelocityOverLifetimeModule.prototype, "_dragVelocityMacro", void 0);
     __decorate$1([
         deepClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitX", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedX", void 0);
     __decorate$1([
         deepClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitY", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedY", void 0);
     __decorate$1([
         deepClone
-    ], LimitVelocityOverLifetimeModule.prototype, "_limitZ", void 0);
+    ], LimitVelocityOverLifetimeModule.prototype, "_speedZ", void 0);
     __decorate$1([
         deepClone
     ], LimitVelocityOverLifetimeModule.prototype, "_drag", void 0);
@@ -41676,8 +41669,8 @@
                 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) {
@@ -45849,7 +45842,9 @@
         _proto._bindMainFBO = function _bindMainFBO() {
             var gl = this._gl;
             var isWebGL2 = this._isWebGL2;
-            /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount, width = _this__target.width, height = _this__target.height;
+            /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount;
+            _this__target.width;
+            _this__target.height;
             var drawBuffers = new Array(colorTextureCount);
             gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
             /** color render buffer */ for(var i = 0; i < colorTextureCount; i++){
@@ -45871,11 +45866,7 @@
                     gl.framebufferTexture2D(gl.FRAMEBUFFER, platformTexture._formatDetail.attachment, gl.TEXTURE_2D, platformTexture._glTexture, 0);
                 } else if (this._target.antiAliasing <= 1) {
                     var _GLTexture__getRenderBufferDepthFormatDetail = GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat = _GLTexture__getRenderBufferDepthFormatDetail.internalFormat, attachment1 = _GLTexture__getRenderBufferDepthFormatDetail.attachment;
-                    var depthRenderBuffer = gl.createRenderbuffer();
-                    this._depthRenderBuffer = depthRenderBuffer;
-                    gl.bindRenderbuffer(gl.RENDERBUFFER, depthRenderBuffer);
-                    gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);
-                    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment1, gl.RENDERBUFFER, depthRenderBuffer);
+                    this._depthRenderBuffer = this._createRenderBuffer(internalFormat, attachment1);
                 }
             }
             gl.bindFramebuffer(gl.FRAMEBUFFER, null);
@@ -45884,32 +45875,38 @@
         _proto._bindMSAAFBO = function _bindMSAAFBO() {
             var gl = this._gl;
             var isWebGL2 = this._isWebGL2;
-            var MSAADepthRenderBuffer = gl.createRenderbuffer();
-            /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount, antiAliasing = _this__target.antiAliasing, width = _this__target.width, height = _this__target.height;
+            /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount;
             this._blitDrawBuffers = new Array(colorTextureCount);
-            this._MSAADepthRenderBuffer = MSAADepthRenderBuffer;
             gl.bindFramebuffer(gl.FRAMEBUFFER, this._MSAAFrameBuffer);
             // prepare MRT+MSAA color RBOs
             for(var i = 0; i < colorTextureCount; i++){
-                var MSAAColorRenderBuffer = gl.createRenderbuffer();
-                this._MSAAColorRenderBuffers[i] = MSAAColorRenderBuffer;
                 this._blitDrawBuffers[i] = gl.NONE;
-                gl.bindRenderbuffer(gl.RENDERBUFFER, MSAAColorRenderBuffer);
-                gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, /** @ts-ignore */ this._target.getColorTexture(i)._platformTexture._formatDetail.internalFormat, width, height);
-                gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, MSAAColorRenderBuffer);
+                var internalFormat = /** @ts-ignore */ this._target.getColorTexture(i)._platformTexture._formatDetail.internalFormat;
+                this._MSAAColorRenderBuffers[i] = this._createRenderBuffer(internalFormat, gl.COLOR_ATTACHMENT0 + i);
             }
             gl.drawBuffers(this._oriDrawBuffers);
             // prepare MSAA depth RBO
             if (_depth !== null) {
-                var _ref = _instanceof1$1(_depth, Texture) ? /** @ts-ignore */ _depth._platformTexture._formatDetail : GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat = _ref.internalFormat, attachment = _ref.attachment;
-                gl.bindRenderbuffer(gl.RENDERBUFFER, MSAADepthRenderBuffer);
-                gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, internalFormat, width, height);
-                gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, MSAADepthRenderBuffer);
+                var _ref = _instanceof1$1(_depth, Texture) ? /** @ts-ignore */ _depth._platformTexture._formatDetail : GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat1 = _ref.internalFormat, attachment = _ref.attachment;
+                this._MSAADepthRenderBuffer = this._createRenderBuffer(internalFormat1, attachment);
             }
             this._checkFrameBuffer();
             gl.bindFramebuffer(gl.FRAMEBUFFER, null);
             gl.bindRenderbuffer(gl.RENDERBUFFER, null);
         };
+        _proto._createRenderBuffer = function _createRenderBuffer(internalFormat, attachment) {
+            var gl = this._gl;
+            var _this__target = this._target, width = _this__target.width, height = _this__target.height, antiAliasing = _this__target.antiAliasing;
+            var renderBuffer = gl.createRenderbuffer();
+            gl.bindRenderbuffer(gl.RENDERBUFFER, renderBuffer);
+            if (antiAliasing > 1) {
+                gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, internalFormat, width, height);
+            } else {
+                gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);
+            }
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, renderBuffer);
+            return renderBuffer;
+        };
         _proto._checkFrameBuffer = function _checkFrameBuffer() {
             var gl = this._gl;
             var e = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
@@ -54058,7 +54055,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.17";
+    var version = "2.0.0-alpha.19";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);