@galacean/engine-core 2.0.0-alpha.25 → 2.0.0-alpha.26

package/dist/main.js

@@ -1327,6 +1327,12 @@ SystemInfo._initialize();
             case TextureFormat.ETC2_RGB:
             case TextureFormat.ETC2_RGBA8:
             case TextureFormat.ASTC_4x4:
+            case TextureFormat.ASTC_5x5:
+            case TextureFormat.ASTC_6x6:
+            case TextureFormat.ASTC_8x8:
+            case TextureFormat.ASTC_10x10:
+            case TextureFormat.ASTC_12x12:
+            case TextureFormat.ETC2_RGBA5:
                 return true;
             default:
                 return false;
@@ -1865,7 +1871,7 @@ SystemInfo._initialize();
         _this = ReferResource.call(this, engine) || this, _this._charInfoMap = {}, _this._space = 1, _this._curX = 1, _this._curY = 1, _this._nextY = 1;
         _this.isGCIgnored = true;
         var format = engine._hardwareRenderer.isWebGL2 ? TextureFormat.R8 : TextureFormat.Alpha8;
-        var texture = new Texture2D(engine, 512, 512, format, false);
+        var texture = new Texture2D(engine, 512, 512, format, false, false);
         texture.filterMode = TextureFilterMode.Bilinear;
         texture.isGCIgnored = true;
         _this.texture = texture;
@@ -4918,7 +4924,9 @@ var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || def
 
 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 noise_module = "#ifdef RENDERER_NOISE_MODULE_ENABLED\n\n#include <noise_common>\n#include <noise_simplex_3D>\n\nuniform vec4 renderer_NoiseParams; // xyz = strength (constant mode only), w = frequency\nuniform vec4 renderer_NoiseOctaveParams; // x = scrollSpeed, y = octaveCount, z = octaveIntensityMultiplier, w = octaveFrequencyMultiplier\n\n#ifdef RENDERER_NOISE_STRENGTH_CURVE\n    uniform vec2 renderer_NoiseStrengthMaxCurveX[4];\n    #ifdef RENDERER_NOISE_IS_SEPARATE\n        uniform vec2 renderer_NoiseStrengthMaxCurveY[4];\n        uniform vec2 renderer_NoiseStrengthMaxCurveZ[4];\n    #endif\n    #ifdef RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO\n        uniform vec2 renderer_NoiseStrengthMinCurveX[4];\n        #ifdef RENDERER_NOISE_IS_SEPARATE\n            uniform vec2 renderer_NoiseStrengthMinCurveY[4];\n            uniform vec2 renderer_NoiseStrengthMinCurveZ[4];\n        #endif\n    #endif\n#else\n    #ifdef RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO\n        uniform vec3 renderer_NoiseStrengthMinConst;\n    #endif\n#endif\n\nvec3 sampleSimplexNoise3D(vec3 coord) {\n    float axisOffset = 100.0;\n    return vec3(\n        simplex(vec3(coord.z, coord.y, coord.x)),\n        simplex(vec3(coord.x + axisOffset, coord.z, coord.y)),\n        simplex(vec3(coord.y, coord.x + axisOffset, coord.z))\n    );\n}\n\nvec3 computeNoiseDisplacement(vec3 currentPosition, float normalizedAge) {\n    vec3 coord = currentPosition * renderer_NoiseParams.w\n               + vec3(renderer_CurrentTime * renderer_NoiseOctaveParams.x);\n\n    int octaveCount = int(renderer_NoiseOctaveParams.y);\n    float octaveIntensityMultiplier = renderer_NoiseOctaveParams.z;\n    float octaveFrequencyMultiplier = renderer_NoiseOctaveParams.w;\n\n    vec3 noiseValue = sampleSimplexNoise3D(coord);\n    float totalAmplitude = 1.0;\n\n    // Unrolled octave loop (GLSL ES 1.0 requires constant loop bounds)\n    if (octaveCount >= 2) {\n        float amplitude = octaveIntensityMultiplier;\n        totalAmplitude += amplitude;\n        noiseValue += amplitude * sampleSimplexNoise3D(coord * octaveFrequencyMultiplier);\n\n        if (octaveCount >= 3) {\n            amplitude *= octaveIntensityMultiplier;\n            totalAmplitude += amplitude;\n            noiseValue += amplitude * sampleSimplexNoise3D(coord * octaveFrequencyMultiplier * octaveFrequencyMultiplier);\n        }\n    }\n\n    // Evaluate strength (supports Constant, TwoConstants, Curve, TwoCurves).\n    vec3 strength;\n    #ifdef RENDERER_NOISE_STRENGTH_CURVE\n        float sx = evaluateParticleCurve(renderer_NoiseStrengthMaxCurveX, normalizedAge);\n        #ifdef RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO\n            sx = mix(evaluateParticleCurve(renderer_NoiseStrengthMinCurveX, normalizedAge), sx, a_Random0.z);\n        #endif\n        #ifdef RENDERER_NOISE_IS_SEPARATE\n            float sy = evaluateParticleCurve(renderer_NoiseStrengthMaxCurveY, normalizedAge);\n            float sz = evaluateParticleCurve(renderer_NoiseStrengthMaxCurveZ, normalizedAge);\n            #ifdef RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO\n                sy = mix(evaluateParticleCurve(renderer_NoiseStrengthMinCurveY, normalizedAge), sy, a_Random0.z);\n                sz = mix(evaluateParticleCurve(renderer_NoiseStrengthMinCurveZ, normalizedAge), sz, a_Random0.z);\n            #endif\n            strength = vec3(sx, sy, sz);\n        #else\n            strength = vec3(sx);\n        #endif\n    #else\n        strength = renderer_NoiseParams.xyz;\n        #ifdef RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO\n            strength = mix(renderer_NoiseStrengthMinConst, strength, a_Random0.z);\n        #endif\n    #endif\n\n    return (noiseValue / totalAmplitude) * strength;\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#include <noise_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    // VOL and Noise overlays are added here (not persisted).\n\n    vec3 totalVelocity;\n    if (renderer_SimulationSpace == 0) {\n      totalVelocity = localVelocity + volLocal + rotationByQuaternions(volWorld, invWorldRotation);\n    } else {\n      totalVelocity = rotationByQuaternions(localVelocity + volLocal, worldRotation) + volWorld;\n    }\n    #ifdef RENDERER_NOISE_MODULE_ENABLED\n        // Noise velocity overlay (not persisted)\n        // computeNoiseDisplacement returns noise * strength (position-scale)\n        // Dividing by lifetime converts to velocity so that integration over lifetime\n        // recovers the original displacement magnitude\n        // Use analytical base position (birth + initial velocity * age) instead of\n        // a_FeedbackPosition to avoid feedback loop: position → noise → velocity → position\n        vec3 noiseBasePos;\n        if (renderer_SimulationSpace == 0) {\n            noiseBasePos = a_ShapePositionStartLifeTime.xyz + a_DirectionTime.xyz * a_StartSpeed * age;\n        } else {\n            noiseBasePos = rotationByQuaternions(\n                a_ShapePositionStartLifeTime.xyz + a_DirectionTime.xyz * a_StartSpeed * age,\n                worldRotation) + a_SimulationWorldPosition;\n        }\n        totalVelocity += computeNoiseDisplacement(noiseBasePos, normalizedAge) / lifetime;\n    #endif\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
 
@@ -4939,6 +4947,7 @@ var ParticleShaderLib = {
     texture_sheet_animation_module: texture_sheet_animation_module,
     force_over_lifetime_module: force_over_lifetime_module,
     limit_velocity_over_lifetime_module: limit_velocity_over_lifetime_module,
+    noise_module: noise_module,
     particle_feedback_simulation: particle_feedback_simulation,
     sphere_billboard: sphere_billboard,
     stretched_billboard: stretched_billboard,
@@ -5787,26 +5796,492 @@ ShaderTagKey._nameMap = Object.create(null);
 }();
 ShaderProgram._counter = 0;
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/**
+ * Directive types for shader preprocessor instructions.
+ */ var ShaderPreprocessorDirective = /*#__PURE__*/ function(ShaderPreprocessorDirective) {
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Text"] = 0] = "Text";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfDef"] = 1] = "IfDef";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfNdef"] = 2] = "IfNdef";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfCmp"] = 3] = "IfCmp";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfExpr"] = 4] = "IfExpr";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Else"] = 5] = "Else";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Endif"] = 6] = "Endif";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Define"] = 7] = "Define";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["DefineVal"] = 8] = "DefineVal";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["DefineFunc"] = 9] = "DefineFunc";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Undef"] = 10] = "Undef";
+    return ShaderPreprocessorDirective;
+}({});
+
+/**
+ * @internal
+ */ var ShaderMacroProcessor = /*#__PURE__*/ function() {
+    function ShaderMacroProcessor() {}
+    /**
+   * Evaluate a flat instruction array with active macros.
+   * Macros are expanded immediately when text chunks are collected,
+   * using the current macro state at that point (conforming to GLSL/C99 §6.10 standard).
+   * @param instructions - Pre-parsed instruction array
+   * @param macros - Active runtime macros
+   * @returns Pure GLSL string with all conditionals resolved and macros expanded
+   */ ShaderMacroProcessor.evaluate = function evaluate(instructions, macros) {
+        var valueMacros = ShaderMacroProcessor._valueMacros;
+        var funcMacros = ShaderMacroProcessor._funcMacros;
+        var shaderChunks = ShaderMacroProcessor._shaderChunks;
+        valueMacros.clear();
+        funcMacros.clear();
+        shaderChunks.length = 0;
+        for(var _iterator = _create_for_of_iterator_helper_loose(macros), _step; !(_step = _iterator()).done;){
+            var _step_value = _step.value, name = _step_value[0], value = _step_value[1];
+            valueMacros.set(name, value);
+        }
+        ShaderMacroProcessor._macroFirstCharsDirty = true;
+        var index = 0;
+        var length = instructions.length;
+        while(index < length){
+            var instruction = instructions[index];
+            switch(instruction[0]){
+                case ShaderPreprocessorDirective.Text:
+                    // Immediately expand macros using current macro state (GLSL/C99 conformant)
+                    shaderChunks.push(ShaderMacroProcessor._expandChunk(instruction[1], valueMacros, funcMacros));
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.IfDef:
+                    {
+                        var name1 = instruction[1];
+                        index = valueMacros.has(name1) || funcMacros.has(name1) ? index + 1 : instruction[2];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfNdef:
+                    {
+                        var name2 = instruction[1];
+                        index = !valueMacros.has(name2) && !funcMacros.has(name2) ? index + 1 : instruction[2];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfCmp:
+                    {
+                        var name3 = instruction[1];
+                        var val = valueMacros.get(name3);
+                        var matched = val !== undefined && ShaderMacroProcessor._compareValues(Number(val) || 0, instruction[2], instruction[3]);
+                        index = matched ? index + 1 : instruction[4];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfExpr:
+                    index = ShaderMacroProcessor._evalCondition(instruction[1], valueMacros, funcMacros) ? index + 1 : instruction[2];
+                    break;
+                case ShaderPreprocessorDirective.Else:
+                    index = instruction[1];
+                    break;
+                case ShaderPreprocessorDirective.Endif:
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.Define:
+                    valueMacros.set(instruction[1], "");
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.DefineVal:
+                    valueMacros.set(instruction[1], instruction[2]);
+                    ShaderMacroProcessor._macroFirstCharsDirty = true;
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.DefineFunc:
+                    funcMacros.set(instruction[1], {
+                        params: instruction[2],
+                        body: instruction[3]
+                    });
+                    ShaderMacroProcessor._macroFirstCharsDirty = true;
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.Undef:
+                    valueMacros.delete(instruction[1]);
+                    funcMacros.delete(instruction[1]);
+                    index++;
+                    break;
+                default:
+                    index++;
+                    break;
+            }
+        }
+        return ShaderMacroProcessor._concatChunks(shaderChunks);
+    };
+    /**
+   * Expand macros in a single text chunk using the current macro state.
+   * Returns the chunk as-is if no expandable macros exist.
+   */ ShaderMacroProcessor._expandChunk = function _expandChunk(chunk, valueMacros, funcMacros) {
+        // Fast path: no expandable macros at this point
+        if (funcMacros.size === 0) {
+            var hasExpandable = false;
+            for(var _iterator = _create_for_of_iterator_helper_loose(valueMacros), _step; !(_step = _iterator()).done;){
+                var _step_value = _step.value, val = _step_value[1];
+                if (val !== "") {
+                    hasExpandable = true;
+                    break;
+                }
+            }
+            if (!hasExpandable) return chunk;
+        }
+        // Rebuild first-char filter if macros changed
+        if (ShaderMacroProcessor._macroFirstCharsDirty) {
+            var macroFirstChars = ShaderMacroProcessor._macroFirstChars;
+            macroFirstChars.clear();
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(valueMacros.keys()), _step1; !(_step1 = _iterator1()).done;){
+                var name = _step1.value;
+                macroFirstChars.add(name.charCodeAt(0));
+            }
+            for(var _iterator2 = _create_for_of_iterator_helper_loose(funcMacros.keys()), _step2; !(_step2 = _iterator2()).done;){
+                var name1 = _step2.value;
+                macroFirstChars.add(name1.charCodeAt(0));
+            }
+            ShaderMacroProcessor._macroFirstCharsDirty = false;
+        }
+        var macroFirstChars1 = ShaderMacroProcessor._macroFirstChars;
+        var expandedNames = ShaderMacroProcessor._expandedNames;
+        var out = ShaderMacroProcessor._out;
+        out.length = 0;
+        var len = chunk.length;
+        var i = 0;
+        while(i < len){
+            var cc = chunk.charCodeAt(i);
+            if (ShaderMacroProcessor._isIdentifierStart(cc)) {
+                var start = i;
+                i++;
+                while(i < len && ShaderMacroProcessor._isIdentifierPart(chunk.charCodeAt(i)))i++;
+                // Fast path: first char not in any macro name
+                if (!macroFirstChars1.has(chunk.charCodeAt(start))) {
+                    out.push(chunk.substring(start, i));
+                    continue;
+                }
+                var name2 = chunk.substring(start, i);
+                // Try function macro
+                var func = funcMacros.get(name2);
+                if (func) {
+                    var lookAhead = i;
+                    while(lookAhead < len && (chunk.charCodeAt(lookAhead) === 32 /* space */  || chunk.charCodeAt(lookAhead) === 9))lookAhead++;
+                    if (lookAhead < len && chunk.charCodeAt(lookAhead) === 40 /* '(' */ ) {
+                        var args = ShaderMacroProcessor._parseFuncArgs(chunk, lookAhead);
+                        if (args) {
+                            i = args.end;
+                            var expanded = ShaderMacroProcessor._expandFuncBody(func, args.values);
+                            expandedNames.clear();
+                            expandedNames.add(name2);
+                            out.push(ShaderMacroProcessor._recursiveExpandMacro(expanded, valueMacros, funcMacros, expandedNames));
+                            continue;
+                        }
+                    }
+                }
+                // Try value macro
+                var val1 = valueMacros.get(name2);
+                if (val1 !== undefined && val1 !== "") {
+                    expandedNames.clear();
+                    expandedNames.add(name2);
+                    out.push(ShaderMacroProcessor._recursiveExpandMacro(val1, valueMacros, funcMacros, expandedNames));
+                    continue;
+                }
+                out.push(name2);
+                continue;
+            }
+            // Batch collect non-identifier characters
+            var batchStart = i;
+            while(i < len && !ShaderMacroProcessor._isIdentifierStart(chunk.charCodeAt(i)))i++;
+            out.push(chunk.substring(batchStart, i));
+        }
+        return out.join("");
+    };
+    /**
+   * Recursively expand macro substitution results until no more macros remain.
+   * @param macroExpansion - Intermediate text from a macro substitution that may contain further macro references
+   * @param valueMacros - Current value macro definitions
+   * @param funcMacros - Current function macro definitions
+   * @param expandedNames - Macro names already on the expansion chain, prevents circular references (C99 §6.10.3.4)
+   */ ShaderMacroProcessor._recursiveExpandMacro = function _recursiveExpandMacro(macroExpansion, valueMacros, funcMacros, expandedNames) {
+        if (macroExpansion.length === 0) return macroExpansion;
+        var len = macroExpansion.length;
+        var out = [];
+        var i = 0;
+        while(i < len){
+            var cc = macroExpansion.charCodeAt(i);
+            if (ShaderMacroProcessor._isIdentifierStart(cc)) {
+                var start = i;
+                i++;
+                while(i < len && ShaderMacroProcessor._isIdentifierPart(macroExpansion.charCodeAt(i)))i++;
+                var name = macroExpansion.substring(start, i);
+                // Skip already-expanded names (circular reference prevention)
+                // Skip GL_ prefixed names (reserved GLSL built-ins, charCodes: G=71, L=76, _=95)
+                if (expandedNames.has(name) || name.charCodeAt(0) === 71 && name.charCodeAt(1) === 76 && name.charCodeAt(2) === 95) {
+                    out.push(name);
+                    continue;
+                }
+                var func = funcMacros.get(name);
+                if (func) {
+                    var lookAhead = i;
+                    while(lookAhead < len && (macroExpansion.charCodeAt(lookAhead) === 32 /* space */  || macroExpansion.charCodeAt(lookAhead) === 9))lookAhead++;
+                    if (lookAhead < len && macroExpansion.charCodeAt(lookAhead) === 40 /* '(' */ ) {
+                        var args = ShaderMacroProcessor._parseFuncArgs(macroExpansion, lookAhead);
+                        if (args) {
+                            i = args.end;
+                            expandedNames.add(name);
+                            out.push(ShaderMacroProcessor._recursiveExpandMacro(ShaderMacroProcessor._expandFuncBody(func, args.values), valueMacros, funcMacros, expandedNames));
+                            expandedNames.delete(name);
+                            continue;
+                        }
+                    }
+                }
+                var val = valueMacros.get(name);
+                if (val !== undefined && val !== "") {
+                    expandedNames.add(name);
+                    out.push(ShaderMacroProcessor._recursiveExpandMacro(val, valueMacros, funcMacros, expandedNames));
+                    expandedNames.delete(name);
+                    continue;
+                }
+                out.push(name);
+                continue;
+            }
+            // Batch collect non-identifier characters
+            var batchStart = i;
+            while(i < len && !ShaderMacroProcessor._isIdentifierStart(macroExpansion.charCodeAt(i)))i++;
+            out.push(macroExpansion.substring(batchStart, i));
+        }
+        return out.join("");
+    };
+    /**
+   * Substitute function macro params in body.
+   */ ShaderMacroProcessor._expandFuncBody = function _expandFuncBody(func, args) {
+        if (func.params.length === 0 || args.length !== func.params.length) return func.body;
+        var result = func.body;
+        for(var i = 0; i < func.params.length; i++){
+            result = ShaderMacroProcessor._replaceWord(result, func.params[i], args[i]);
+        }
+        return result;
+    };
+    /**
+   * Evaluate a compound condition tree.
+   */ ShaderMacroProcessor._evalCondition = function _evalCondition(cond, valueMacros, funcMacros) {
+        switch(cond.t){
+            case "def":
+                return valueMacros.has(cond.m) || funcMacros.has(cond.m);
+            case "ndef":
+                return !valueMacros.has(cond.m) && !funcMacros.has(cond.m);
+            case "cmp":
+                {
+                    var val = valueMacros.get(cond.m);
+                    if (val === undefined) return false;
+                    return ShaderMacroProcessor._compareValues(Number(val) || 0, cond.op, cond.v);
+                }
+            case "and":
+                return ShaderMacroProcessor._evalCondition(cond.l, valueMacros, funcMacros) && ShaderMacroProcessor._evalCondition(cond.r, valueMacros, funcMacros);
+            case "or":
+                return ShaderMacroProcessor._evalCondition(cond.l, valueMacros, funcMacros) || ShaderMacroProcessor._evalCondition(cond.r, valueMacros, funcMacros);
+            case "not":
+                return !ShaderMacroProcessor._evalCondition(cond.c, valueMacros, funcMacros);
+            case "bool":
+                return cond.v;
+        }
+    };
+    /**
+   * Evaluate a comparison operator.
+   */ ShaderMacroProcessor._compareValues = function _compareValues(numVal, op, value) {
+        switch(op){
+            case "==":
+                return numVal === value;
+            case "!=":
+                return numVal !== value;
+            case ">":
+                return numVal > value;
+            case "<":
+                return numVal < value;
+            case ">=":
+                return numVal >= value;
+            case "<=":
+                return numVal <= value;
+            default:
+                return false;
+        }
+    };
+    /**
+   * Parse function macro call arguments.
+   * Returns reusable static result object to avoid allocation.
+   */ ShaderMacroProcessor._parseFuncArgs = function _parseFuncArgs(text, openParen) {
+        var result = ShaderMacroProcessor._parsedFuncArgs;
+        result.values.length = 0;
+        var level = 1;
+        var argStart = openParen + 1;
+        var k = argStart;
+        var len = text.length;
+        while(k < len && level > 0){
+            var cc = text.charCodeAt(k);
+            if (cc === 40 /* '(' */ ) {
+                level++;
+            } else if (cc === 41 /* ')' */ ) {
+                if (--level === 0) {
+                    var arg = text.substring(argStart, k).trim();
+                    if (arg.length > 0 || result.values.length > 0) result.values.push(arg);
+                    result.end = k + 1;
+                    return result;
+                }
+            } else if (cc === 44 /* ',' */  && level === 1) {
+                result.values.push(text.substring(argStart, k).trim());
+                argStart = k + 1;
+            }
+            k++;
+        }
+        return null;
+    };
+    /**
+   * Replace all whole-word occurrences of `word` in `text` with `replacement`.
+   */ ShaderMacroProcessor._replaceWord = function _replaceWord(text, word, replacement) {
+        var wLen = word.length;
+        var parts = ShaderMacroProcessor._replaceWordParts;
+        parts.length = 0;
+        var start = 0;
+        var idx = text.indexOf(word, start);
+        while(idx !== -1){
+            if (idx > 0 && ShaderMacroProcessor._isIdentifierPart(text.charCodeAt(idx - 1))) {
+                idx = text.indexOf(word, idx + 1);
+                continue;
+            }
+            var afterIdx = idx + wLen;
+            if (afterIdx < text.length && ShaderMacroProcessor._isIdentifierPart(text.charCodeAt(afterIdx))) {
+                idx = text.indexOf(word, idx + 1);
+                continue;
+            }
+            parts.push(text.substring(start, idx));
+            parts.push(replacement);
+            start = afterIdx;
+            idx = text.indexOf(word, start);
+        }
+        if (start === 0) return text;
+        parts.push(text.substring(start));
+        return parts.join("");
+    };
+    /**
+   * Concatenate shader chunks with consecutive blank lines collapsed to a single newline.
+   */ ShaderMacroProcessor._concatChunks = function _concatChunks(shaderChunks) {
+        var out = ShaderMacroProcessor._out;
+        out.length = 0;
+        var lastNewline = false;
+        for(var p = 0; p < shaderChunks.length; p++){
+            var text = shaderChunks[p];
+            var len = text.length;
+            var i = 0;
+            while(i < len){
+                if (text.charCodeAt(i) === 10 /* \n */ ) {
+                    if (!lastNewline) {
+                        out.push("\n");
+                        lastNewline = true;
+                    }
+                    i++;
+                    while(i < len){
+                        var c = text.charCodeAt(i);
+                        if (c === 32 /* space */  || c === 9 /* tab */  || c === 10 /* \n */ ) i++;
+                        else break;
+                    }
+                } else {
+                    var batchStart = i;
+                    while(i < len && text.charCodeAt(i) !== 10 /* \n */ )i++;
+                    out.push(text.substring(batchStart, i));
+                    lastNewline = false;
+                }
+            }
+        }
+        return out.join("");
+    };
+    /**
+   * Check if char code is a valid identifier start.
+   * Matches: [A-Z] | [a-z] | _
+   */ ShaderMacroProcessor._isIdentifierStart = function _isIdentifierStart(charCode) {
+        return charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 95;
+    };
+    /**
+   * Check if char code is a valid identifier part.
+   * Matches: [A-Z] | [a-z] | [0-9] | _
+   */ ShaderMacroProcessor._isIdentifierPart = function _isIdentifierPart(charCode) {
+        return charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode >= 48 && charCode <= 57 || charCode === 95;
+    };
+    return ShaderMacroProcessor;
+}();
+ShaderMacroProcessor._valueMacros = new Map();
+ShaderMacroProcessor._funcMacros = new Map();
+ShaderMacroProcessor._shaderChunks = [];
+ShaderMacroProcessor._out = [];
+ShaderMacroProcessor._expandedNames = new Set();
+ShaderMacroProcessor._macroFirstChars = new Set();
+ShaderMacroProcessor._macroFirstCharsDirty = true;
+ShaderMacroProcessor._replaceWordParts = [];
+ShaderMacroProcessor._parsedFuncArgs = {
+    values: [],
+    end: 0
+};
+
 var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision highp float;\n      precision highp int;\n    #else\n      precision mediump float;\n      precision mediump int;\n    #endif\n    ";
 /**
  * Shader pass containing vertex and fragment source.
  */ var ShaderPass = /*#__PURE__*/ function(ShaderPart) {
     _inherits(ShaderPass, ShaderPart);
-    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSource, fragmentSourceOrTags, tags) {
+    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSourceOrInstructions, fragmentSourceOrTags, tagsOrPlatformTarget, tags) {
         var _this;
         _this = ShaderPart.call(this) || this, /** @internal */ _this._shaderPassId = 0, /** @internal */ _this._renderStateDataMap = {}, /** @internal */ _this._shaderProgramPools = [];
         _this._shaderPassId = ShaderPass._shaderPassCounter++;
-        if (typeof fragmentSourceOrTags === "string") {
+        if (Array.isArray(vertexSourceOrFragmentSourceOrInstructions)) {
+            // Instructions overload: (name, vertexInst, fragInst, platformTarget, tags?)
             _this._name = nameOrVertexSource;
-            _this._vertexSource = vertexSourceOrFragmentSource;
-            _this._fragmentSource = fragmentSourceOrTags;
+            _this._vertexShaderInstructions = vertexSourceOrFragmentSourceOrInstructions;
+            _this._fragmentShaderInstructions = fragmentSourceOrTags;
+            _this._platformTarget = tagsOrPlatformTarget;
             tags = _extends({
                 pipelineStage: PipelineStage.Forward
             }, tags);
+        } else if (typeof fragmentSourceOrTags === "string") {
+            // Named overload: (name, vertexSource, fragmentSource, tags?)
+            _this._name = nameOrVertexSource;
+            _this._vertexSource = vertexSourceOrFragmentSourceOrInstructions;
+            _this._fragmentSource = fragmentSourceOrTags;
+            tags = _extends({
+                pipelineStage: PipelineStage.Forward
+            }, tagsOrPlatformTarget);
         } else {
+            // Unnamed overload: (vertexSource, fragmentSource, tags?)
             _this._name = "Default";
             _this._vertexSource = nameOrVertexSource;
-            _this._fragmentSource = vertexSourceOrFragmentSource;
+            _this._fragmentSource = vertexSourceOrFragmentSourceOrInstructions;
             tags = _extends({
                 pipelineStage: PipelineStage.Forward
             }, fragmentSourceOrTags);
@@ -5842,15 +6317,16 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         shaderProgramPools.length = 0;
     };
     _proto._getCanonicalShaderProgram = function _getCanonicalShaderProgram(engine, macroCollection) {
-        if (this._platformTarget != undefined) {
-            return this._getShaderLabProgram(engine, macroCollection);
-        }
-        var _ShaderFactory_compilePlatformSource = ShaderFactory.compilePlatformSource(engine, macroCollection, this._vertexSource, this._fragmentSource), vertexSource = _ShaderFactory_compilePlatformSource.vertexSource, fragmentSource = _ShaderFactory_compilePlatformSource.fragmentSource;
+        var _ref = this._platformTarget != undefined ? this._compileShaderLabSource(engine, macroCollection) : this._compilePlatformSource(engine, macroCollection), vertexSource = _ref.vertexSource, fragmentSource = _ref.fragmentSource;
         return new ShaderProgram(engine, vertexSource, fragmentSource);
     };
-    _proto._getShaderLabProgram = function _getShaderLabProgram(engine, macroCollection) {
+    _proto._compilePlatformSource = function _compilePlatformSource(engine, macroCollection) {
+        return ShaderFactory.compilePlatformSource(engine, macroCollection, this._vertexSource, this._fragmentSource);
+    };
+    _proto._compileShaderLabSource = function _compileShaderLabSource(engine, macroCollection) {
         var isWebGL2 = engine._hardwareRenderer.isWebGL2;
-        var shaderMacroList = new Array();
+        var shaderMacroList = ShaderPass._shaderMacroList;
+        shaderMacroList.length = 0;
         ShaderMacro._getMacrosElements(macroCollection, shaderMacroList);
         shaderMacroList.push(ShaderMacro.getByName(isWebGL2 ? "GRAPHICS_API_WEBGL2" : "GRAPHICS_API_WEBGL1"));
         if (engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
@@ -5859,23 +6335,31 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
             shaderMacroList.push(ShaderMacro.getByName("HAS_DERIVATIVES"));
         }
-        var noIncludeVertex = ShaderFactory.parseIncludes(this._vertexSource);
-        var noIncludeFrag = ShaderFactory.parseIncludes(this._fragmentSource);
-        noIncludeVertex = Shader._shaderLab._parseMacros(noIncludeVertex, shaderMacroList);
-        noIncludeFrag = Shader._shaderLab._parseMacros(noIncludeFrag, shaderMacroList);
+        var macroMap = ShaderPass._macroMap;
+        macroMap.clear();
+        for(var i = 0, n = shaderMacroList.length; i < n; i++){
+            var macro = shaderMacroList[i];
+            var _macro_value;
+            macroMap.set(macro.name, (_macro_value = macro.value) != null ? _macro_value : "");
+        }
+        var vertexSource = ShaderMacroProcessor.evaluate(this._vertexShaderInstructions, macroMap);
+        var fragmentSource = ShaderMacroProcessor.evaluate(this._fragmentShaderInstructions, macroMap);
         if (isWebGL2 && this._platformTarget === ShaderLanguage.GLSLES100) {
-            noIncludeVertex = ShaderFactory.convertTo300(noIncludeVertex);
-            noIncludeFrag = ShaderFactory.convertTo300(noIncludeFrag, true);
+            vertexSource = ShaderFactory.convertTo300(vertexSource);
+            fragmentSource = ShaderFactory.convertTo300(fragmentSource, true);
         }
         var versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
-        var vertexSource = " " + versionStr + "\n        " + noIncludeVertex + "\n      ";
-        var fragmentSource = " " + versionStr + "\n        " + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + "\n        " + precisionStr + "\n        " + noIncludeFrag + "\n      ";
-        return new ShaderProgram(engine, vertexSource, fragmentSource);
+        return {
+            vertexSource: " " + versionStr + "\n        " + vertexSource + "\n      ",
+            fragmentSource: " " + versionStr + "\n        " + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + "\n        " + precisionStr + "\n        " + fragmentSource + "\n      "
+        };
     };
     return ShaderPass;
 }(ShaderPart);
 /** @internal */ ShaderPass._shaderPassCounter = 0;
 /** @internal */ ShaderPass._shaderRootPath = "shaders://root/";
+ShaderPass._shaderMacroList = [];
+ShaderPass._macroMap = new Map();
 
 /**
  * Sub shader.
@@ -6624,36 +7108,14 @@ __decorate([
             var subShaderList = shaderSource.subShaders.map(function(subShaderSource) {
                 var passList = subShaderSource.passes.map(function(passSource) {
                     if (passSource.isUsePass) {
-                        var _Shader_find_subShaders_find, _Shader_find;
-                        var _passSource_name_split = passSource.name.split("/"), shaderName = _passSource_name_split[0], subShaderName = _passSource_name_split[1], passName = _passSource_name_split[2];
-                        return (_Shader_find = Shader.find(shaderName)) == null ? void 0 : (_Shader_find_subShaders_find = _Shader_find.subShaders.find(function(subShader) {
-                            return subShader.name === subShaderName;
-                        })) == null ? void 0 : _Shader_find_subShaders_find.passes.find(function(pass) {
-                            return pass.name === passName;
-                        });
+                        return Shader._resolveUsePass(passSource.name);
                     }
                     var shaderPassSource = Shader._shaderLab._parseShaderPass(passSource.contents, passSource.vertexEntry, passSource.fragmentEntry, vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget, new URL(fragmentSourceOrPath != null ? fragmentSourceOrPath : "", ShaderPass._shaderRootPath).href);
                     if (!shaderPassSource) {
                         throw 'Shader pass "' + shaderSource.name + "." + subShaderSource.name + "." + passSource.name + '" parse failed, please check the shader source code.';
                     }
-                    var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertex, shaderPassSource.fragment, passSource.tags);
-                    shaderPass._platformTarget = vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget;
-                    var _passSource_renderStates = passSource.renderStates, constantMap = _passSource_renderStates.constantMap, variableMap = _passSource_renderStates.variableMap;
-                    // Compatible shader lab no render state use material `renderState` to modify render state
-                    if (Object.keys(constantMap).length > 0 || Object.keys(variableMap).length > 0) {
-                        // Parse const render state
-                        var renderState = new RenderState();
-                        for(var k in constantMap){
-                            Shader._applyConstRenderStates(renderState, +k, constantMap[k]);
-                        }
-                        shaderPass._renderState = renderState;
-                        // Parse variable render state
-                        var renderStateDataMap = {};
-                        for(var k1 in variableMap){
-                            renderStateDataMap[k1] = ShaderProperty.getByName(variableMap[k1]);
-                        }
-                        shaderPass._renderStateDataMap = renderStateDataMap;
-                    }
+                    var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertexShaderInstructions, shaderPassSource.fragmentShaderInstructions, vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget, passSource.tags);
+                    Shader._applyRenderStates(shaderPass, passSource.renderStates.constantMap, passSource.renderStates.variableMap, false);
                     return shaderPass;
                 });
                 return new SubShader(subShaderSource.name, passList, subShaderSource.tags);
@@ -6698,6 +7160,29 @@ __decorate([
     };
     /**
    * @internal
+   */ Shader._createFromPrecompiled = function _createFromPrecompiled(data) {
+        var shaderMap = Shader._shaderMap;
+        if (shaderMap[data.name]) {
+            console.error('Shader named "' + data.name + '" already exists.');
+            return;
+        }
+        var subShaderList = data.subShaders.map(function(subData) {
+            var passList = subData.passes.map(function(passData) {
+                if (passData.isUsePass) {
+                    return Shader._resolveUsePass(passData.name);
+                }
+                var shaderPass = new ShaderPass(passData.name, passData.vertexShaderInstructions, passData.fragmentShaderInstructions, data.platformTarget, passData.tags);
+                Shader._applyRenderStates(shaderPass, passData.renderStates.constantMap, passData.renderStates.variableMap, true);
+                return shaderPass;
+            });
+            return new SubShader(subData.name, passList, subData.tags);
+        });
+        var shader = new Shader(data.name, subShaderList);
+        shaderMap[data.name] = shader;
+        return shader;
+    };
+    /**
+   * @internal
    */ Shader._clear = function _clear(engine) {
         var shaderMap = Shader._shaderMap;
         for(var key in shaderMap){
@@ -6718,6 +7203,34 @@ __decorate([
             }
         }
     };
+    Shader._resolveUsePass = function _resolveUsePass(passName) {
+        var _Shader_find_subShaders_find, _Shader_find;
+        var _passName_split = passName.split("/"), shaderName = _passName_split[0], subShaderName = _passName_split[1], passNamePart = _passName_split[2];
+        return (_Shader_find = Shader.find(shaderName)) == null ? void 0 : (_Shader_find_subShaders_find = _Shader_find.subShaders.find(function(subShader) {
+            return subShader.name === subShaderName;
+        })) == null ? void 0 : _Shader_find_subShaders_find.passes.find(function(pass) {
+            return pass.name === passNamePart;
+        });
+    };
+    Shader._applyRenderStates = function _applyRenderStates(shaderPass, constantMap, variableMap, deserializeColor) {
+        if (Object.keys(constantMap).length > 0 || Object.keys(variableMap).length > 0) {
+            var renderState = new RenderState();
+            for(var k in constantMap){
+                var value = constantMap[k];
+                if (deserializeColor && Array.isArray(value)) {
+                    Shader._applyConstRenderStates(renderState, +k, new engineMath.Color(value[0], value[1], value[2], value[3]));
+                } else {
+                    Shader._applyConstRenderStates(renderState, +k, value);
+                }
+            }
+            shaderPass._renderState = renderState;
+            var renderStateDataMap = {};
+            for(var k1 in variableMap){
+                renderStateDataMap[k1] = ShaderProperty.getByName(variableMap[k1]);
+            }
+            shaderPass._renderStateDataMap = renderStateDataMap;
+        }
+    };
     Shader._applyConstRenderStates = function _applyConstRenderStates(renderState, key, value) {
         switch(key){
             case RenderStateElementKey.BlendStateEnabled0:
@@ -9158,7 +9671,15 @@ exports.Camera = /*#__PURE__*/ function(Component) {
    */ _proto._getInvViewProjMat = function _getInvViewProjMat() {
         if (this._isInvViewProjDirty.flag) {
             this._isInvViewProjDirty.flag = false;
-            engineMath.Matrix.multiply(this._entity.transform.worldMatrix, this._getInverseProjectionMatrix(), this._invViewProjMat);
+            var matrix = this._invViewProjMat;
+            if (this._isCustomViewMatrix) {
+                engineMath.Matrix.invert(this.viewMatrix, matrix);
+            } else {
+                // Ignore scale, consistent with viewMatrix getter
+                var transform = this._entity.transform;
+                engineMath.Matrix.rotationTranslation(transform.worldRotationQuaternion, transform.worldPosition, matrix);
+            }
+            matrix.multiply(this._getInverseProjectionMatrix());
         }
         return this._invViewProjMat;
     };
@@ -22447,7 +22968,7 @@ __decorate([
     deepClone
 ], Skin.prototype, "inverseBindMatrices", void 0);
 __decorate([
-    ignoreClone
+    deepClone
 ], Skin.prototype, "_skinMatrices", void 0);
 __decorate([
     ignoreClone
@@ -23447,7 +23968,10 @@ var ComponentCloner = /*#__PURE__*/ function() {
     _proto._setActiveComponents = function _setActiveComponents(isActive, activeChangeFlag) {
         var activeChangedComponents = this._activeChangedComponents;
         for(var i = 0, length = activeChangedComponents.length; i < length; ++i){
-            activeChangedComponents[i]._setActive(isActive, activeChangeFlag);
+            var component = activeChangedComponents[i];
+            // Skip components whose scene was already cleared by an earlier callback's removeChild
+            if (!isActive && !component._entity._scene) continue;
+            component._setActive(isActive, activeChangeFlag);
         }
         this._scene._componentsManager.putActiveChangedTempList(activeChangedComponents);
         this._activeChangedComponents = null;
@@ -23467,18 +23991,19 @@ var ComponentCloner = /*#__PURE__*/ function() {
         }
     };
     _proto._setInActiveInHierarchy = function _setInActiveInHierarchy(activeChangedComponents, activeChangeFlag) {
+        // Children-first, reverse traversal for safe removeChild during callbacks
+        var children = this._children;
+        for(var i = children.length - 1; i >= 0; i--){
+            var child = children[i];
+            child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
+        }
         activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = false);
         activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = false);
         var components = this._components;
-        for(var i = 0, n = components.length; i < n; i++){
-            var component = components[i];
+        for(var i1 = 0, n = components.length; i1 < n; i1++){
+            var component = components[i1];
             component.enabled && activeChangedComponents.push(component);
         }
-        var children = this._children;
-        for(var i1 = 0, n1 = children.length; i1 < n1; i1++){
-            var child = children[i1];
-            child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
-        }
     };
     _proto._setSiblingIndex = function _setSiblingIndex(sibling, target) {
         target = Math.min(target, sibling.length - 1);
@@ -26390,7 +26915,7 @@ var depthOnlyVs = "#define MATERIAL_OMIT_NORMAL\n#include <common>\n#include <co
 
 var particleFs = "#include <common>\n\nvarying vec4 v_Color;\nvarying vec2 v_TextureCoordinate;\nuniform sampler2D material_BaseTexture;\nuniform vec4 material_BaseColor;\n \nuniform mediump vec3 material_EmissiveColor;\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n    uniform sampler2D material_EmissiveTexture;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n\tvarying vec4 v_MeshColor;\n#endif\n\nvoid main() {\n\tvec4 color = material_BaseColor * v_Color;\n\n\t#if defined(RENDERER_MODE_MESH) && defined(RENDERER_ENABLE_VERTEXCOLOR)\n\t\tcolor *= v_MeshColor;\n\t#endif\n\n\t#ifdef MATERIAL_HAS_BASETEXTURE\n\t\tcolor *= texture2DSRGB(material_BaseTexture, v_TextureCoordinate);\n\t#endif\n\t\n\t// Emissive\n\tvec3 emissiveRadiance = material_EmissiveColor;\n\t#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n\t\temissiveRadiance *= texture2DSRGB(material_EmissiveTexture, v_TextureCoordinate).rgb;\n\t#endif\n\n\tcolor.rgb += emissiveRadiance;\n\n\tgl_FragColor = color;\n}"; // eslint-disable-line
 
-var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\n#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE) || defined(RENDERER_LVL_MODULE_ENABLED)\n    attribute vec4 a_Random2;\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\n#ifdef RENDERER_TRANSFORM_FEEDBACK\n    attribute vec3 a_FeedbackPosition;\n    attribute vec3 a_FeedbackVelocity;\n#endif\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = startVelocity * age;\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    // normalizedAge >= 0.0: skip stale TF slots whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 0.0 && normalizedAge < 1.0) {\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity;\n        vec3 worldVelocity;\n\n        #ifdef RENDERER_TRANSFORM_FEEDBACK\n            // Transform Feedback mode: position in simulation space (local or world).\n            // Local: transform to world; World: use directly.\n            vec3 center;\n            if (renderer_SimulationSpace == 0) {\n                center = rotationByQuaternions(a_FeedbackPosition, worldRotation) + renderer_WorldPosition;\n            } else if (renderer_SimulationSpace == 1) {\n                center = a_FeedbackPosition;\n            }\n            localVelocity = a_FeedbackVelocity;\n            worldVelocity = vec3(0.0);\n\n            #ifdef _VOL_MODULE_ENABLED\n                vec3 instantVOLVelocity;\n                computeVelocityPositionOffset(normalizedAge, age, instantVOLVelocity);\n                if (renderer_VOLSpace == 0) {\n                    localVelocity += instantVOLVelocity;\n                } else {\n                    worldVelocity += instantVOLVelocity;\n                }\n            #endif\n        #else\n            // Original analytical path\n            vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n            vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n            localVelocity = startVelocity;\n            worldVelocity = gravityVelocity;\n            vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, localVelocity, worldVelocity);\n        #endif\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
+var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\n#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE) || defined(RENDERER_LVL_MODULE_ENABLED)\n    attribute vec4 a_Random2;\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\n#ifdef RENDERER_TRANSFORM_FEEDBACK\n    attribute vec3 a_FeedbackPosition;\n    attribute vec3 a_FeedbackVelocity;\n#endif\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n#include <noise_module>\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = startVelocity * age;\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    // normalizedAge >= 0.0: skip stale TF slots whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 0.0 && normalizedAge < 1.0) {\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity;\n        vec3 worldVelocity;\n\n        #ifdef RENDERER_TRANSFORM_FEEDBACK\n            // Transform Feedback mode: position in simulation space (local or world).\n            // Local: transform to world; World: use directly.\n            vec3 center;\n            if (renderer_SimulationSpace == 0) {\n                center = rotationByQuaternions(a_FeedbackPosition, worldRotation) + renderer_WorldPosition;\n            } else if (renderer_SimulationSpace == 1) {\n                center = a_FeedbackPosition;\n            }\n            localVelocity = a_FeedbackVelocity;\n            worldVelocity = vec3(0.0);\n\n            #ifdef _VOL_MODULE_ENABLED\n                vec3 instantVOLVelocity;\n                computeVelocityPositionOffset(normalizedAge, age, instantVOLVelocity);\n                if (renderer_VOLSpace == 0) {\n                    localVelocity += instantVOLVelocity;\n                } else {\n                    worldVelocity += instantVOLVelocity;\n                }\n            #endif\n        #else\n            // Original analytical path\n            vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n            vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n            localVelocity = startVelocity;\n            worldVelocity = gravityVelocity;\n            vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, localVelocity, worldVelocity);\n        #endif\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
 
 var pbrSpecularFs = "#include <common>\n#include <camera_declare>\n\n#include <FogFragmentDeclaration>\n\n#include <uv_share>\n#include <normal_share>\n#include <color_share>\n#include <worldpos_share>\n\n#include <light_frag_define>\n\n\n#include <pbr_frag_define>\n#include <pbr_helper>\n\nvoid main() {\n    #include <pbr_frag>\n    #include <FogFragment>\n}\n"; // eslint-disable-line
 
@@ -28860,45 +29385,6 @@ Scene._fogColorProperty = ShaderProperty.getByName("scene_FogColor");
 Scene._fogParamsProperty = ShaderProperty.getByName("scene_FogParams");
 Scene._prefilterdDFGProperty = ShaderProperty.getByName("scene_PrefilteredDFG");
 
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-    return arr2;
-}
-
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-
-function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
-    if (it) return (it = it.call(o)).next.bind(it);
-    // Fallback for engines without symbol support
-    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-
-        var i = 0;
-
-        return function() {
-            if (i >= o.length) return { done: true };
-
-            return { done: false, value: o[i++] };
-        };
-    }
-
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
 /**
  * Script class, used for logic writing.
  */ var Script = /*#__PURE__*/ function(Component) {
@@ -33293,7 +33779,7 @@ var ParticleStopMode = /*#__PURE__*/ function(ParticleStopMode) {
     _inherits(ParticleRenderer, Renderer);
     function ParticleRenderer(entity) {
         var _this;
-        _this = Renderer.call(this, entity) || this, /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0, /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2, /** The pivot of particle. */ _this.pivot = new engineMath.Vector3(), /** @internal */ _this._generatorBounds = new engineMath.BoundingBox(), /** @internal */ _this._transformedBounds = new engineMath.BoundingBox();
+        _this = Renderer.call(this, entity) || this, /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0, /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2, /** The pivot of particle. */ _this.pivot = new engineMath.Vector3(), /** @internal */ _this._generatorBounds = new engineMath.BoundingBox(), /** @internal */ _this._transformedBounds = new engineMath.BoundingBox(), _this._renderMode = ParticleRenderMode.Billboard;
         _this._onGeneratorParamsChanged = _this._onGeneratorParamsChanged.bind(_this);
         _this.generator = new ParticleGenerator(_this);
         _this._currentRenderModeMacro = ParticleRenderer._billboardModeMacro;
@@ -33899,6 +34385,7 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["GravityModifier"] = 2759560269] = "GravityModifier";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
+    ParticleRandomSubSeeds[ParticleRandomSubSeeds["Noise"] = 4105357473] = "Noise";
     return ParticleRandomSubSeeds;
 }({});
 
@@ -35282,7 +35769,7 @@ __decorate([
                         return;
                     }
                     this._enabled = value;
-                    this._generator._setTransformFeedback(value);
+                    this._generator._setTransformFeedback();
                     this._generator._renderer._onGeneratorParamsChanged();
                 }
             }
@@ -36228,6 +36715,298 @@ __decorate([
     ignoreClone
 ], TextureSheetAnimationModule.prototype, "_onTilingChanged", null);
 
+/**
+ * Noise module for particle system.
+ * Adds simplex noise-based turbulence displacement to particles.
+ */ var NoiseModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+    _inherits(NoiseModule, ParticleGeneratorModule);
+    function NoiseModule(generator) {
+        var _this;
+        _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._noiseRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Noise), _this._noiseParams = new engineMath.Vector4(), _this._noiseOctaveParams = new engineMath.Vector4(), _this._strengthMinConst = new engineMath.Vector3(), _this._scrollSpeed = 0, _this._separateAxes = false, _this._frequency = 0.5, _this._octaveCount = 1, _this._octaveIntensityMultiplier = 0.5, _this._octaveFrequencyMultiplier = 2.0;
+        _this.strengthX = new ParticleCompositeCurve(1);
+        _this.strengthY = new ParticleCompositeCurve(1);
+        _this.strengthZ = new ParticleCompositeCurve(1);
+        return _this;
+    }
+    var _proto = NoiseModule.prototype;
+    /**
+   * @internal
+   */ _proto._updateShaderData = function _updateShaderData(shaderData) {
+        var enabledMacro = null;
+        var strengthCurveMacro = null;
+        var strengthIsRandomTwoMacro = null;
+        var separateAxesMacro = null;
+        if (this.enabled) {
+            enabledMacro = NoiseModule._enabledMacro;
+            var strengthX = this._strengthX;
+            var strengthY = this._strengthY;
+            var strengthZ = this._strengthZ;
+            var separateAxes = this._separateAxes;
+            // Determine strength curve mode (following SOL pattern)
+            var isRandomCurveMode = separateAxes ? strengthX.mode === ParticleCurveMode.TwoCurves && strengthY.mode === ParticleCurveMode.TwoCurves && strengthZ.mode === ParticleCurveMode.TwoCurves : strengthX.mode === ParticleCurveMode.TwoCurves;
+            var isCurveMode = isRandomCurveMode || (separateAxes ? strengthX.mode === ParticleCurveMode.Curve && strengthY.mode === ParticleCurveMode.Curve && strengthZ.mode === ParticleCurveMode.Curve : strengthX.mode === ParticleCurveMode.Curve);
+            var isRandomConstMode = separateAxes ? strengthX.mode === ParticleCurveMode.TwoConstants && strengthY.mode === ParticleCurveMode.TwoConstants && strengthZ.mode === ParticleCurveMode.TwoConstants : strengthX.mode === ParticleCurveMode.TwoConstants;
+            // noiseParams.w = frequency (always needed)
+            var noiseParams = this._noiseParams;
+            if (isCurveMode) {
+                // Curve/TwoCurves: encode curve data as float arrays
+                shaderData.setFloatArray(NoiseModule._strengthMaxCurveXProperty, strengthX.curveMax._getTypeArray());
+                if (separateAxes) {
+                    shaderData.setFloatArray(NoiseModule._strengthMaxCurveYProperty, strengthY.curveMax._getTypeArray());
+                    shaderData.setFloatArray(NoiseModule._strengthMaxCurveZProperty, strengthZ.curveMax._getTypeArray());
+                }
+                if (isRandomCurveMode) {
+                    shaderData.setFloatArray(NoiseModule._strengthMinCurveXProperty, strengthX.curveMin._getTypeArray());
+                    if (separateAxes) {
+                        shaderData.setFloatArray(NoiseModule._strengthMinCurveYProperty, strengthY.curveMin._getTypeArray());
+                        shaderData.setFloatArray(NoiseModule._strengthMinCurveZProperty, strengthZ.curveMin._getTypeArray());
+                    }
+                    strengthIsRandomTwoMacro = NoiseModule._strengthIsRandomTwoMacro;
+                }
+                strengthCurveMacro = NoiseModule._strengthCurveMacro;
+                // xyz unused in curve mode, just set frequency
+                noiseParams.set(0, 0, 0, this._frequency);
+            } else {
+                // Constant/TwoConstants: pack strength into noiseParams.xyz
+                if (separateAxes) {
+                    noiseParams.set(strengthX.constantMax, strengthY.constantMax, strengthZ.constantMax, this._frequency);
+                } else {
+                    var s = strengthX.constantMax;
+                    noiseParams.set(s, s, s, this._frequency);
+                }
+                if (isRandomConstMode) {
+                    var minConst = this._strengthMinConst;
+                    if (separateAxes) {
+                        minConst.set(strengthX.constantMin, strengthY.constantMin, strengthZ.constantMin);
+                    } else {
+                        var sMin = strengthX.constantMin;
+                        minConst.set(sMin, sMin, sMin);
+                    }
+                    shaderData.setVector3(NoiseModule._strengthMinConstProperty, minConst);
+                    strengthIsRandomTwoMacro = NoiseModule._strengthIsRandomTwoMacro;
+                }
+            }
+            shaderData.setVector4(NoiseModule._noiseProperty, noiseParams);
+            if (separateAxes) {
+                separateAxesMacro = NoiseModule._separateAxesMacro;
+            }
+            var noiseOctaveParams = this._noiseOctaveParams;
+            noiseOctaveParams.set(this._scrollSpeed, this._octaveCount, this._octaveIntensityMultiplier, this._octaveFrequencyMultiplier);
+            shaderData.setVector4(NoiseModule._noiseOctaveProperty, noiseOctaveParams);
+        }
+        this._enabledModuleMacro = this._enableMacro(shaderData, this._enabledModuleMacro, enabledMacro);
+        this._strengthCurveModeMacro = this._enableMacro(shaderData, this._strengthCurveModeMacro, strengthCurveMacro);
+        this._strengthIsRandomTwoModeMacro = this._enableMacro(shaderData, this._strengthIsRandomTwoModeMacro, strengthIsRandomTwoMacro);
+        this._separateAxesModeMacro = this._enableMacro(shaderData, this._separateAxesModeMacro, separateAxesMacro);
+    };
+    /**
+   * @internal
+   */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
+        this._noiseRand.reset(seed, ParticleRandomSubSeeds.Noise);
+    };
+    _create_class(NoiseModule, [
+        {
+            key: "separateAxes",
+            get: /**
+   * Specifies whether the strength is separate on each axis, when disabled, only `strength` is used.
+   */ function get() {
+                return this._separateAxes;
+            },
+            set: function set(value) {
+                if (value !== this._separateAxes) {
+                    this._separateAxes = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "strengthX",
+            get: /**
+   * Noise strength. When `separateAxes` is disabled, applies to all axes.
+   * When `separateAxes` is enabled, applies only to x axis.
+   */ function get() {
+                return this._strengthX;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthX;
+                if (value !== lastValue) {
+                    this._strengthX = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "strengthY",
+            get: /**
+   * Noise strength for y axis, used when `separateAxes` is enabled.
+   */ function get() {
+                return this._strengthY;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthY;
+                if (value !== lastValue) {
+                    this._strengthY = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "strengthZ",
+            get: /**
+   * Noise strength for z axis, used when `separateAxes` is enabled.
+   */ function get() {
+                return this._strengthZ;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthZ;
+                if (value !== lastValue) {
+                    this._strengthZ = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "frequency",
+            get: /**
+   * Noise spatial frequency.
+   */ function get() {
+                return this._frequency;
+            },
+            set: function set(value) {
+                value = Math.max(1e-6, value);
+                if (value !== this._frequency) {
+                    this._frequency = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "scrollSpeed",
+            get: /**
+   * Noise field scroll speed over time.
+   */ function get() {
+                return this._scrollSpeed;
+            },
+            set: function set(value) {
+                if (value !== this._scrollSpeed) {
+                    this._scrollSpeed = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveCount",
+            get: /**
+   * Number of noise octave layers (1-3).
+   */ function get() {
+                return this._octaveCount;
+            },
+            set: function set(value) {
+                value = Math.max(1, Math.min(3, Math.floor(value)));
+                if (value !== this._octaveCount) {
+                    this._octaveCount = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveIntensityMultiplier",
+            get: /**
+   * Intensity multiplier for each successive octave, only effective when `octaveCount` > 1.
+   * Each layer's contribution is scaled by this factor relative to the previous layer, range [0, 1].
+   */ function get() {
+                return this._octaveIntensityMultiplier;
+            },
+            set: function set(value) {
+                value = Math.max(0, Math.min(1, value));
+                if (value !== this._octaveIntensityMultiplier) {
+                    this._octaveIntensityMultiplier = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveFrequencyMultiplier",
+            get: /**
+   * Frequency multiplier for each successive octave, only effective when `octaveCount` > 1.
+   * Each layer samples at this multiple of the previous layer's frequency, range [1, 4].
+   */ function get() {
+                return this._octaveFrequencyMultiplier;
+            },
+            set: function set(value) {
+                value = Math.max(1, Math.min(4, value));
+                if (value !== this._octaveFrequencyMultiplier) {
+                    this._octaveFrequencyMultiplier = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "enabled",
+            get: function get() {
+                return this._enabled;
+            },
+            set: function set(value) {
+                if (value !== this._enabled) {
+                    if (value && !this._generator._renderer.engine._hardwareRenderer.isWebGL2) {
+                        return;
+                    }
+                    this._enabled = value;
+                    this._generator._setTransformFeedback();
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        }
+    ]);
+    return NoiseModule;
+}(ParticleGeneratorModule);
+NoiseModule._enabledMacro = ShaderMacro.getByName("RENDERER_NOISE_MODULE_ENABLED");
+NoiseModule._strengthCurveMacro = ShaderMacro.getByName("RENDERER_NOISE_STRENGTH_CURVE");
+NoiseModule._strengthIsRandomTwoMacro = ShaderMacro.getByName("RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO");
+NoiseModule._separateAxesMacro = ShaderMacro.getByName("RENDERER_NOISE_IS_SEPARATE");
+NoiseModule._noiseProperty = ShaderProperty.getByName("renderer_NoiseParams");
+NoiseModule._noiseOctaveProperty = ShaderProperty.getByName("renderer_NoiseOctaveParams");
+NoiseModule._strengthMinConstProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinConst");
+NoiseModule._strengthMaxCurveXProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveX");
+NoiseModule._strengthMaxCurveYProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveY");
+NoiseModule._strengthMaxCurveZProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveZ");
+NoiseModule._strengthMinCurveXProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveX");
+NoiseModule._strengthMinCurveYProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveY");
+NoiseModule._strengthMinCurveZProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveZ");
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_enabledModuleMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthCurveModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthIsRandomTwoModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_separateAxesModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseRand", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseParams", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseOctaveParams", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthMinConst", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthX", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthY", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthZ", void 0);
+
 /**
  * Velocity over lifetime module.
  */ var VelocityOverLifetimeModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
@@ -36434,6 +37213,7 @@ __decorate([
         this.forceOverLifetime = new ForceOverLifetimeModule(this);
         this.sizeOverLifetime = new SizeOverLifetimeModule(this);
         this.limitVelocityOverLifetime = new LimitVelocityOverLifetimeModule(this);
+        this.noise = new NoiseModule(this);
         this.emission.enabled = true;
     }
     var _proto = ParticleGenerator.prototype;
@@ -36741,6 +37521,7 @@ __decorate([
         this.sizeOverLifetime._updateShaderData(shaderData);
         this.rotationOverLifetime._updateShaderData(shaderData);
         this.colorOverLifetime._updateShaderData(shaderData);
+        this.noise._updateShaderData(shaderData);
     };
     /**
    * @internal
@@ -36754,16 +37535,19 @@ __decorate([
         this.limitVelocityOverLifetime._resetRandomSeed(seed);
         this.rotationOverLifetime._resetRandomSeed(seed);
         this.colorOverLifetime._resetRandomSeed(seed);
+        this.noise._resetRandomSeed(seed);
     };
     /**
    * @internal
-   */ _proto._setTransformFeedback = function _setTransformFeedback(enabled) {
-        this._useTransformFeedback = enabled;
+   */ _proto._setTransformFeedback = function _setTransformFeedback() {
+        var needed = this.limitVelocityOverLifetime.enabled || this.noise.enabled;
+        if (needed === this._useTransformFeedback) return;
+        this._useTransformFeedback = needed;
         // Switching TF mode invalidates all active particle state: feedback buffers and instance
         // buffer layout are incompatible between the two paths. Clear rather than show a one-frame
         // jump; new particles will fill in naturally from the next emit cycle.
         this._clearActiveParticles();
-        if (enabled) {
+        if (needed) {
             if (!this._feedbackSimulator) {
                 this._feedbackSimulator = new ParticleTransformFeedbackSimulator(this._renderer.engine);
             }
@@ -36813,9 +37597,7 @@ __decorate([
     /**
    * @internal
    */ _proto._cloneTo = function _cloneTo(target) {
-        if (target.limitVelocityOverLifetime.enabled) {
-            target._setTransformFeedback(true);
-        }
+        target._setTransformFeedback();
     };
     /**
    * @internal
@@ -36977,10 +37759,6 @@ __decorate([
         // Start rotation
         var startRotationRand = main._startRotationRand, flipRotation = main.flipRotation;
         var isFlip = flipRotation > startRotationRand.random();
-        // @todo:None-Mesh mode should inverse the rotation, maybe should unify it
-        if (this._renderer.renderMode !== ParticleRenderMode.Mesh) {
-            isFlip = !isFlip;
-        }
         var rotationZ = main.startRotationZ.evaluate(undefined, startRotationRand.random());
         if (main.startRotation3D) {
             var rotationX = main.startRotationX.evaluate(undefined, startRotationRand.random());
@@ -37006,7 +37784,9 @@ __decorate([
         if (colorOverLifetime.enabled && colorOverLifetime.color.mode === ParticleGradientMode.TwoGradients) {
             instanceVertices[offset + 20] = colorOverLifetime._colorGradientRand.random();
         }
-        // instanceVertices[offset + 21] = rand.random();
+        if (this.noise.enabled) {
+            instanceVertices[offset + 21] = this.noise._noiseRand.random();
+        }
         var rotationOverLifetime = this.rotationOverLifetime;
         if (rotationOverLifetime.enabled && rotationOverLifetime.rotationZ.mode === ParticleCurveMode.TwoConstants) {
             instanceVertices[offset + 22] = rotationOverLifetime._rotationRand.random();
@@ -37294,6 +38074,21 @@ __decorate([
         out.transform(rotateMat);
         min.add(worldOffsetMin);
         max.add(worldOffsetMax);
+        // Noise module impact: noise output is normalized to [-1, 1],
+        // max displacement = |strength_max|
+        var noise = this.noise;
+        if (noise.enabled) {
+            var noiseMaxX, noiseMaxY, noiseMaxZ;
+            if (noise.separateAxes) {
+                noiseMaxX = Math.abs(noise.strengthX._getMax());
+                noiseMaxY = Math.abs(noise.strengthY._getMax());
+                noiseMaxZ = Math.abs(noise.strengthZ._getMax());
+            } else {
+                noiseMaxX = noiseMaxY = noiseMaxZ = Math.abs(noise.strengthX._getMax());
+            }
+            min.set(min.x - noiseMaxX, min.y - noiseMaxY, min.z - noiseMaxZ);
+            max.set(max.x + noiseMaxX, max.y + noiseMaxY, max.z + noiseMaxZ);
+        }
         min.add(worldPosition);
         max.add(worldPosition);
     };
@@ -37391,6 +38186,9 @@ __decorate([
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "textureSheetAnimation", void 0);
+__decorate([
+    deepClone
+], ParticleGenerator.prototype, "noise", void 0);
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_playTime", void 0);
@@ -39594,6 +40392,7 @@ exports.MeshRenderer = MeshRenderer;
 exports.MeshShape = MeshShape;
 exports.MeshTopology = MeshTopology;
 exports.ModelMesh = ModelMesh;
+exports.NoiseModule = NoiseModule;
 exports.OverflowMode = OverflowMode;
 exports.PBRMaterial = PBRMaterial;
 exports.ParticleCompositeCurve = ParticleCompositeCurve;