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

package/dist/browser.js

@@ -6414,6 +6414,12 @@
                 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;
@@ -6947,7 +6953,7 @@
             _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;
@@ -9888,7 +9894,8 @@
     var texture_sheet_animation_module = "#if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n    uniform float renderer_TSACycles;\n    uniform vec3 renderer_TSATillingParams; // x:subU y:subV z:tileCount\n    uniform vec2 renderer_TSAFrameMaxCurve[4]; // x:time y:value\n\n    #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n        uniform vec2 renderer_TSAFrameMinCurve[4]; // x:time y:value\n    #endif\n#endif\n\nvec2 computeParticleUV(in vec2 uv, in float normalizedAge) {\n    #if defined(RENDERER_TSA_FRAME_CURVE) || defined(RENDERER_TSA_FRAME_RANDOM_CURVES)\n        float scaledNormalizedAge = normalizedAge * renderer_TSACycles;\n        float cycleNormalizedAge = scaledNormalizedAge - floor(scaledNormalizedAge);\n        float normalizedFrame = evaluateParticleCurve(renderer_TSAFrameMaxCurve, cycleNormalizedAge);\n        #ifdef RENDERER_TSA_FRAME_RANDOM_CURVES\n            normalizedFrame = mix(evaluateParticleCurve(renderer_TSAFrameMinCurve, cycleNormalizedAge), normalizedFrame, a_Random1.x);\n        #endif\n\n        float frame = floor(normalizedFrame * renderer_TSATillingParams.z);\n\n        float tileRow = frame * renderer_TSATillingParams.x;\n        float tileRowIndex = floor(tileRow);\n        uv.x += tileRow - tileRowIndex;\n        uv.y += tileRowIndex * renderer_TSATillingParams.y;\n    #endif\n    \n    return uv;\n}\n"; // eslint-disable-line
     var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE)\n    #define _FOL_MODULE_ENABLED\n#endif\n\n#ifdef _FOL_MODULE_ENABLED\n    uniform int renderer_FOLSpace;\n\n    #ifdef RENDERER_FOL_CONSTANT_MODE\n        uniform vec3 renderer_FOLMaxConst;\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec3 renderer_FOLMinConst;\n        #endif\n\n    #endif\n\n    #ifdef RENDERER_FOL_CURVE_MODE\n        uniform vec2 renderer_FOLMaxGradientX[4];\n        uniform vec2 renderer_FOLMaxGradientY[4];\n        uniform vec2 renderer_FOLMaxGradientZ[4];\n\n        #ifdef RENDERER_FOL_IS_RANDOM_TWO\n            uniform vec2 renderer_FOLMinGradientX[4];\n            uniform vec2 renderer_FOLMinGradientY[4];\n            uniform vec2 renderer_FOLMinGradientZ[4];\n        #endif\n    #endif\n\n    // (tHat - t1) * (tHat - t1) * (tHat - t1) * (a2 - a1) / ((t2 - t1) * 6.0) + a1 * (tHat - t1) * (tHat - t1) * 0.5 + v1 * (tHat - t1);\n    // to = tHat - t1; tr = t2 - t1\n    float computeDisplacementIntegral(in float to, in float tr, in float a1, in float a2, in float v1) {\n        return to * to * to * (a2 - a1) / (tr * 6.0) + a1 * to * to * 0.5 + v1 * to;\n    }\n\n    float evaluateForceParticleCurveCumulative(in vec2 keys[4], in float normalizedAge, out float velocityCumulative) {\n        float cumulativeValue = 0.0;\n        velocityCumulative = 0.0;\n\n        for (int i = 1; i < 4; i++){\n            vec2 key = keys[i];\n            vec2 lastKey = keys[i - 1];\n            float timeRange = (key.x - lastKey.x) * a_ShapePositionStartLifeTime.w;\n\n            if (key.x >= normalizedAge){\n                float timeOffset = (normalizedAge - lastKey.x) * a_ShapePositionStartLifeTime.w;\n                cumulativeValue += computeDisplacementIntegral(timeOffset, timeRange, lastKey.y, key.y, velocityCumulative);\n\n                float finalAcceleration = mix(lastKey.y, key.y, timeOffset / timeRange);\n                velocityCumulative += 0.5 * timeOffset * (finalAcceleration + lastKey.y);\n                break;\n            } else {  \n                cumulativeValue += computeDisplacementIntegral(timeRange, timeRange, lastKey.y, key.y, velocityCumulative);\n                velocityCumulative += 0.5 * timeRange * (lastKey.y + key.y);\n            }\n        }\n        return cumulativeValue;\n    }\n\n    vec3 computeForcePositionOffset(in float normalizedAge, in float age, out vec3 velocityOffset) {\n        vec3 forcePosition;\n\n        #if defined(RENDERER_FOL_CONSTANT_MODE)\n            vec3 forceAcceleration = renderer_FOLMaxConst;\n\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                forceAcceleration = mix(renderer_FOLMinConst, forceAcceleration, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n\n            velocityOffset = forceAcceleration * age;\n\n            forcePosition = 0.5 * forceAcceleration * age * age;\n        #elif defined(RENDERER_FOL_CURVE_MODE)\n            forcePosition = vec3(\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientX, normalizedAge, velocityOffset.x),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientY, normalizedAge, velocityOffset.y),\n                evaluateForceParticleCurveCumulative(renderer_FOLMaxGradientZ, normalizedAge, velocityOffset.z)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minVelocityOffset;\n\n                forcePosition = vec3(\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientX, normalizedAge, minVelocityOffset.x), forcePosition.x, a_Random2.x),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientY, normalizedAge, minVelocityOffset.y), forcePosition.y, a_Random2.y),\n                    mix(evaluateForceParticleCurveCumulative(renderer_FOLMinGradientZ, normalizedAge, minVelocityOffset.z), forcePosition.z, a_Random2.z)\n                );\n\n                velocityOffset = mix(minVelocityOffset, velocityOffset, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        return forcePosition;\n    }\n#endif"; // eslint-disable-line
     var limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n    uniform int renderer_LVLSpace;\n    uniform float renderer_LVLDampen;\n\n    // Scalar limit\n    #ifndef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_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
     var stretched_billboard = "#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 velocity = rotationByQuaternions(renderer_SizeScale * localVelocity, worldRotation) + worldVelocity;\n\tvec3 cameraUpVector = normalize(velocity);\n\tvec3 direction = normalize(center - camera_Position);\n\tvec3 sideVector = normalize(cross(direction, normalize(velocity)));\n\n\tsideVector = renderer_SizeScale.xzy * sideVector;\n\tcameraUpVector = length(vec3(renderer_SizeScale.x, 0.0, 0.0)) * cameraUpVector;\n\n\tvec2 size = computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n\n\tconst mat2 rotationZHalfPI = mat2(0.0, -1.0, 1.0, 0.0);\n\tcorner = rotationZHalfPI * corner;\n\tcorner.y = corner.y - abs(corner.y);\n\n\tfloat speed = length(velocity); // TODO:\n\tcenter += sign(renderer_SizeScale.x) * (sign(renderer_StretchedBillboardLengthScale) * size.x * corner.x * sideVector\n\t        + (speed * renderer_StretchedBillboardSpeedScale + size.y * renderer_StretchedBillboardLengthScale) * corner.y * cameraUpVector);\n#endif"; // eslint-disable-line
     var vertical_billboard = "#ifdef RENDERER_MODE_VERTICAL_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy; // Billboard模式z轴无效\n\tconst vec3 cameraUpVector = vec3(0.0, 1.0, 0.0);\n\tvec3 sideVector = normalize(cross(camera_Forward, cameraUpVector));\n\n\tfloat rot = radians(computeParticleRotationFloat(a_StartRotation0.x, age, normalizedAge));\n\tfloat c = cos(rot);\n\tfloat s = sin(rot);\n\tmat2 rotation = mat2(c, -s, s, c);\n\tcorner = rotation * corner * cos(0.78539816339744830961566084581988); // TODO:临时缩小cos45,不确定U3D原因\n\tcorner *= computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n\tcenter += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * cameraUpVector);\n#endif"; // eslint-disable-line
@@ -9903,6 +9910,7 @@
         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,
@@ -10742,26 +10750,483 @@
         return ShaderProgram;
     }();
     ShaderProgram._counter = 0;
+    function _array_like_to_array$2(arr, len) {
+        if (len == null || len > arr.length) len = arr.length;
+        for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+        return arr2;
+    }
+    function _unsupported_iterable_to_array$2(o, minLen) {
+        if (!o) return;
+        if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+        var n = Object.prototype.toString.call(o).slice(8, -1);
+        if (n === "Object" && o.constructor) n = o.constructor.name;
+        if (n === "Map" || n === "Set") return Array.from(n);
+        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+    }
+    function _create_for_of_iterator_helper_loose$2(o, allowArrayLike) {
+        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+        if (it) return (it = it.call(o)).next.bind(it);
+        // Fallback for engines without symbol support
+        if (Array.isArray(o) || (it = _unsupported_iterable_to_array$2(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$2(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$2(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$2(valueMacros.keys()), _step1; !(_step1 = _iterator1()).done;){
+                    var name = _step1.value;
+                    macroFirstChars.add(name.charCodeAt(0));
+                }
+                for(var _iterator2 = _create_for_of_iterator_helper_loose$2(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$2(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$2({
                     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$2({
+                    pipelineStage: PipelineStage.Forward
+                }, tagsOrPlatformTarget);
             } else {
+                // Unnamed overload: (vertexSource, fragmentSource, tags?)
                 _this._name = "Default";
                 _this._vertexSource = nameOrVertexSource;
-                _this._fragmentSource = vertexSourceOrFragmentSource;
+                _this._fragmentSource = vertexSourceOrFragmentSourceOrInstructions;
                 tags = _extends$2({
                     pipelineStage: PipelineStage.Forward
                 }, fragmentSourceOrTags);
@@ -10797,15 +11262,16 @@
             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)) {
@@ -10814,23 +11280,31 @@
             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.
      */ var SubShader = /*#__PURE__*/ function(ShaderPart) {
@@ -11571,36 +12045,14 @@
                 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);
@@ -11645,6 +12097,29 @@
         };
         /**
        * @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){
@@ -11665,6 +12140,34 @@
                 }
             }
         };
+        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 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:
@@ -14082,7 +14585,15 @@
        */ _proto._getInvViewProjMat = function _getInvViewProjMat() {
             if (this._isInvViewProjDirty.flag) {
                 this._isInvViewProjDirty.flag = false;
-                Matrix.multiply(this._entity.transform.worldMatrix, this._getInverseProjectionMatrix(), this._invViewProjMat);
+                var matrix = this._invViewProjMat;
+                if (this._isCustomViewMatrix) {
+                    Matrix.invert(this.viewMatrix, matrix);
+                } else {
+                    // Ignore scale, consistent with viewMatrix getter
+                    var transform = this._entity.transform;
+                    Matrix.rotationTranslation(transform.worldRotationQuaternion, transform.worldPosition, matrix);
+                }
+                matrix.multiply(this._getInverseProjectionMatrix());
             }
             return this._invViewProjMat;
         };
@@ -27250,7 +27761,7 @@
         deepClone
     ], Skin.prototype, "inverseBindMatrices", void 0);
     __decorate$1([
-        ignoreClone
+        deepClone
     ], Skin.prototype, "_skinMatrices", void 0);
     __decorate$1([
         ignoreClone
@@ -28241,7 +28752,10 @@
         _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;
@@ -28261,18 +28775,19 @@
             }
         };
         _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);
@@ -31137,7 +31652,7 @@
     var depthOnlyFs = "void main() {\n}"; // eslint-disable-line
     var depthOnlyVs = "#define MATERIAL_OMIT_NORMAL\n#include <common>\n#include <common_vert>\n#include <blendShape_input>\nuniform mat4 camera_VPMat;\n\n\nvoid main() {\n\n    #include <begin_position_vert>\n    #include <blendShape_vert>\n    #include <skinning_vert>\n    #include <position_vert>\n\n}\n"; // eslint-disable-line
     var particleFs = "#include <common>\n\nvarying vec4 v_Color;\nvarying vec2 v_TextureCoordinate;\nuniform sampler2D material_BaseTexture;\nuniform vec4 material_BaseColor;\n \nuniform mediump vec3 material_EmissiveColor;\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n    uniform sampler2D material_EmissiveTexture;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n\tvarying vec4 v_MeshColor;\n#endif\n\nvoid main() {\n\tvec4 color = material_BaseColor * v_Color;\n\n\t#if defined(RENDERER_MODE_MESH) && defined(RENDERER_ENABLE_VERTEXCOLOR)\n\t\tcolor *= v_MeshColor;\n\t#endif\n\n\t#ifdef MATERIAL_HAS_BASETEXTURE\n\t\tcolor *= texture2DSRGB(material_BaseTexture, v_TextureCoordinate);\n\t#endif\n\t\n\t// Emissive\n\tvec3 emissiveRadiance = material_EmissiveColor;\n\t#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n\t\temissiveRadiance *= texture2DSRGB(material_EmissiveTexture, v_TextureCoordinate).rgb;\n\t#endif\n\n\tcolor.rgb += emissiveRadiance;\n\n\tgl_FragColor = color;\n}"; // eslint-disable-line
-    var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\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
     var pbrFs = "#include <common>\n#include <camera_declare>\n#include <transform_declare>\n\n#include <FogFragmentDeclaration>\n#include <PositionClipSpaceDeclaration>\n\n#include <uv_share>\n#include <normal_share>\n#include <color_share>\n#include <worldpos_share>\n\n#include <light_frag_define>\n\n#include <pbr_frag_define>\n#include <pbr_helper>\n\nvoid main() {\n    #include <pbr_frag>\n    #include <FogFragment>\n}\n"; // eslint-disable-line
     var pbrVs = "#include <common>\n#include <common_vert>\n#include <blendShape_input>\n#include <uv_share>\n#include <color_share>\n#include <normal_share>\n#include <worldpos_share>\n\n#include <ShadowVertexDeclaration>\n#include <FogVertexDeclaration>\n#include <PositionClipSpaceDeclaration>\n\nvoid main() {\n\n    #include <begin_position_vert>\n    #include <begin_normal_vert>\n    #include <blendShape_vert>\n    #include <skinning_vert>\n    #include <uv_vert>\n    #include <color_vert>\n    #include <normal_vert>\n    #include <worldpos_vert>\n    #include <position_vert>\n\n    #include <ShadowVertex>\n    #include <FogVertex>\n    #include <PositionClipSpaceVertex>\n}\n"; // eslint-disable-line
@@ -33572,38 +34087,6 @@
     Scene._fogColorProperty = ShaderProperty.getByName("scene_FogColor");
     Scene._fogParamsProperty = ShaderProperty.getByName("scene_FogParams");
     Scene._prefilterdDFGProperty = ShaderProperty.getByName("scene_PrefilteredDFG");
-    function _array_like_to_array$2(arr, len) {
-        if (len == null || len > arr.length) len = arr.length;
-        for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-        return arr2;
-    }
-    function _unsupported_iterable_to_array$2(o, minLen) {
-        if (!o) return;
-        if (typeof o === "string") return _array_like_to_array$2(o, minLen);
-        var n = Object.prototype.toString.call(o).slice(8, -1);
-        if (n === "Object" && o.constructor) n = o.constructor.name;
-        if (n === "Map" || n === "Set") return Array.from(n);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
-    }
-    function _create_for_of_iterator_helper_loose$2(o, allowArrayLike) {
-        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-        if (it) return (it = it.call(o)).next.bind(it);
-        // Fallback for engines without symbol support
-        if (Array.isArray(o) || (it = _unsupported_iterable_to_array$2(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) {
@@ -37928,7 +38411,7 @@
         _inherits$2(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 Vector3(), /** @internal */ _this._generatorBounds = new BoundingBox(), /** @internal */ _this._transformedBounds = new 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 Vector3(), /** @internal */ _this._generatorBounds = new BoundingBox(), /** @internal */ _this._transformedBounds = new BoundingBox(), _this._renderMode = ParticleRenderMode.Billboard;
             _this._onGeneratorParamsChanged = _this._onGeneratorParamsChanged.bind(_this);
             _this.generator = new ParticleGenerator(_this);
             _this._currentRenderModeMacro = ParticleRenderer._billboardModeMacro;
@@ -38527,6 +39010,7 @@
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["GravityModifier"] = 2759560269] = "GravityModifier";
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
         ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
+        ParticleRandomSubSeeds[ParticleRandomSubSeeds["Noise"] = 4105357473] = "Noise";
         return ParticleRandomSubSeeds;
     }({});
     /**
@@ -39902,7 +40386,7 @@
                             return;
                         }
                         this._enabled = value;
-                        this._generator._setTransformFeedback(value);
+                        this._generator._setTransformFeedback();
                         this._generator._renderer._onGeneratorParamsChanged();
                     }
                 }
@@ -40841,6 +41325,297 @@
     __decorate$1([
         ignoreClone
     ], TextureSheetAnimationModule.prototype, "_onTilingChanged", null);
+    /**
+     * Noise module for particle system.
+     * Adds simplex noise-based turbulence displacement to particles.
+     */ var NoiseModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+        _inherits$2(NoiseModule, ParticleGeneratorModule);
+        function NoiseModule(generator) {
+            var _this;
+            _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._noiseRand = new Rand(0, ParticleRandomSubSeeds.Noise), _this._noiseParams = new Vector4(), _this._noiseOctaveParams = new Vector4(), _this._strengthMinConst = new 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$2(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$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_enabledModuleMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_strengthCurveModeMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_strengthIsRandomTwoModeMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_separateAxesModeMacro", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_noiseRand", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_noiseParams", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_noiseOctaveParams", void 0);
+    __decorate$1([
+        ignoreClone
+    ], NoiseModule.prototype, "_strengthMinConst", void 0);
+    __decorate$1([
+        deepClone
+    ], NoiseModule.prototype, "_strengthX", void 0);
+    __decorate$1([
+        deepClone
+    ], NoiseModule.prototype, "_strengthY", void 0);
+    __decorate$1([
+        deepClone
+    ], NoiseModule.prototype, "_strengthZ", void 0);
     /**
      * Velocity over lifetime module.
      */ var VelocityOverLifetimeModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
@@ -41046,6 +41821,7 @@
             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;
@@ -41353,6 +42129,7 @@
             this.sizeOverLifetime._updateShaderData(shaderData);
             this.rotationOverLifetime._updateShaderData(shaderData);
             this.colorOverLifetime._updateShaderData(shaderData);
+            this.noise._updateShaderData(shaderData);
         };
         /**
        * @internal
@@ -41366,16 +42143,19 @@
             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);
                 }
@@ -41425,9 +42205,7 @@
         /**
        * @internal
        */ _proto._cloneTo = function _cloneTo(target) {
-            if (target.limitVelocityOverLifetime.enabled) {
-                target._setTransformFeedback(true);
-            }
+            target._setTransformFeedback();
         };
         /**
        * @internal
@@ -41589,10 +42367,6 @@
             // 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());
@@ -41618,7 +42392,9 @@
             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();
@@ -41906,6 +42682,21 @@
             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);
         };
@@ -42003,6 +42794,9 @@
     __decorate$1([
         deepClone
     ], ParticleGenerator.prototype, "textureSheetAnimation", void 0);
+    __decorate$1([
+        deepClone
+    ], ParticleGenerator.prototype, "noise", void 0);
     __decorate$1([
         ignoreClone
     ], ParticleGenerator.prototype, "_playTime", void 0);
@@ -44196,6 +44990,7 @@
         MeshShape: MeshShape,
         MeshTopology: MeshTopology,
         ModelMesh: ModelMesh,
+        NoiseModule: NoiseModule,
         OverflowMode: OverflowMode,
         PBRMaterial: PBRMaterial,
         ParticleCompositeCurve: ParticleCompositeCurve,
@@ -45386,7 +46181,7 @@
                     };
                 case TextureFormat.ETC2_RGBA5:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : GLCompressedTextureInternalFormat.RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
                         isCompressed: true
                     };
                 case TextureFormat.ETC2_RGBA8:
@@ -45421,27 +46216,27 @@
                     };
                 case TextureFormat.ASTC_5x5:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGBA_ASTC_5X5_KHR,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_ALPHA8_ASTC_5X5_KHR : GLCompressedTextureInternalFormat.RGBA_ASTC_5X5_KHR,
                         isCompressed: true
                     };
                 case TextureFormat.ASTC_6x6:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGBA_ASTC_6X6_KHR,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_ALPHA8_ASTC_6X6_KHR : GLCompressedTextureInternalFormat.RGBA_ASTC_6X6_KHR,
                         isCompressed: true
                     };
                 case TextureFormat.ASTC_8x8:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGBA_ASTC_8X8_KHR,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_ALPHA8_ASTC_8X8_KHR : GLCompressedTextureInternalFormat.RGBA_ASTC_8X8_KHR,
                         isCompressed: true
                     };
                 case TextureFormat.ASTC_10x10:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGBA_ASTC_10X10_KHR,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_ALPHA8_ASTC_10X10_KHR : GLCompressedTextureInternalFormat.RGBA_ASTC_10X10_KHR,
                         isCompressed: true
                     };
                 case TextureFormat.ASTC_12x12:
                     return {
-                        internalFormat: GLCompressedTextureInternalFormat.RGBA_ASTC_12X12_KHR,
+                        internalFormat: isSRGBColorSpace ? GLCompressedTextureInternalFormat.SRGB8_ALPHA8_ASTC_12X12_KHR : GLCompressedTextureInternalFormat.RGBA_ASTC_12X12_KHR,
                         isCompressed: true
                     };
                 case TextureFormat.Depth:
@@ -51701,16 +52496,11 @@
             var isDefaultScene = scene === index;
             var sceneNodes = sceneInfo.nodes || [];
             var sceneRoot;
-            if (sceneNodes.length === 1) {
-                sceneRoot = context.get(GLTFParserType.Entity, sceneNodes[0]);
-            } else {
-                sceneRoot = new Entity(engine, "GLTF_ROOT");
-                // @ts-ignore
-                sceneRoot._markAsTemplate(glTFResource);
-                for(var i = 0; i < sceneNodes.length; i++){
-                    var childEntity = context.get(GLTFParserType.Entity, sceneNodes[i]);
-                    sceneRoot.addChild(childEntity);
-                }
+            sceneRoot = new Entity(engine, "GLTF_ROOT");
+            // @ts-ignore
+            sceneRoot._markAsTemplate(glTFResource);
+            for(var i = 0; i < sceneNodes.length; i++){
+                sceneRoot.addChild(context.get(GLTFParserType.Entity, sceneNodes[i]));
             }
             if (isDefaultScene) {
                 glTFResource._defaultSceneRoot = sceneRoot;
@@ -53233,6 +54023,15 @@
         _proto.load = function load(item, resourceManager) {
             var _this = this;
             var url = item.url;
+            if (url.endsWith(".gsp")) {
+                // @ts-ignore
+                return resourceManager._request(url, _extends({}, item, {
+                    type: "json"
+                })).then(function(data) {
+                    // @ts-ignore - _createFromPrecompiled is @internal
+                    return Shader._createFromPrecompiled(data);
+                });
+            }
             // @ts-ignore
             return resourceManager._request(url, _extends({}, item, {
                 type: "text"
@@ -53256,8 +54055,7 @@
     ShaderLoader._builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
     ShaderLoader = __decorate([
         resourceLoader(AssetType.Shader, [
-            "gs",
-            "gsl"
+            "shader"
         ])
     ], ShaderLoader);
     var PhysicsMaterialLoader = /*#__PURE__*/ function(Loader) {
@@ -53968,7 +54766,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.25";
+    var version = "2.0.0-alpha.26";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);
@@ -54132,6 +54930,7 @@
     exports.MeshShape = MeshShape;
     exports.MeshTopology = MeshTopology;
     exports.ModelMesh = ModelMesh;
+    exports.NoiseModule = NoiseModule;
     exports.OverflowMode = OverflowMode;
     exports.PBRMaterial = PBRMaterial;
     exports.ParserContext = ParserContext;