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

package/dist/main.js

@@ -1327,6 +1327,12 @@ SystemInfo._initialize();
             case TextureFormat.ETC2_RGB:
             case TextureFormat.ETC2_RGBA8:
             case TextureFormat.ASTC_4x4:
+            case TextureFormat.ASTC_5x5:
+            case TextureFormat.ASTC_6x6:
+            case TextureFormat.ASTC_8x8:
+            case TextureFormat.ASTC_10x10:
+            case TextureFormat.ASTC_12x12:
+            case TextureFormat.ETC2_RGBA5:
                 return true;
             default:
                 return false;
@@ -1865,7 +1871,7 @@ SystemInfo._initialize();
         _this = ReferResource.call(this, engine) || this, _this._charInfoMap = {}, _this._space = 1, _this._curX = 1, _this._curY = 1, _this._nextY = 1;
         _this.isGCIgnored = true;
         var format = engine._hardwareRenderer.isWebGL2 ? TextureFormat.R8 : TextureFormat.Alpha8;
-        var texture = new Texture2D(engine, 512, 512, format, false);
+        var texture = new Texture2D(engine, 512, 512, format, false, false);
         texture.filterMode = TextureFilterMode.Bilinear;
         texture.isGCIgnored = true;
         _this.texture = texture;
@@ -4825,37 +4831,9 @@ var begin_viewdir_frag = "#ifdef CAMERA_ORTHOGRAPHIC\n    vec3 V = -camera_Forwa
 
 var mobile_blinnphong_frag = "    #ifdef MATERIAL_HAS_NORMALTEXTURE\n        mat3 tbn = getTBN(gl_FrontFacing);\n        vec3 N = getNormalByNormalTexture(tbn, material_NormalTexture, material_NormalIntensity, v_uv, gl_FrontFacing);\n    #else\n        vec3 N = getNormal(gl_FrontFacing);\n    #endif\n\n    vec3 lightDiffuse = vec3( 0.0, 0.0, 0.0 );\n    vec3 lightSpecular = vec3( 0.0, 0.0, 0.0 );\n    float shadowAttenuation = 1.0;\n\n    #ifdef SCENE_DIRECT_LIGHT_COUNT\n        shadowAttenuation = 1.0;\n        #ifdef SCENE_IS_CALCULATE_SHADOWS\n            shadowAttenuation *= sampleShadowMap();\n        #endif\n\n    DirectLight directionalLight;\n    for( int i = 0; i < SCENE_DIRECT_LIGHT_COUNT; i++ ) {\n        if(!isRendererCulledByLight(renderer_Layer.xy, scene_DirectLightCullingMask[i])){\n            directionalLight.color = scene_DirectLightColor[i];\n            #ifdef SCENE_IS_CALCULATE_SHADOWS\n                if (i == 0) { // Sun light index is always 0\n                    directionalLight.color *= shadowAttenuation;\n                }\n            #endif\n            directionalLight.direction = scene_DirectLightDirection[i];\n    \n            float d = max(dot(N, -directionalLight.direction), 0.0);\n            lightDiffuse += directionalLight.color * d;\n    \n            vec3 halfDir = normalize( V - directionalLight.direction );\n            float s = pow( clamp( dot( N, halfDir ), 0.0, 1.0 ), material_Shininess );\n            lightSpecular += directionalLight.color * s;\n        }\n    }\n\n    #endif\n\n    #ifdef SCENE_POINT_LIGHT_COUNT\n    PointLight pointLight;\n    for( int i = 0; i < SCENE_POINT_LIGHT_COUNT; i++ ) {\n        if(!isRendererCulledByLight(renderer_Layer.xy, scene_PointLightCullingMask[i])){\n            pointLight.color = scene_PointLightColor[i];\n            pointLight.position = scene_PointLightPosition[i];\n            pointLight.distance = scene_PointLightDistance[i];\n\n            vec3 direction = v_pos - pointLight.position;\n            float dist = length( direction );\n            direction /= dist;\n            float decay = clamp(1.0 - pow(dist / pointLight.distance, 4.0), 0.0, 1.0);\n\n            float d =  max( dot( N, -direction ), 0.0 ) * decay;\n            lightDiffuse += pointLight.color * d;\n\n            vec3 halfDir = normalize( V - direction );\n            float s = pow( clamp( dot( N, halfDir ), 0.0, 1.0 ), material_Shininess )  * decay;\n            lightSpecular += pointLight.color * s;\n        }\n    }\n\n    #endif\n\n    #ifdef SCENE_SPOT_LIGHT_COUNT\n    SpotLight spotLight;\n    for( int i = 0; i < SCENE_SPOT_LIGHT_COUNT; i++) {\n        if(!isRendererCulledByLight(renderer_Layer.xy, scene_SpotLightCullingMask[i])){\n            spotLight.color = scene_SpotLightColor[i];\n            spotLight.position = scene_SpotLightPosition[i];\n            spotLight.direction = scene_SpotLightDirection[i];\n            spotLight.distance = scene_SpotLightDistance[i];\n            spotLight.angleCos = scene_SpotLightAngleCos[i];\n            spotLight.penumbraCos = scene_SpotLightPenumbraCos[i];\n\n            vec3 direction = spotLight.position - v_pos;\n            float lightDistance = length( direction );\n            direction /= lightDistance;\n            float angleCos = dot( direction, -spotLight.direction );\n            float decay = clamp(1.0 - pow(lightDistance/spotLight.distance, 4.0), 0.0, 1.0);\n            float spotEffect = smoothstep( spotLight.penumbraCos, spotLight.angleCos, angleCos );\n            float decayTotal = decay * spotEffect;\n            float d = max( dot( N, direction ), 0.0 )  * decayTotal;\n            lightDiffuse += spotLight.color * d;\n\n            vec3 halfDir = normalize( V + direction );\n            float s = pow( clamp( dot( N, halfDir ), 0.0, 1.0 ), material_Shininess ) * decayTotal;\n            lightSpecular += spotLight.color * s;\n        }\n    }\n\n    #endif\n\n    diffuse *= vec4( lightDiffuse, 1.0 );\n    specular *= vec4( lightSpecular, 1.0 );\n\n    #ifdef MATERIAL_IS_ALPHA_CUTOFF\n        if( diffuse.a < material_AlphaCutoff ) {\n            discard;\n        }\n    #endif\n"; // eslint-disable-line
 
-var noise_cellular = "#include <noise_cellular_2D>\n#include <noise_cellular_3D>\n#include <noise_cellular_2x2>\n#include <noise_cellular_2x2x2>\n"; // eslint-disable-line
-
-var noise_cellular_2D = "\n// Cellular noise (\"Worley noise\") in 2D in GLSL.\n// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.\n// This code is released under the conditions of the MIT license.\n// See LICENSE file for details.\n// https://github.com/stegu/webgl-noise\n\n// Cellular noise, returning F1 and F2 in a vec2.\n// Standard 3x3 search window for good F1 and F2 values\nvec2 cellular( vec2 P ) {\n\n\tvec2 Pi = mod289( floor( P ) );\n \tvec2 Pf = fract( P );\n\tvec3 oi = vec3( -1.0, 0.0, 1.0);\n\tvec3 of = vec3( -0.5, 0.5, 1.5);\n\tvec3 px = permute( Pi.x + oi );\n\tvec3 p = permute( px.x + Pi.y + oi ); // p11, p12, p13\n\tvec3 ox = fract( p * K ) - Ko;\n\tvec3 oy = mod7( floor( p * K ) ) * K - Ko;\n\tvec3 dx = Pf.x + 0.5 + jitter * ox;\n\tvec3 dy = Pf.y - of + jitter * oy;\n\tvec3 d1 = dx * dx + dy * dy; // d11, d12 and d13, squared\n\tp = permute( px.y + Pi.y + oi ); // p21, p22, p23\n\tox = fract( p * K ) - Ko;\n\toy = mod7( floor( p * K ) ) * K - Ko;\n\tdx = Pf.x - 0.5 + jitter * ox;\n\tdy = Pf.y - of + jitter * oy;\n\tvec3 d2 = dx * dx + dy * dy; // d21, d22 and d23, squared\n\tp = permute( px.z + Pi.y + oi ); // p31, p32, p33\n\tox = fract( p * K ) - Ko;\n\toy = mod7( floor( p * K ) ) * K - Ko;\n\tdx = Pf.x - 1.5 + jitter * ox;\n\tdy = Pf.y - of + jitter * oy;\n\tvec3 d3 = dx * dx + dy * dy; // d31, d32 and d33, squared\n\t// Sort out the two smallest distances (F1, F2)\n\tvec3 d1a = min( d1, d2 );\n\td2 = max( d1, d2 ); // Swap to keep candidates for F2\n\td2 = min( d2, d3 ); // neither F1 nor F2 are now in d3\n\td1 = min( d1a, d2 ); // F1 is now in d1\n\td2 = max( d1a, d2 ); // Swap to keep candidates for F2\n\td1.xy = ( d1.x < d1.y ) ? d1.xy : d1.yx; // Swap if smaller\n\td1.xz = ( d1.x < d1.z ) ? d1.xz : d1.zx; // F1 is in d1.x\n\td1.yz = min( d1.yz, d2.yz ); // F2 is now not in d2.yz\n\td1.y = min( d1.y, d1.z ); // nor in  d1.z\n\td1.y = min( d1.y, d2.x ); // F2 is in d1.y, we're done.\n\treturn sqrt( d1.xy );\n\n}\n"; // eslint-disable-line
-
-var noise_cellular_2x2 = "\n// Cellular noise (\"Worley noise\") in 2D in GLSL.\n// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.\n// This code is released under the conditions of the MIT license.\n// See LICENSE file for details.\n// https://github.com/stegu/webgl-noise\n\n// Cellular noise, returning F1 and F2 in a vec2.\n// Speeded up by using 2x2 search window instead of 3x3,\n// at the expense of some strong pattern artifacts.\n// F2 is often wrong and has sharp discontinuities.\n// If you need a smooth F2, use the slower 3x3 version.\n// F1 is sometimes wrong, too, but OK for most purposes.\nvec2 cellular2x2( vec2 P ) {\n\n\tvec2 Pi = mod289( floor( P ) );\n \tvec2 Pf = fract( P );\n\tvec4 Pfx = Pf.x + vec4( -0.5, -1.5, -0.5, -1.5 );\n\tvec4 Pfy = Pf.y + vec4( -0.5, -0.5, -1.5, -1.5 );\n\tvec4 p = permute( Pi.x + vec4( 0.0, 1.0, 0.0, 1.0 ) );\n\tp = permute( p + Pi.y + vec4( 0.0, 0.0, 1.0, 1.0 ) );\n\tvec4 ox = mod7( p ) * K + Kd2;\n\tvec4 oy = mod7( floor( p * K ) ) * K + Kd2;\n\tvec4 dx = Pfx + jitter1 * ox;\n\tvec4 dy = Pfy + jitter1 * oy;\n\tvec4 d = dx * dx + dy * dy; // d11, d12, d21 and d22, squared\n\n\t// Do it right and find both F1 and F2\n\td.xy = ( d.x < d.y ) ? d.xy : d.yx; // Swap if smaller\n\td.xz = ( d.x < d.z ) ? d.xz : d.zx;\n\td.xw = ( d.x < d.w ) ? d.xw : d.wx;\n\td.y = min( d.y, d.z );\n\td.y = min( d.y, d.w );\n\treturn sqrt( d.xy );\n\n}\n"; // eslint-disable-line
-
-var noise_cellular_2x2x2 = "\n// Cellular noise (\"Worley noise\") in 3D in GLSL.\n// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.\n// This code is released under the conditions of the MIT license.\n// See LICENSE file for details.\n// https://github.com/stegu/webgl-noise\n\n// Cellular noise, returning F1 and F2 in a vec2.\n// Speeded up by using 2x2x2 search window instead of 3x3x3,\n// at the expense of some pattern artifacts.\n// F2 is often wrong and has sharp discontinuities.\n// If you need a good F2, use the slower 3x3x3 version.\nvec2 cellular2x2x2(vec3 P) {\n\n\tvec3 Pi = mod289( floor( P ) );\n \tvec3 Pf = fract( P );\n\tvec4 Pfx = Pf.x + vec4( 0.0, -1.0, 0.0, -1.0 );\n\tvec4 Pfy = Pf.y + vec4( 0.0, 0.0, -1.0, -1.0 );\n\tvec4 p = permute( Pi.x + vec4( 0.0, 1.0, 0.0, 1.0 ) );\n\tp = permute( p + Pi.y + vec4( 0.0, 0.0, 1.0, 1.0 ) );\n\tvec4 p1 = permute( p + Pi.z ); // z+0\n\tvec4 p2 = permute( p + Pi.z + vec4( 1.0 ) ); // z+1\n\tvec4 ox1 = fract( p1 * K ) - Ko;\n\tvec4 oy1 = mod7( floor( p1 * K ) ) * K - Ko;\n\tvec4 oz1 = floor( p1 * K2 ) * Kz - Kzo; // p1 < 289 guaranteed\n\tvec4 ox2 = fract( p2 * K ) - Ko;\n\tvec4 oy2 = mod7( floor( p2 * K ) ) * K - Ko;\n\tvec4 oz2 = floor( p2 * K2 ) * Kz - Kzo;\n\tvec4 dx1 = Pfx + jitter1 * ox1;\n\tvec4 dy1 = Pfy + jitter1 * oy1;\n\tvec4 dz1 = Pf.z + jitter1 * oz1;\n\tvec4 dx2 = Pfx + jitter1 * ox2;\n\tvec4 dy2 = Pfy + jitter1 * oy2;\n\tvec4 dz2 = Pf.z - 1.0 + jitter1 * oz2;\n\tvec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0\n\tvec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1\n\n\t// Do it right and sort out both F1 and F2\n\tvec4 d = min( d1, d2 ); // F1 is now in d\n\td2 = max( d1, d2 ); // Make sure we keep all candidates for F2\n\td.xy = ( d.x < d.y ) ? d.xy : d.yx; // Swap smallest to d.x\n\td.xz = ( d.x < d.z ) ? d.xz : d.zx;\n\td.xw = ( d.x < d.w ) ? d.xw : d.wx; // F1 is now in d.x\n\td.yzw = min( d.yzw, d2.yzw ); // F2 now not in d2.yzw\n\td.y = min( d.y, d.z ); // nor in d.z\n\td.y = min( d.y, d.w ); // nor in d.w\n\td.y = min( d.y, d2.x ); // F2 is now in d.y\n\treturn sqrt( d.xy ); // F1 and F2\n\n}\n"; // eslint-disable-line
-
-var noise_cellular_3D = "\n// Cellular noise (\"Worley noise\") in 3D in GLSL.\n// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.\n// This code is released under the conditions of the MIT license.\n// See LICENSE file for details.\n// https://github.com/stegu/webgl-noise\n\n// Cellular noise, returning F1 and F2 in a vec2.\n// 3x3x3 search region for good F2 everywhere, but a lot\n// slower than the 2x2x2 version.\n// The code below is a bit scary even to its author,\n// but it has at least half decent performance on a\n// modern GPU. In any case, it beats any software\n// implementation of Worley noise hands down.\n\nvec2 cellular( vec3 P ) {\n\n\tvec3 Pi = mod289( floor( P ) );\n \tvec3 Pf = fract( P ) - 0.5;\n\n\tvec3 Pfx = Pf.x + vec3( 1.0, 0.0, -1.0 );\n\tvec3 Pfy = Pf.y + vec3( 1.0, 0.0, -1.0 );\n\tvec3 Pfz = Pf.z + vec3( 1.0, 0.0, -1.0 );\n\n\tvec3 p = permute( Pi.x + vec3( -1.0, 0.0, 1.0 ) );\n\tvec3 p1 = permute( p + Pi.y - 1.0 );\n\tvec3 p2 = permute( p + Pi.y );\n\tvec3 p3 = permute( p + Pi.y + 1.0 );\n\n\tvec3 p11 = permute( p1 + Pi.z - 1.0 );\n\tvec3 p12 = permute( p1 + Pi.z );\n\tvec3 p13 = permute( p1 + Pi.z + 1.0 );\n\n\tvec3 p21 = permute( p2 + Pi.z - 1.0 );\n\tvec3 p22 = permute( p2 + Pi.z );\n\tvec3 p23 = permute( p2 + Pi.z + 1.0 );\n\n\tvec3 p31 = permute( p3 + Pi.z - 1.0 );\n\tvec3 p32 = permute( p3 + Pi.z );\n\tvec3 p33 = permute( p3 + Pi.z + 1.0 );\n\n\tvec3 ox11 = fract( p11 * K ) - Ko;\n\tvec3 oy11 = mod7( floor( p11 * K ) ) * K - Ko;\n\tvec3 oz11 = floor( p11 * K2 ) * Kz - Kzo; // p11 < 289 guaranteed\n\n\tvec3 ox12 = fract( p12 * K ) - Ko;\n\tvec3 oy12 = mod7( floor( p12 * K ) ) * K - Ko;\n\tvec3 oz12 = floor( p12 * K2 ) * Kz - Kzo;\n\n\tvec3 ox13 = fract( p13 * K ) - Ko;\n\tvec3 oy13 = mod7( floor( p13 * K ) ) * K - Ko;\n\tvec3 oz13 = floor( p13 * K2 ) * Kz - Kzo;\n\n\tvec3 ox21 = fract( p21 * K ) - Ko;\n\tvec3 oy21 = mod7( floor( p21 * K ) ) * K - Ko;\n\tvec3 oz21 = floor( p21 * K2 ) * Kz - Kzo;\n\n\tvec3 ox22 = fract( p22 * K ) - Ko;\n\tvec3 oy22 = mod7( floor( p22 * K ) ) * K - Ko;\n\tvec3 oz22 = floor( p22 * K2 ) * Kz - Kzo;\n\n\tvec3 ox23 = fract( p23 * K ) - Ko;\n\tvec3 oy23 = mod7( floor( p23 * K ) ) * K - Ko;\n\tvec3 oz23 = floor( p23 * K2 ) * Kz - Kzo;\n\n\tvec3 ox31 = fract( p31 * K ) - Ko;\n\tvec3 oy31 = mod7( floor( p31 * K ) ) * K - Ko;\n\tvec3 oz31 = floor( p31 * K2 ) * Kz - Kzo;\n\n\tvec3 ox32 = fract( p32 * K ) - Ko;\n\tvec3 oy32 = mod7( floor( p32 * K ) ) * K - Ko;\n\tvec3 oz32 = floor( p32 * K2 ) * Kz - Kzo;\n\n\tvec3 ox33 = fract( p33 * K ) - Ko;\n\tvec3 oy33 = mod7( floor( p33 * K ) ) * K - Ko;\n\tvec3 oz33 = floor( p33 * K2 ) * Kz - Kzo;\n\n\tvec3 dx11 = Pfx + jitter * ox11;\n\tvec3 dy11 = Pfy.x + jitter * oy11;\n\tvec3 dz11 = Pfz.x + jitter * oz11;\n\n\tvec3 dx12 = Pfx + jitter * ox12;\n\tvec3 dy12 = Pfy.x + jitter * oy12;\n\tvec3 dz12 = Pfz.y + jitter * oz12;\n\n\tvec3 dx13 = Pfx + jitter * ox13;\n\tvec3 dy13 = Pfy.x + jitter * oy13;\n\tvec3 dz13 = Pfz.z + jitter * oz13;\n\n\tvec3 dx21 = Pfx + jitter * ox21;\n\tvec3 dy21 = Pfy.y + jitter * oy21;\n\tvec3 dz21 = Pfz.x + jitter * oz21;\n\n\tvec3 dx22 = Pfx + jitter * ox22;\n\tvec3 dy22 = Pfy.y + jitter * oy22;\n\tvec3 dz22 = Pfz.y + jitter * oz22;\n\n\tvec3 dx23 = Pfx + jitter * ox23;\n\tvec3 dy23 = Pfy.y + jitter * oy23;\n\tvec3 dz23 = Pfz.z + jitter * oz23;\n\n\tvec3 dx31 = Pfx + jitter * ox31;\n\tvec3 dy31 = Pfy.z + jitter * oy31;\n\tvec3 dz31 = Pfz.x + jitter * oz31;\n\n\tvec3 dx32 = Pfx + jitter * ox32;\n\tvec3 dy32 = Pfy.z + jitter * oy32;\n\tvec3 dz32 = Pfz.y + jitter * oz32;\n\n\tvec3 dx33 = Pfx + jitter * ox33;\n\tvec3 dy33 = Pfy.z + jitter * oy33;\n\tvec3 dz33 = Pfz.z + jitter * oz33;\n\n\tvec3 d11 = dx11 * dx11 + dy11 * dy11 + dz11 * dz11;\n\tvec3 d12 = dx12 * dx12 + dy12 * dy12 + dz12 * dz12;\n\tvec3 d13 = dx13 * dx13 + dy13 * dy13 + dz13 * dz13;\n\tvec3 d21 = dx21 * dx21 + dy21 * dy21 + dz21 * dz21;\n\tvec3 d22 = dx22 * dx22 + dy22 * dy22 + dz22 * dz22;\n\tvec3 d23 = dx23 * dx23 + dy23 * dy23 + dz23 * dz23;\n\tvec3 d31 = dx31 * dx31 + dy31 * dy31 + dz31 * dz31;\n\tvec3 d32 = dx32 * dx32 + dy32 * dy32 + dz32 * dz32;\n\tvec3 d33 = dx33 * dx33 + dy33 * dy33 + dz33 * dz33;\n\n\t// Do it right and sort out both F1 and F2\n\tvec3 d1a = min( d11, d12 );\n\td12 = max( d11, d12 );\n\td11 = min( d1a, d13 ); // Smallest now not in d12 or d13\n\td13 = max( d1a, d13 );\n\td12 = min( d12, d13 ); // 2nd smallest now not in d13\n\tvec3 d2a = min( d21, d22 );\n\td22 = max( d21, d22 );\n\td21 = min( d2a, d23 ); // Smallest now not in d22 or d23\n\td23 = max( d2a, d23 );\n\td22 = min( d22, d23 ); // 2nd smallest now not in d23\n\tvec3 d3a = min( d31, d32 );\n\td32 = max( d31, d32 );\n\td31 = min( d3a, d33 ); // Smallest now not in d32 or d33\n\td33 = max( d3a, d33 );\n\td32 = min( d32, d33 ); // 2nd smallest now not in d33\n\tvec3 da = min( d11, d21 );\n\td21 = max( d11, d21 );\n\td11 = min( da, d31 ); // Smallest now in d11\n\td31 = max( da, d31 ); // 2nd smallest now not in d31\n\td11.xy = ( d11.x < d11.y ) ? d11.xy : d11.yx;\n\td11.xz = ( d11.x < d11.z ) ? d11.xz : d11.zx; // d11.x now smallest\n\td12 = min( d12, d21 ); // 2nd smallest now not in d21\n\td12 = min( d12, d22 ); // nor in d22\n\td12 = min( d12, d31 ); // nor in d31\n\td12 = min( d12, d32 ); // nor in d32\n\td11.yz = min( d11.yz, d12.xy ); // nor in d12.yz\n\td11.y = min( d11.y, d12.z ); // Only two more to go\n\td11.y = min( d11.y, d11.z ); // Done! (Phew! )\n\treturn sqrt( d11.xy ); // F1, F2\n\n}\n"; // eslint-disable-line
-
-var noise_common = "// Modulo 289 without a division (only multiplications)\nvec4 mod289( vec4 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nvec3 mod289( vec3 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nvec2 mod289( vec2 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nfloat mod289( float x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\n// Modulo 7 without a division\nvec4 mod7( vec4 x ) {\n\n    return x - floor( x * ( 1.0 / 7.0 ) ) * 7.0;\n\n}\n\nvec3 mod7( vec3 x ) {\n\n    return x - floor( x * ( 1.0 / 7.0 ) ) * 7.0;\n\n}\n\n// Permutation polynomial: (34x^2 + x) mod 289\nvec4 permute( vec4 x ) {\n\n    return mod289( ( 34.0 * x + 1.0 ) * x);\n\n}\n\nvec3 permute( vec3 x ) {\n\n    return mod289( ( 34.0 * x + 1.0 ) * x );\n\n}\n\nfloat permute( float x ) {\n\n  return mod289( ( ( x * 34.0 ) + 1.0 ) * x );\n\n}\n\nvec4 taylorInvSqrt( vec4 r ) {\n\n    return 1.79284291400159 - 0.85373472095314 * r;\n\n}\n\nfloat taylorInvSqrt( float r ) {\n\n    return 1.79284291400159 - 0.85373472095314 * r;\n\n}\n\nvec4 fade( vec4 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\nvec3 fade( vec3 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\nvec2 fade( vec2 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\n#define K 0.142857142857 // 1/7\n#define Ko 0.428571428571 // 1/2-K/2\n#define K2 0.020408163265306 // 1/(7*7)\n#define Kd2 0.0714285714285 // K/2\n#define Kz 0.166666666667 // 1/6\n#define Kzo 0.416666666667 // 1/2-1/6*2\n#define jitter 1.0 // smaller jitter gives more regular pattern\n#define jitter1 0.8 // smaller jitter gives less errors in F1 F2\n"; // eslint-disable-line
-
-var noise_perlin = "#include <noise_perlin_2D>\n#include <noise_perlin_3D>\n#include <noise_perlin_4D>\n"; // eslint-disable-line
-
-var noise_perlin_2D = "//\n// GLSL textureless classic 2D noise \"cnoise\",\n// with an RSL-style periodic variant \"pnoise\".\n// Author:  Stefan Gustavson (stefan.gustavson@liu.se)\n// Version: 2011-08-22\n//\n// Many thanks to Ian McEwan of Ashima Arts for the\n// ideas for permutation and gradient selection.\n//\n// Copyright (c) 2011 Stefan Gustavson. All rights reserved.\n// Distributed under the MIT license. See LICENSE file.\n// https://github.com/stegu/webgl-noise\n//\n\n// Classic Perlin noise\nfloat perlin( vec2 P ) {\n\n    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);\n    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);\n    Pi = mod289(Pi); // To avoid truncation effects in permutation\n    vec4 ix = Pi.xzxz;\n    vec4 iy = Pi.yyww;\n    vec4 fx = Pf.xzxz;\n    vec4 fy = Pf.yyww;\n\n    vec4 i = permute(permute(ix) + iy);\n\n    vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;\n    vec4 gy = abs(gx) - 0.5 ;\n    vec4 tx = floor(gx + 0.5);\n    gx = gx - tx;\n\n    vec2 g00 = vec2(gx.x,gy.x);\n    vec2 g10 = vec2(gx.y,gy.y);\n    vec2 g01 = vec2(gx.z,gy.z);\n    vec2 g11 = vec2(gx.w,gy.w);\n\n    vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));\n    g00 *= norm.x;\n    g01 *= norm.y;\n    g10 *= norm.z;\n    g11 *= norm.w;\n\n    float n00 = dot(g00, vec2(fx.x, fy.x));\n    float n10 = dot(g10, vec2(fx.y, fy.y));\n    float n01 = dot(g01, vec2(fx.z, fy.z));\n    float n11 = dot(g11, vec2(fx.w, fy.w));\n\n    vec2 fade_xy = fade(Pf.xy);\n    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);\n    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);\n    return 2.3 * n_xy;\n\n}\n\n// Classic Perlin noise, periodic variant\nfloat perlin( vec2 P, vec2 rep ) {\n\n    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);\n    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);\n    Pi = mod(Pi, rep.xyxy); // To create noise with explicit period\n    Pi = mod289(Pi);        // To avoid truncation effects in permutation\n    vec4 ix = Pi.xzxz;\n    vec4 iy = Pi.yyww;\n    vec4 fx = Pf.xzxz;\n    vec4 fy = Pf.yyww;\n\n    vec4 i = permute(permute(ix) + iy);\n\n    vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;\n    vec4 gy = abs(gx) - 0.5 ;\n    vec4 tx = floor(gx + 0.5);\n    gx = gx - tx;\n\n    vec2 g00 = vec2(gx.x,gy.x);\n    vec2 g10 = vec2(gx.y,gy.y);\n    vec2 g01 = vec2(gx.z,gy.z);\n    vec2 g11 = vec2(gx.w,gy.w);\n\n    vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));\n    g00 *= norm.x;\n    g01 *= norm.y;\n    g10 *= norm.z;\n    g11 *= norm.w;\n\n    float n00 = dot(g00, vec2(fx.x, fy.x));\n    float n10 = dot(g10, vec2(fx.y, fy.y));\n    float n01 = dot(g01, vec2(fx.z, fy.z));\n    float n11 = dot(g11, vec2(fx.w, fy.w));\n\n    vec2 fade_xy = fade(Pf.xy);\n    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);\n    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);\n    return 2.3 * n_xy;\n\n}\n"; // eslint-disable-line
-
-var noise_perlin_3D = "//\n// GLSL textureless classic 3D noise \"cnoise\",\n// with an RSL-style periodic variant \"pnoise\".\n// Author:  Stefan Gustavson (stefan.gustavson@liu.se)\n// Version: 2011-10-11\n//\n// Many thanks to Ian McEwan of Ashima Arts for the\n// ideas for permutation and gradient selection.\n//\n// Copyright (c) 2011 Stefan Gustavson. All rights reserved.\n// Distributed under the MIT license. See LICENSE file.\n// https://github.com/stegu/webgl-noise\n//\n\n// Classic Perlin noise\nfloat perlin( vec3 P ) {\n\n    vec3 Pi0 = floor(P); // Integer part for indexing\n    vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1\n    Pi0 = mod289(Pi0);\n    Pi1 = mod289(Pi1);\n    vec3 Pf0 = fract(P); // Fractional part for interpolation\n    vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0\n    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);\n    vec4 iy = vec4(Pi0.yy, Pi1.yy);\n    vec4 iz0 = Pi0.zzzz;\n    vec4 iz1 = Pi1.zzzz;\n\n    vec4 ixy = permute(permute(ix) + iy);\n    vec4 ixy0 = permute(ixy + iz0);\n    vec4 ixy1 = permute(ixy + iz1);\n\n    vec4 gx0 = ixy0 * (1.0 / 7.0);\n    vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;\n    gx0 = fract(gx0);\n    vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);\n    vec4 sz0 = step(gz0, vec4(0.0));\n    gx0 -= sz0 * (step(0.0, gx0) - 0.5);\n    gy0 -= sz0 * (step(0.0, gy0) - 0.5);\n\n    vec4 gx1 = ixy1 * (1.0 / 7.0);\n    vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;\n    gx1 = fract(gx1);\n    vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);\n    vec4 sz1 = step(gz1, vec4(0.0));\n    gx1 -= sz1 * (step(0.0, gx1) - 0.5);\n    gy1 -= sz1 * (step(0.0, gy1) - 0.5);\n\n    vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);\n    vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);\n    vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);\n    vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);\n    vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);\n    vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);\n    vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);\n    vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);\n\n    vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));\n    g000 *= norm0.x;\n    g010 *= norm0.y;\n    g100 *= norm0.z;\n    g110 *= norm0.w;\n    vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));\n    g001 *= norm1.x;\n    g011 *= norm1.y;\n    g101 *= norm1.z;\n    g111 *= norm1.w;\n\n    float n000 = dot(g000, Pf0);\n    float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));\n    float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));\n    float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));\n    float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));\n    float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));\n    float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));\n    float n111 = dot(g111, Pf1);\n\n    vec3 fade_xyz = fade(Pf0);\n    vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);\n    vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);\n    float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);\n    return 2.2 * n_xyz;\n\n}\n\n// Classic Perlin noise, periodic variant\nfloat perlin( vec3 P, vec3 rep ) {\n\n    vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period\n    vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period\n    Pi0 = mod289(Pi0);\n    Pi1 = mod289(Pi1);\n    vec3 Pf0 = fract(P); // Fractional part for interpolation\n    vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0\n    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);\n    vec4 iy = vec4(Pi0.yy, Pi1.yy);\n    vec4 iz0 = Pi0.zzzz;\n    vec4 iz1 = Pi1.zzzz;\n\n    vec4 ixy = permute(permute(ix) + iy);\n    vec4 ixy0 = permute(ixy + iz0);\n    vec4 ixy1 = permute(ixy + iz1);\n\n    vec4 gx0 = ixy0 * (1.0 / 7.0);\n    vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;\n    gx0 = fract(gx0);\n    vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);\n    vec4 sz0 = step(gz0, vec4(0.0));\n    gx0 -= sz0 * (step(0.0, gx0) - 0.5);\n    gy0 -= sz0 * (step(0.0, gy0) - 0.5);\n\n    vec4 gx1 = ixy1 * (1.0 / 7.0);\n    vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;\n    gx1 = fract(gx1);\n    vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);\n    vec4 sz1 = step(gz1, vec4(0.0));\n    gx1 -= sz1 * (step(0.0, gx1) - 0.5);\n    gy1 -= sz1 * (step(0.0, gy1) - 0.5);\n\n    vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);\n    vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);\n    vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);\n    vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);\n    vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);\n    vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);\n    vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);\n    vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);\n\n    vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));\n    g000 *= norm0.x;\n    g010 *= norm0.y;\n    g100 *= norm0.z;\n    g110 *= norm0.w;\n    vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));\n    g001 *= norm1.x;\n    g011 *= norm1.y;\n    g101 *= norm1.z;\n    g111 *= norm1.w;\n\n    float n000 = dot(g000, Pf0);\n    float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));\n    float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));\n    float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));\n    float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));\n    float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));\n    float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));\n    float n111 = dot(g111, Pf1);\n\n    vec3 fade_xyz = fade(Pf0);\n    vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);\n    vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);\n    float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);\n    return 2.2 * n_xyz;\n\n}\n"; // eslint-disable-line
+var noise_common = "// Common helper functions for simplex noise.\n// Algorithm: Ken Perlin, \"Noise hardware\" (2001) — simplex lattice improvement over classic Perlin noise (1985).\n// GLSL implementation: Ian McEwan, Ashima Arts (MIT License) — https://github.com/ashima/webgl-noise\n\n// Modulo 289 without a division (only multiplications)\nvec4 mod289( vec4 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nvec3 mod289( vec3 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nvec2 mod289( vec2 x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\nfloat mod289( float x ) {\n\n    return x - floor( x * ( 1.0 / 289.0 ) ) * 289.0;\n\n}\n\n// Modulo 7 without a division\nvec4 mod7( vec4 x ) {\n\n    return x - floor( x * ( 1.0 / 7.0 ) ) * 7.0;\n\n}\n\nvec3 mod7( vec3 x ) {\n\n    return x - floor( x * ( 1.0 / 7.0 ) ) * 7.0;\n\n}\n\n// Permutation polynomial: (34x^2 + x) mod 289\nvec4 permute( vec4 x ) {\n\n    return mod289( ( 34.0 * x + 1.0 ) * x);\n\n}\n\nvec3 permute( vec3 x ) {\n\n    return mod289( ( 34.0 * x + 1.0 ) * x );\n\n}\n\nfloat permute( float x ) {\n\n  return mod289( ( ( x * 34.0 ) + 1.0 ) * x );\n\n}\n\nvec4 taylorInvSqrt( vec4 r ) {\n\n    return 1.79284291400159 - 0.85373472095314 * r;\n\n}\n\nfloat taylorInvSqrt( float r ) {\n\n    return 1.79284291400159 - 0.85373472095314 * r;\n\n}\n\nvec4 fade( vec4 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\nvec3 fade( vec3 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\nvec2 fade( vec2 t ) {\n\n    return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );\n\n}\n\n#define K 0.142857142857 // 1/7\n#define Ko 0.428571428571 // 1/2-K/2\n#define K2 0.020408163265306 // 1/(7*7)\n#define Kd2 0.0714285714285 // K/2\n#define Kz 0.166666666667 // 1/6\n#define Kzo 0.416666666667 // 1/2-1/6*2\n#define jitter 1.0 // smaller jitter gives more regular pattern\n#define jitter1 0.8 // smaller jitter gives less errors in F1 F2\n"; // eslint-disable-line
 
-var noise_perlin_4D = "//\n// GLSL textureless classic 4D noise \"cnoise\",\n// with an RSL-style periodic variant \"pnoise\".\n// Author:  Stefan Gustavson (stefan.gustavson@liu.se)\n// Version: 2011-08-22\n//\n// Many thanks to Ian McEwan of Ashima Arts for the\n// ideas for permutation and gradient selection.\n//\n// Copyright (c) 2011 Stefan Gustavson. All rights reserved.\n// Distributed under the MIT license. See LICENSE file.\n// https://github.com/stegu/webgl-noise\n//\n\n// Classic Perlin noise\nfloat perlin( vec4 P ) {\n\n    vec4 Pi0 = floor(P); // Integer part for indexing\n    vec4 Pi1 = Pi0 + 1.0; // Integer part + 1\n    Pi0 = mod289(Pi0);\n    Pi1 = mod289(Pi1);\n    vec4 Pf0 = fract(P); // Fractional part for interpolation\n    vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0\n    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);\n    vec4 iy = vec4(Pi0.yy, Pi1.yy);\n    vec4 iz0 = vec4(Pi0.zzzz);\n    vec4 iz1 = vec4(Pi1.zzzz);\n    vec4 iw0 = vec4(Pi0.wwww);\n    vec4 iw1 = vec4(Pi1.wwww);\n\n    vec4 ixy = permute(permute(ix) + iy);\n    vec4 ixy0 = permute(ixy + iz0);\n    vec4 ixy1 = permute(ixy + iz1);\n    vec4 ixy00 = permute(ixy0 + iw0);\n    vec4 ixy01 = permute(ixy0 + iw1);\n    vec4 ixy10 = permute(ixy1 + iw0);\n    vec4 ixy11 = permute(ixy1 + iw1);\n\n    vec4 gx00 = ixy00 * (1.0 / 7.0);\n    vec4 gy00 = floor(gx00) * (1.0 / 7.0);\n    vec4 gz00 = floor(gy00) * (1.0 / 6.0);\n    gx00 = fract(gx00) - 0.5;\n    gy00 = fract(gy00) - 0.5;\n    gz00 = fract(gz00) - 0.5;\n    vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00);\n    vec4 sw00 = step(gw00, vec4(0.0));\n    gx00 -= sw00 * (step(0.0, gx00) - 0.5);\n    gy00 -= sw00 * (step(0.0, gy00) - 0.5);\n\n    vec4 gx01 = ixy01 * (1.0 / 7.0);\n    vec4 gy01 = floor(gx01) * (1.0 / 7.0);\n    vec4 gz01 = floor(gy01) * (1.0 / 6.0);\n    gx01 = fract(gx01) - 0.5;\n    gy01 = fract(gy01) - 0.5;\n    gz01 = fract(gz01) - 0.5;\n    vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01);\n    vec4 sw01 = step(gw01, vec4(0.0));\n    gx01 -= sw01 * (step(0.0, gx01) - 0.5);\n    gy01 -= sw01 * (step(0.0, gy01) - 0.5);\n\n    vec4 gx10 = ixy10 * (1.0 / 7.0);\n    vec4 gy10 = floor(gx10) * (1.0 / 7.0);\n    vec4 gz10 = floor(gy10) * (1.0 / 6.0);\n    gx10 = fract(gx10) - 0.5;\n    gy10 = fract(gy10) - 0.5;\n    gz10 = fract(gz10) - 0.5;\n    vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10);\n    vec4 sw10 = step(gw10, vec4(0.0));\n    gx10 -= sw10 * (step(0.0, gx10) - 0.5);\n    gy10 -= sw10 * (step(0.0, gy10) - 0.5);\n\n    vec4 gx11 = ixy11 * (1.0 / 7.0);\n    vec4 gy11 = floor(gx11) * (1.0 / 7.0);\n    vec4 gz11 = floor(gy11) * (1.0 / 6.0);\n    gx11 = fract(gx11) - 0.5;\n    gy11 = fract(gy11) - 0.5;\n    gz11 = fract(gz11) - 0.5;\n    vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11);\n    vec4 sw11 = step(gw11, vec4(0.0));\n    gx11 -= sw11 * (step(0.0, gx11) - 0.5);\n    gy11 -= sw11 * (step(0.0, gy11) - 0.5);\n\n    vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x);\n    vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y);\n    vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z);\n    vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w);\n    vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x);\n    vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y);\n    vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z);\n    vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w);\n    vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x);\n    vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y);\n    vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z);\n    vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w);\n    vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x);\n    vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y);\n    vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z);\n    vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w);\n\n    vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));\n    g0000 *= norm00.x;\n    g0100 *= norm00.y;\n    g1000 *= norm00.z;\n    g1100 *= norm00.w;\n\n    vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));\n    g0001 *= norm01.x;\n    g0101 *= norm01.y;\n    g1001 *= norm01.z;\n    g1101 *= norm01.w;\n\n    vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));\n    g0010 *= norm10.x;\n    g0110 *= norm10.y;\n    g1010 *= norm10.z;\n    g1110 *= norm10.w;\n\n    vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));\n    g0011 *= norm11.x;\n    g0111 *= norm11.y;\n    g1011 *= norm11.z;\n    g1111 *= norm11.w;\n\n    float n0000 = dot(g0000, Pf0);\n    float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw));\n    float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw));\n    float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw));\n    float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w));\n    float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));\n    float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w));\n    float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w));\n    float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w));\n    float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w));\n    float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));\n    float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w));\n    float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw));\n    float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw));\n    float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw));\n    float n1111 = dot(g1111, Pf1);\n\n    vec4 fade_xyzw = fade(Pf0);\n    vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w);\n    vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w);\n    vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z);\n    vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y);\n    float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);\n    return 2.2 * n_xyzw;\n\n}\n\n// Classic Perlin noise, periodic version\nfloat perlin( vec4 P, vec4 rep ) {\n\n    vec4 Pi0 = mod(floor(P), rep); // Integer part modulo rep\n    vec4 Pi1 = mod(Pi0 + 1.0, rep); // Integer part + 1 mod rep\n    Pi0 = mod289(Pi0);\n    Pi1 = mod289(Pi1);\n    vec4 Pf0 = fract(P); // Fractional part for interpolation\n    vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0\n    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);\n    vec4 iy = vec4(Pi0.yy, Pi1.yy);\n    vec4 iz0 = vec4(Pi0.zzzz);\n    vec4 iz1 = vec4(Pi1.zzzz);\n    vec4 iw0 = vec4(Pi0.wwww);\n    vec4 iw1 = vec4(Pi1.wwww);\n\n    vec4 ixy = permute(permute(ix) + iy);\n    vec4 ixy0 = permute(ixy + iz0);\n    vec4 ixy1 = permute(ixy + iz1);\n    vec4 ixy00 = permute(ixy0 + iw0);\n    vec4 ixy01 = permute(ixy0 + iw1);\n    vec4 ixy10 = permute(ixy1 + iw0);\n    vec4 ixy11 = permute(ixy1 + iw1);\n\n    vec4 gx00 = ixy00 * (1.0 / 7.0);\n    vec4 gy00 = floor(gx00) * (1.0 / 7.0);\n    vec4 gz00 = floor(gy00) * (1.0 / 6.0);\n    gx00 = fract(gx00) - 0.5;\n    gy00 = fract(gy00) - 0.5;\n    gz00 = fract(gz00) - 0.5;\n    vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00);\n    vec4 sw00 = step(gw00, vec4(0.0));\n    gx00 -= sw00 * (step(0.0, gx00) - 0.5);\n    gy00 -= sw00 * (step(0.0, gy00) - 0.5);\n\n    vec4 gx01 = ixy01 * (1.0 / 7.0);\n    vec4 gy01 = floor(gx01) * (1.0 / 7.0);\n    vec4 gz01 = floor(gy01) * (1.0 / 6.0);\n    gx01 = fract(gx01) - 0.5;\n    gy01 = fract(gy01) - 0.5;\n    gz01 = fract(gz01) - 0.5;\n    vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01);\n    vec4 sw01 = step(gw01, vec4(0.0));\n    gx01 -= sw01 * (step(0.0, gx01) - 0.5);\n    gy01 -= sw01 * (step(0.0, gy01) - 0.5);\n\n    vec4 gx10 = ixy10 * (1.0 / 7.0);\n    vec4 gy10 = floor(gx10) * (1.0 / 7.0);\n    vec4 gz10 = floor(gy10) * (1.0 / 6.0);\n    gx10 = fract(gx10) - 0.5;\n    gy10 = fract(gy10) - 0.5;\n    gz10 = fract(gz10) - 0.5;\n    vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10);\n    vec4 sw10 = step(gw10, vec4(0.0));\n    gx10 -= sw10 * (step(0.0, gx10) - 0.5);\n    gy10 -= sw10 * (step(0.0, gy10) - 0.5);\n\n    vec4 gx11 = ixy11 * (1.0 / 7.0);\n    vec4 gy11 = floor(gx11) * (1.0 / 7.0);\n    vec4 gz11 = floor(gy11) * (1.0 / 6.0);\n    gx11 = fract(gx11) - 0.5;\n    gy11 = fract(gy11) - 0.5;\n    gz11 = fract(gz11) - 0.5;\n    vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11);\n    vec4 sw11 = step(gw11, vec4(0.0));\n    gx11 -= sw11 * (step(0.0, gx11) - 0.5);\n    gy11 -= sw11 * (step(0.0, gy11) - 0.5);\n\n    vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x);\n    vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y);\n    vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z);\n    vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w);\n    vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x);\n    vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y);\n    vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z);\n    vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w);\n    vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x);\n    vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y);\n    vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z);\n    vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w);\n    vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x);\n    vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y);\n    vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z);\n    vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w);\n\n    vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));\n    g0000 *= norm00.x;\n    g0100 *= norm00.y;\n    g1000 *= norm00.z;\n    g1100 *= norm00.w;\n\n    vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));\n    g0001 *= norm01.x;\n    g0101 *= norm01.y;\n    g1001 *= norm01.z;\n    g1101 *= norm01.w;\n\n    vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));\n    g0010 *= norm10.x;\n    g0110 *= norm10.y;\n    g1010 *= norm10.z;\n    g1110 *= norm10.w;\n\n    vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));\n    g0011 *= norm11.x;\n    g0111 *= norm11.y;\n    g1011 *= norm11.z;\n    g1111 *= norm11.w;\n\n    float n0000 = dot(g0000, Pf0);\n    float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw));\n    float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw));\n    float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw));\n    float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w));\n    float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));\n    float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w));\n    float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w));\n    float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w));\n    float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w));\n    float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));\n    float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w));\n    float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw));\n    float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw));\n    float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw));\n    float n1111 = dot(g1111, Pf1);\n\n    vec4 fade_xyzw = fade(Pf0);\n    vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w);\n    vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w);\n    vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z);\n    vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y);\n    float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);\n    return 2.2 * n_xyzw;\n\n}\n"; // eslint-disable-line
-
-var noise_psrd_2D = "// Periodic (tiling) 2-D simplex noise (hexagonal lattice gradient noise)\n// with rotating gradients and analytic derivatives.\n// Variants also without the derivative (no \"d\" in the name), without\n// the tiling property (no \"p\" in the name) and without the rotating\n// gradients (no \"r\" in the name).\n//\n// This is (yet) another variation on simplex noise. It's similar to the\n// version presented by Ken Perlin, but the grid is axis-aligned and\n// slightly stretched in the y direction to permit rectangular tiling.\n//\n// The noise can be made to tile seamlessly to any integer period in x and\n// any even integer period in y. Odd periods may be specified for y, but\n// then the actual tiling period will be twice that number.\n//\n// The rotating gradients give the appearance of a swirling motion, and can\n// serve a similar purpose for animation as motion along z in 3-D noise.\n// The rotating gradients in conjunction with the analytic derivatives\n// can make \"flow noise\" effects as presented by Perlin and Neyret.\n//\n// vec3 {p}s{r}dnoise(vec2 pos {, vec2 per} {, float rot})\n// \"pos\" is the input (x,y) coordinate\n// \"per\" is the x and y period, where per.x is a positive integer\n//    and per.y is a positive even integer\n// \"rot\" is the angle to rotate the gradients (any float value,\n//    where 0.0 is no rotation and 1.0 is one full turn)\n// The first component of the 3-element return vector is the noise value.\n// The second and third components are the x and y partial derivatives.\n//\n// float {p}s{r}noise(vec2 pos {, vec2 per} {, float rot})\n// \"pos\" is the input (x,y) coordinate\n// \"per\" is the x and y period, where per.x is a positive integer\n//    and per.y is a positive even integer\n// \"rot\" is the angle to rotate the gradients (any float value,\n//    where 0.0 is no rotation and 1.0 is one full turn)\n// The return value is the noise value.\n// Partial derivatives are not computed, making these functions faster.\n//\n// Author: Stefan Gustavson (stefan.gustavson@gmail.com)\n// Version 2016-05-10.\n//\n// Many thanks to Ian McEwan of Ashima Arts for the\n// idea of using a permutation polynomial.\n//\n// Copyright (c) 2016 Stefan Gustavson. All rights reserved.\n// Distributed under the MIT license. See LICENSE file.\n// https://github.com/stegu/webgl-noise\n//\n\n// Hashed 2-D gradients with an extra rotation.\n// (The constant 0.0243902439 is 1/41)\nvec2 rgrad2( vec2 p, float rot ) {\n\n    // For more isotropic gradients, sin/cos can be used instead.\n    float u = permute( permute( p.x ) + p.y ) * 0.0243902439 + rot; // Rotate by shift\n    u = fract( u ) * 6.28318530718; // 2*pi\n    return vec2( cos( u ), sin( u ));\n\n}\n\n//\n// 2-D tiling simplex noise with rotating gradients and analytical derivative.\n// The first component of the 3-element return vector is the noise value,\n// and the second and third components are the x and y partial derivatives.\n//\nvec3 psrdnoise(vec2 pos, vec2 per, float rot) {\n  // Hack: offset y slightly to hide some rare artifacts\n  pos.y += 0.01;\n  // Skew to hexagonal grid\n  vec2 uv = vec2(pos.x + pos.y*0.5, pos.y);\n\n  vec2 i0 = floor(uv);\n  vec2 f0 = fract(uv);\n  // Traversal order\n  vec2 i1 = (f0.x > f0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n  // Unskewed grid points in (x,y) space\n  vec2 p0 = vec2(i0.x - i0.y * 0.5, i0.y);\n  vec2 p1 = vec2(p0.x + i1.x - i1.y * 0.5, p0.y + i1.y);\n  vec2 p2 = vec2(p0.x + 0.5, p0.y + 1.0);\n\n  // Integer grid point indices in (u,v) space\n  i1 = i0 + i1;\n  vec2 i2 = i0 + vec2(1.0, 1.0);\n\n  // Vectors in unskewed (x,y) coordinates from\n  // each of the simplex corners to the evaluation point\n  vec2 d0 = pos - p0;\n  vec2 d1 = pos - p1;\n  vec2 d2 = pos - p2;\n\n  // Wrap i0, i1 and i2 to the desired period before gradient hashing:\n  // wrap points in (x,y), map to (u,v)\n  vec3 xw = mod(vec3(p0.x, p1.x, p2.x), per.x);\n  vec3 yw = mod(vec3(p0.y, p1.y, p2.y), per.y);\n  vec3 iuw = xw + 0.5 * yw;\n  vec3 ivw = yw;\n\n  // Create gradients from indices\n  vec2 g0 = rgrad2(vec2(iuw.x, ivw.x), rot);\n  vec2 g1 = rgrad2(vec2(iuw.y, ivw.y), rot);\n  vec2 g2 = rgrad2(vec2(iuw.z, ivw.z), rot);\n\n  // Gradients dot vectors to corresponding corners\n  // (The derivatives of this are simply the gradients)\n  vec3 w = vec3(dot(g0, d0), dot(g1, d1), dot(g2, d2));\n\n  // Radial weights from corners\n  // 0.8 is the square of 2/sqrt(5), the distance from\n  // a grid point to the nearest simplex boundary\n  vec3 t = 0.8 - vec3(dot(d0, d0), dot(d1, d1), dot(d2, d2));\n\n  // Partial derivatives for analytical gradient computation\n  vec3 dtdx = -2.0 * vec3(d0.x, d1.x, d2.x);\n  vec3 dtdy = -2.0 * vec3(d0.y, d1.y, d2.y);\n\n  // Set influence of each surflet to zero outside radius sqrt(0.8)\n  if (t.x < 0.0) {\n    dtdx.x = 0.0;\n    dtdy.x = 0.0;\n\tt.x = 0.0;\n  }\n  if (t.y < 0.0) {\n    dtdx.y = 0.0;\n    dtdy.y = 0.0;\n\tt.y = 0.0;\n  }\n  if (t.z < 0.0) {\n    dtdx.z = 0.0;\n    dtdy.z = 0.0;\n\tt.z = 0.0;\n  }\n\n  // Fourth power of t (and third power for derivative)\n  vec3 t2 = t * t;\n  vec3 t4 = t2 * t2;\n  vec3 t3 = t2 * t;\n\n  // Final noise value is:\n  // sum of ((radial weights) times (gradient dot vector from corner))\n  float n = dot(t4, w);\n\n  // Final analytical derivative (gradient of a sum of scalar products)\n  vec2 dt0 = vec2(dtdx.x, dtdy.x) * 4.0 * t3.x;\n  vec2 dn0 = t4.x * g0 + dt0 * w.x;\n  vec2 dt1 = vec2(dtdx.y, dtdy.y) * 4.0 * t3.y;\n  vec2 dn1 = t4.y * g1 + dt1 * w.y;\n  vec2 dt2 = vec2(dtdx.z, dtdy.z) * 4.0 * t3.z;\n  vec2 dn2 = t4.z * g2 + dt2 * w.z;\n\n  return 11.0*vec3(n, dn0 + dn1 + dn2);\n}\n\n//\n// 2-D tiling simplex noise with fixed gradients\n// and analytical derivative.\n// This function is implemented as a wrapper to \"psrdnoise\",\n// at the minimal cost of three extra additions.\n//\nvec3 psdnoise(vec2 pos, vec2 per) {\n  return psrdnoise(pos, per, 0.0);\n}\n\n//\n// 2-D tiling simplex noise with rotating gradients,\n// but without the analytical derivative.\n//\nfloat psrnoise(vec2 pos, vec2 per, float rot) {\n  // Offset y slightly to hide some rare artifacts\n  pos.y += 0.001;\n  // Skew to hexagonal grid\n  vec2 uv = vec2(pos.x + pos.y*0.5, pos.y);\n\n  vec2 i0 = floor(uv);\n  vec2 f0 = fract(uv);\n  // Traversal order\n  vec2 i1 = (f0.x > f0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n  // Unskewed grid points in (x,y) space\n  vec2 p0 = vec2(i0.x - i0.y * 0.5, i0.y);\n  vec2 p1 = vec2(p0.x + i1.x - i1.y * 0.5, p0.y + i1.y);\n  vec2 p2 = vec2(p0.x + 0.5, p0.y + 1.0);\n\n  // Integer grid point indices in (u,v) space\n  i1 = i0 + i1;\n  vec2 i2 = i0 + vec2(1.0, 1.0);\n\n  // Vectors in unskewed (x,y) coordinates from\n  // each of the simplex corners to the evaluation point\n  vec2 d0 = pos - p0;\n  vec2 d1 = pos - p1;\n  vec2 d2 = pos - p2;\n\n  // Wrap i0, i1 and i2 to the desired period before gradient hashing:\n  // wrap points in (x,y), map to (u,v)\n  vec3 xw = mod(vec3(p0.x, p1.x, p2.x), per.x);\n  vec3 yw = mod(vec3(p0.y, p1.y, p2.y), per.y);\n  vec3 iuw = xw + 0.5 * yw;\n  vec3 ivw = yw;\n\n  // Create gradients from indices\n  vec2 g0 = rgrad2(vec2(iuw.x, ivw.x), rot);\n  vec2 g1 = rgrad2(vec2(iuw.y, ivw.y), rot);\n  vec2 g2 = rgrad2(vec2(iuw.z, ivw.z), rot);\n\n  // Gradients dot vectors to corresponding corners\n  // (The derivatives of this are simply the gradients)\n  vec3 w = vec3(dot(g0, d0), dot(g1, d1), dot(g2, d2));\n\n  // Radial weights from corners\n  // 0.8 is the square of 2/sqrt(5), the distance from\n  // a grid point to the nearest simplex boundary\n  vec3 t = 0.8 - vec3(dot(d0, d0), dot(d1, d1), dot(d2, d2));\n\n  // Set influence of each surflet to zero outside radius sqrt(0.8)\n  t = max(t, 0.0);\n\n  // Fourth power of t\n  vec3 t2 = t * t;\n  vec3 t4 = t2 * t2;\n\n  // Final noise value is:\n  // sum of ((radial weights) times (gradient dot vector from corner))\n  float n = dot(t4, w);\n\n  // Rescale to cover the range [-1,1] reasonably well\n  return 11.0*n;\n}\n\n//\n// 2-D tiling simplex noise with fixed gradients,\n// without the analytical derivative.\n// This function is implemented as a wrapper to \"psrnoise\",\n// at the minimal cost of three extra additions.\n//\nfloat psnoise(vec2 pos, vec2 per) {\n  return psrnoise(pos, per, 0.0);\n}\n\n//\n// 2-D non-tiling simplex noise with rotating gradients and analytical derivative.\n// The first component of the 3-element return vector is the noise value,\n// and the second and third components are the x and y partial derivatives.\n//\nvec3 srdnoise(vec2 pos, float rot) {\n  // Offset y slightly to hide some rare artifacts\n  pos.y += 0.001;\n  // Skew to hexagonal grid\n  vec2 uv = vec2(pos.x + pos.y*0.5, pos.y);\n\n  vec2 i0 = floor(uv);\n  vec2 f0 = fract(uv);\n  // Traversal order\n  vec2 i1 = (f0.x > f0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n  // Unskewed grid points in (x,y) space\n  vec2 p0 = vec2(i0.x - i0.y * 0.5, i0.y);\n  vec2 p1 = vec2(p0.x + i1.x - i1.y * 0.5, p0.y + i1.y);\n  vec2 p2 = vec2(p0.x + 0.5, p0.y + 1.0);\n\n  // Integer grid point indices in (u,v) space\n  i1 = i0 + i1;\n  vec2 i2 = i0 + vec2(1.0, 1.0);\n\n  // Vectors in unskewed (x,y) coordinates from\n  // each of the simplex corners to the evaluation point\n  vec2 d0 = pos - p0;\n  vec2 d1 = pos - p1;\n  vec2 d2 = pos - p2;\n\n  vec3 x = vec3(p0.x, p1.x, p2.x);\n  vec3 y = vec3(p0.y, p1.y, p2.y);\n  vec3 iuw = x + 0.5 * y;\n  vec3 ivw = y;\n\n  // Avoid precision issues in permutation\n  iuw = mod289(iuw);\n  ivw = mod289(ivw);\n\n  // Create gradients from indices\n  vec2 g0 = rgrad2(vec2(iuw.x, ivw.x), rot);\n  vec2 g1 = rgrad2(vec2(iuw.y, ivw.y), rot);\n  vec2 g2 = rgrad2(vec2(iuw.z, ivw.z), rot);\n\n  // Gradients dot vectors to corresponding corners\n  // (The derivatives of this are simply the gradients)\n  vec3 w = vec3(dot(g0, d0), dot(g1, d1), dot(g2, d2));\n\n  // Radial weights from corners\n  // 0.8 is the square of 2/sqrt(5), the distance from\n  // a grid point to the nearest simplex boundary\n  vec3 t = 0.8 - vec3(dot(d0, d0), dot(d1, d1), dot(d2, d2));\n\n  // Partial derivatives for analytical gradient computation\n  vec3 dtdx = -2.0 * vec3(d0.x, d1.x, d2.x);\n  vec3 dtdy = -2.0 * vec3(d0.y, d1.y, d2.y);\n\n  // Set influence of each surflet to zero outside radius sqrt(0.8)\n  if (t.x < 0.0) {\n    dtdx.x = 0.0;\n    dtdy.x = 0.0;\n\tt.x = 0.0;\n  }\n  if (t.y < 0.0) {\n    dtdx.y = 0.0;\n    dtdy.y = 0.0;\n\tt.y = 0.0;\n  }\n  if (t.z < 0.0) {\n    dtdx.z = 0.0;\n    dtdy.z = 0.0;\n\tt.z = 0.0;\n  }\n\n  // Fourth power of t (and third power for derivative)\n  vec3 t2 = t * t;\n  vec3 t4 = t2 * t2;\n  vec3 t3 = t2 * t;\n\n  // Final noise value is:\n  // sum of ((radial weights) times (gradient dot vector from corner))\n  float n = dot(t4, w);\n\n  // Final analytical derivative (gradient of a sum of scalar products)\n  vec2 dt0 = vec2(dtdx.x, dtdy.x) * 4.0 * t3.x;\n  vec2 dn0 = t4.x * g0 + dt0 * w.x;\n  vec2 dt1 = vec2(dtdx.y, dtdy.y) * 4.0 * t3.y;\n  vec2 dn1 = t4.y * g1 + dt1 * w.y;\n  vec2 dt2 = vec2(dtdx.z, dtdy.z) * 4.0 * t3.z;\n  vec2 dn2 = t4.z * g2 + dt2 * w.z;\n\n  return 11.0*vec3(n, dn0 + dn1 + dn2);\n}\n\n//\n// 2-D non-tiling simplex noise with fixed gradients and analytical derivative.\n// This function is implemented as a wrapper to \"srdnoise\",\n// at the minimal cost of three extra additions.\n//\nvec3 sdnoise(vec2 pos) {\n  return srdnoise(pos, 0.0);\n}\n\n//\n// 2-D non-tiling simplex noise with rotating gradients,\n// without the analytical derivative.\n//\nfloat srnoise(vec2 pos, float rot) {\n  // Offset y slightly to hide some rare artifacts\n  pos.y += 0.001;\n  // Skew to hexagonal grid\n  vec2 uv = vec2(pos.x + pos.y*0.5, pos.y);\n\n  vec2 i0 = floor(uv);\n  vec2 f0 = fract(uv);\n  // Traversal order\n  vec2 i1 = (f0.x > f0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n  // Unskewed grid points in (x,y) space\n  vec2 p0 = vec2(i0.x - i0.y * 0.5, i0.y);\n  vec2 p1 = vec2(p0.x + i1.x - i1.y * 0.5, p0.y + i1.y);\n  vec2 p2 = vec2(p0.x + 0.5, p0.y + 1.0);\n\n  // Integer grid point indices in (u,v) space\n  i1 = i0 + i1;\n  vec2 i2 = i0 + vec2(1.0, 1.0);\n\n  // Vectors in unskewed (x,y) coordinates from\n  // each of the simplex corners to the evaluation point\n  vec2 d0 = pos - p0;\n  vec2 d1 = pos - p1;\n  vec2 d2 = pos - p2;\n\n  // Wrap i0, i1 and i2 to the desired period before gradient hashing:\n  // wrap points in (x,y), map to (u,v)\n  vec3 x = vec3(p0.x, p1.x, p2.x);\n  vec3 y = vec3(p0.y, p1.y, p2.y);\n  vec3 iuw = x + 0.5 * y;\n  vec3 ivw = y;\n\n  // Avoid precision issues in permutation\n  iuw = mod289(iuw);\n  ivw = mod289(ivw);\n\n  // Create gradients from indices\n  vec2 g0 = rgrad2(vec2(iuw.x, ivw.x), rot);\n  vec2 g1 = rgrad2(vec2(iuw.y, ivw.y), rot);\n  vec2 g2 = rgrad2(vec2(iuw.z, ivw.z), rot);\n\n  // Gradients dot vectors to corresponding corners\n  // (The derivatives of this are simply the gradients)\n  vec3 w = vec3(dot(g0, d0), dot(g1, d1), dot(g2, d2));\n\n  // Radial weights from corners\n  // 0.8 is the square of 2/sqrt(5), the distance from\n  // a grid point to the nearest simplex boundary\n  vec3 t = 0.8 - vec3(dot(d0, d0), dot(d1, d1), dot(d2, d2));\n\n  // Set influence of each surflet to zero outside radius sqrt(0.8)\n  t = max(t, 0.0);\n\n  // Fourth power of t\n  vec3 t2 = t * t;\n  vec3 t4 = t2 * t2;\n\n  // Final noise value is:\n  // sum of ((radial weights) times (gradient dot vector from corner))\n  float n = dot(t4, w);\n\n  // Rescale to cover the range [-1,1] reasonably well\n  return 11.0*n;\n}\n\n//\n// 2-D non-tiling simplex noise with fixed gradients,\n// without the analytical derivative.\n// This function is implemented as a wrapper to \"srnoise\",\n// at the minimal cost of three extra additions.\n// Note: if this kind of noise is all you want, there are faster\n// GLSL implementations of non-tiling simplex noise out there.\n// This one is included mainly for completeness and compatibility\n// with the other functions in the file.\n//\nfloat snoise(vec2 pos) {\n  return srnoise(pos, 0.0);\n}\n"; // eslint-disable-line
-
-var noise_simplex = "#include <noise_simplex_2D>\n#include <noise_simplex_3D>\n#include <noise_simplex_3D_grad>\n#include <noise_simplex_4D>\n"; // eslint-disable-line
-
-var noise_simplex_2D = "//\n// Description : Array and textureless GLSL 2D simplex noise function.\n//      Author : Ian McEwan, Ashima Arts.\n//  Maintainer : stegu\n//     Lastmod : 20110822 (ijm)\n//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.\n//               Distributed under the MIT License. See LICENSE file.\n//               https://github.com/ashima/webgl-noise\n//               https://github.com/stegu/webgl-noise\n//\n\nfloat simplex( vec2 v ) {\n\n    const vec4 C = vec4( 0.211324865405187,  // (3.0-sqrt(3.0))/6.0\n                        0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)\n                        -0.577350269189626,  // -1.0 + 2.0 * C.x\n                        0.024390243902439 ); // 1.0 / 41.0\n    // First corner\n    vec2 i  = floor( v + dot( v, C.yy ) );\n    vec2 x0 = v - i + dot( i, C.xx );\n\n    // Other corners\n    vec2 i1;\n    //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0\n    //i1.y = 1.0 - i1.x;\n    i1 = ( x0.x > x0.y ) ? vec2( 1.0, 0.0 ) : vec2( 0.0, 1.0 );\n    // x0 = x0 - 0.0 + 0.0 * C.xx ;\n    // x1 = x0 - i1 + 1.0 * C.xx ;\n    // x2 = x0 - 1.0 + 2.0 * C.xx ;\n    vec4 x12 = x0.xyxy + C.xxzz;\n    x12.xy -= i1;\n\n    // Permutations\n    i = mod289( i ); // Avoid truncation effects in permutation\n    vec3 p = permute( permute( i.y + vec3( 0.0, i1.y, 1.0 ) )\n        + i.x + vec3( 0.0, i1.x, 1.0 ) );\n\n    vec3 m = max( 0.5 - vec3( dot( x0, x0 ), dot( x12.xy, x12.xy ), dot( x12.zw, x12.zw ) ), 0.0 );\n    m = m*m ;\n    m = m*m ;\n\n    // Gradients: 41 points uniformly over a line, mapped onto a diamond.\n    // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)\n\n    vec3 x = 2.0 * fract( p * C.www ) - 1.0;\n    vec3 h = abs( x ) - 0.5;\n    vec3 ox = floor( x + 0.5 );\n    vec3 a0 = x - ox;\n\n    // Normalise gradients implicitly by scaling m\n    // Approximation of: m *= inversesqrt( a0*a0 + h*h );\n    m *= 1.79284291400159 - 0.85373472095314 * ( a0 * a0 + h * h );\n\n    // Compute final noise value at P\n    vec3 g;\n    g.x  = a0.x * x0.x + h.x * x0.y;\n    g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n    return 130.0 * dot( m, g );\n\n}\n"; // eslint-disable-line
-
-var noise_simplex_3D = "//\n// Description : Array and textureless GLSL 2D/3D/4D simplex\n//               noise functions.\n//      Author : Ian McEwan, Ashima Arts.\n//  Maintainer : stegu\n//     Lastmod : 20110822 (ijm)\n//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.\n//               Distributed under the MIT License. See LICENSE file.\n//               https://github.com/ashima/webgl-noise\n//               https://github.com/stegu/webgl-noise\n//\n\nfloat simplex( vec3 v ) {\n\n    const vec2 C = vec2( 1.0 / 6.0, 1.0 / 3.0 );\n    const vec4 D = vec4( 0.0, 0.5, 1.0, 2.0 );\n\n    // First corner\n    vec3 i  = floor( v + dot( v, C.yyy ) );\n    vec3 x0 = v - i + dot( i, C.xxx );\n\n    // Other corners\n    vec3 g = step( x0.yzx, x0.xyz );\n    vec3 l = 1.0 - g;\n    vec3 i1 = min( g.xyz, l.zxy );\n    vec3 i2 = max( g.xyz, l.zxy );\n\n    vec3 x1 = x0 - i1 + C.xxx;\n    vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y\n    vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y\n\n    // Permutations\n    i = mod289( i );\n    vec4 p = permute( permute( permute(\n                i.z + vec4(0.0, i1.z, i2.z, 1.0 ))\n            + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))\n            + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));\n\n    // Gradients: 7x7 points over a square, mapped onto an octahedron.\n    // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)\n    float n_ = 0.142857142857; // 1.0/7.0\n    vec3 ns = n_ * D.wyz - D.xzx;\n\n    vec4 j = p - 49.0 * floor( p * ns.z * ns.z );  //  mod(p,7*7)\n\n    vec4 x_ = floor(j * ns.z);\n    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)\n\n    vec4 x = x_ *ns.x + ns.yyyy;\n    vec4 y = y_ *ns.x + ns.yyyy;\n    vec4 h = 1.0 - abs( x ) - abs( y );\n\n    vec4 b0 = vec4( x.xy, y.xy );\n    vec4 b1 = vec4( x.zw, y.zw );\n\n    vec4 s0 = floor( b0 ) * 2.0 + 1.0;\n    vec4 s1 = floor( b1 ) * 2.0 + 1.0;\n    vec4 sh = - step( h, vec4( 0.0 ) );\n\n    vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy ;\n    vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww ;\n\n    vec3 p0 = vec3( a0.xy, h.x );\n    vec3 p1 = vec3( a0.zw, h.y );\n    vec3 p2 = vec3( a1.xy, h.z );\n    vec3 p3 = vec3( a1.zw, h.w );\n\n    //Normalise gradients\n    vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );\n    p0 *= norm.x;\n    p1 *= norm.y;\n    p2 *= norm.z;\n    p3 *= norm.w;\n\n    // Mix final noise value\n    vec4 m = max( 0.6 - vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ), 0.0 );\n    m = m * m;\n    return 42.0 * dot( m*m, vec4( dot( p0, x0 ), dot( p1, x1 ),\n                                dot( p2, x2 ), dot( p3, x3 ) ) );\n\n}\n"; // eslint-disable-line
-
-var noise_simplex_3D_grad = "//\n// Description : Array and textureless GLSL 2D/3D/4D simplex\n//               noise functions.\n//      Author : Ian McEwan, Ashima Arts.\n//  Maintainer : stegu\n//     Lastmod : 20150104 (JcBernack)\n//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.\n//               Distributed under the MIT License. See LICENSE file.\n//               https://github.com/ashima/webgl-noise\n//               https://github.com/stegu/webgl-noise\n//\n\nfloat simplex( vec3 v, out vec3 gradient ) {\n\n    const vec2  C = vec2( 1.0 / 6.0, 1.0 / 3.0 );\n    const vec4  D = vec4( 0.0, 0.5, 1.0, 2.0 );\n\n    // First corner\n    vec3 i  = floor( v + dot( v, C.yyy ) );\n    vec3 x0 = v - i + dot( i, C.xxx ) ;\n\n    // Other corners\n    vec3 g = step( x0.yzx, x0.xyz );\n    vec3 l = 1.0 - g;\n    vec3 i1 = min( g.xyz, l.zxy );\n    vec3 i2 = max( g.xyz, l.zxy );\n\n    vec3 x1 = x0 - i1 + C.xxx;\n    vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y\n    vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y\n\n    // Permutations\n    i = mod289( i );\n    vec4 p = permute( permute( permute(\n                i.z + vec4( 0.0, i1.z, i2.z, 1.0 ) )\n            + i.y + vec4( 0.0, i1.y, i2.y, 1.0 ) )\n            + i.x + vec4( 0.0, i1.x, i2.x, 1.0 ) );\n\n    // Gradients: 7x7 points over a square, mapped onto an octahedron.\n    // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)\n    float n_ = 0.142857142857; // 1.0/7.0\n    vec3 ns = n_ * D.wyz - D.xzx;\n\n    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)\n\n    vec4 x_ = floor(j * ns.z);\n    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)\n\n    vec4 x = x_ * ns.x + ns.yyyy;\n    vec4 y = y_ * ns.x + ns.yyyy;\n    vec4 h = 1.0 - abs( x ) - abs( y );\n\n    vec4 b0 = vec4( x.xy, y.xy );\n    vec4 b1 = vec4( x.zw, y.zw );\n\n    vec4 s0 = floor( b0 ) * 2.0 + 1.0;\n    vec4 s1 = floor( b1 ) * 2.0 + 1.0;\n    vec4 sh = - step( h, vec4( 0.0 ) );\n\n    vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy ;\n    vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww ;\n\n    vec3 p0 = vec3( a0.xy, h.x );\n    vec3 p1 = vec3( a0.zw, h.y );\n    vec3 p2 = vec3( a1.xy, h.z );\n    vec3 p3 = vec3( a1.zw, h.w );\n\n    //Normalise gradients\n    vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );\n    p0 *= norm.x;\n    p1 *= norm.y;\n    p2 *= norm.z;\n    p3 *= norm.w;\n\n    // Mix final noise value\n    vec4 m = max( 0.6 - vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ), 0.0 );\n    vec4 m2 = m * m;\n    vec4 m4 = m2 * m2;\n    vec4 pdotx = vec4( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ), dot( p3, x3 ) );\n\n    // Determine noise gradient\n    vec4 temp = m2 * m * pdotx;\n    gradient = - 8.0 * ( temp.x * x0 + temp.y * x1 + temp.z * x2 + temp.w * x3 );\n    gradient += m4.x * p0 + m4.y * p1 + m4.z * p2 + m4.w * p3;\n    gradient *= 42.0;\n\n    return 42.0 * dot( m4, pdotx );\n\n}\n"; // eslint-disable-line
-
-var noise_simplex_4D = "//\n// Description : Array and textureless GLSL 2D/3D/4D simplex\n//               noise functions.\n//      Author : Ian McEwan, Ashima Arts.\n//  Maintainer : stegu\n//     Lastmod : 20110822 (ijm)\n//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.\n//               Distributed under the MIT License. See LICENSE file.\n//               https://github.com/ashima/webgl-noise\n//               https://github.com/stegu/webgl-noise\n//\n\nvec4 grad4( float j, vec4 ip ) {\n\n    const vec4 ones = vec4( 1.0, 1.0, 1.0, -1.0 );\n    vec4 p, s;\n\n    p.xyz = floor( fract( vec3( j ) * ip.xyz ) * 7.0 ) * ip.z - 1.0;\n    p.w = 1.5 - dot( abs( p.xyz ), ones.xyz );\n    s = vec4( lessThan( p, vec4( 0.0 ) ) );\n    p.xyz = p.xyz + ( s.xyz * 2.0 - 1.0 ) * s.www;\n\n    return p;\n\n}\n\n// (sqrt(5) - 1)/4 = F4, used once below\n#define F4 0.309016994374947451\n\nfloat simplex(vec4 v) {\n\n    const vec4 C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4\n                        0.276393202250021,  // 2 * G4\n                        0.414589803375032,  // 3 * G4\n                        -0.447213595499958); // -1 + 4 * G4\n\n    // First corner\n    vec4 i  = floor( v + dot( v, vec4( F4 ) ) );\n    vec4 x0 = v - i + dot( i, C.xxxx );\n\n    // Other corners\n\n    // Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)\n    vec4 i0;\n    vec3 isX = step( x0.yzw, x0.xxx );\n    vec3 isYZ = step( x0.zww, x0.yyz );\n    i0.x = isX.x + isX.y + isX.z;\n    i0.yzw = 1.0 - isX;\n    i0.y += isYZ.x + isYZ.y;\n    i0.zw += 1.0 - isYZ.xy;\n    i0.z += isYZ.z;\n    i0.w += 1.0 - isYZ.z;\n\n    vec4 i3 = clamp( i0, 0.0, 1.0 );\n    vec4 i2 = clamp( i0 - 1.0, 0.0, 1.0 );\n    vec4 i1 = clamp( i0 - 2.0, 0.0, 1.0 );\n\n    vec4 x1 = x0 - i1 + C.xxxx;\n    vec4 x2 = x0 - i2 + C.yyyy;\n    vec4 x3 = x0 - i3 + C.zzzz;\n    vec4 x4 = x0 + C.wwww;\n\n    // Permutations\n    i = mod289( i );\n    float j0 = permute( permute( permute( permute( i.w ) + i.z ) + i.y ) + i.x );\n    vec4 j1 = permute( permute( permute( permute (\n                i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))\n            + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))\n            + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))\n            + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));\n\n    // Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope\n    // 7*7*6 = 294, which is close to the ring size 17*17 = 289.\n    vec4 ip = vec4( 1.0 / 294.0, 1.0 / 49.0, 1.0 / 7.0, 0.0 );\n\n    vec4 p0 = grad4(j0,   ip);\n    vec4 p1 = grad4(j1.x, ip);\n    vec4 p2 = grad4(j1.y, ip);\n    vec4 p3 = grad4(j1.z, ip);\n    vec4 p4 = grad4(j1.w, ip);\n\n    // Normalise gradients\n    vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );\n    p0 *= norm.x;\n    p1 *= norm.y;\n    p2 *= norm.z;\n    p3 *= norm.w;\n    p4 *= taylorInvSqrt( dot( p4, p4 ) );\n\n    // Mix contributions from the five corners\n    vec3 m0 = max( 0.6 - vec3( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ) ), 0.0 );\n    vec2 m1 = max( 0.6 - vec2( dot( x3, x3 ), dot( x4, x4 ) ), 0.0 );\n    m0 = m0 * m0;\n    m1 = m1 * m1;\n    return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))\n                + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;\n\n}\n"; // eslint-disable-line
+var noise_simplex_3D_grad = "// 3D simplex noise analytical gradient.\n// Algorithm: Ken Perlin, \"Noise hardware\" (2001) — simplex lattice improvement over classic Perlin noise (1985).\n// Curl noise: Robert Bridson et al., \"Curl-noise for procedural fluid flow\" (2007).\n// GLSL implementation: Ian McEwan, Ashima Arts (MIT License) — https://github.com/ashima/webgl-noise\n\nvec3 simplexGrad( vec3 v ) {\n\n    const vec2  C = vec2( 1.0 / 6.0, 1.0 / 3.0 );\n    const vec4  D = vec4( 0.0, 0.5, 1.0, 2.0 );\n\n    // First corner\n    vec3 i  = floor( v + dot( v, C.yyy ) );\n    vec3 x0 = v - i + dot( i, C.xxx ) ;\n\n    // Other corners\n    vec3 g = step( x0.yzx, x0.xyz );\n    vec3 l = 1.0 - g;\n    vec3 i1 = min( g.xyz, l.zxy );\n    vec3 i2 = max( g.xyz, l.zxy );\n\n    vec3 x1 = x0 - i1 + C.xxx;\n    vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y\n    vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y\n\n    // Permutations\n    i = mod289( i );\n    vec4 p = permute( permute( permute(\n                i.z + vec4( 0.0, i1.z, i2.z, 1.0 ) )\n            + i.y + vec4( 0.0, i1.y, i2.y, 1.0 ) )\n            + i.x + vec4( 0.0, i1.x, i2.x, 1.0 ) );\n\n    // Gradients: 7x7 points over a square, mapped onto an octahedron.\n    // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)\n    float n_ = 0.142857142857; // 1.0/7.0\n    vec3 ns = n_ * D.wyz - D.xzx;\n\n    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)\n\n    vec4 x_ = floor(j * ns.z);\n    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)\n\n    vec4 x = x_ * ns.x + ns.yyyy;\n    vec4 y = y_ * ns.x + ns.yyyy;\n    vec4 h = 1.0 - abs( x ) - abs( y );\n\n    vec4 b0 = vec4( x.xy, y.xy );\n    vec4 b1 = vec4( x.zw, y.zw );\n\n    vec4 s0 = floor( b0 ) * 2.0 + 1.0;\n    vec4 s1 = floor( b1 ) * 2.0 + 1.0;\n    vec4 sh = - step( h, vec4( 0.0 ) );\n\n    vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy ;\n    vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww ;\n\n    vec3 p0 = vec3( a0.xy, h.x );\n    vec3 p1 = vec3( a0.zw, h.y );\n    vec3 p2 = vec3( a1.xy, h.z );\n    vec3 p3 = vec3( a1.zw, h.w );\n\n    //Normalise gradients\n    vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );\n    p0 *= norm.x;\n    p1 *= norm.y;\n    p2 *= norm.z;\n    p3 *= norm.w;\n\n    // Mix final noise value\n    vec4 m = max( 0.6 - vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ), 0.0 );\n    vec4 m2 = m * m;\n    vec4 m4 = m2 * m2;\n    vec4 pdotx = vec4( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ), dot( p3, x3 ) );\n\n    // Compute and return noise gradient\n    vec4 temp = m2 * m * pdotx;\n    vec3 grad = - 8.0 * ( temp.x * x0 + temp.y * x1 + temp.z * x2 + temp.w * x3 );\n    grad += m4.x * p0 + m4.y * p1 + m4.z * p2 + m4.w * p3;\n    return grad * 42.0;\n\n}\n"; // eslint-disable-line
 
 var pbr_frag_define = "#define MIN_PERCEPTUAL_ROUGHNESS 0.045\n#define MIN_ROUGHNESS            0.002025\n\nuniform float material_AlphaCutoff;\nuniform vec4 material_BaseColor;\nuniform float material_Metal;\nuniform float material_Roughness;\nuniform float material_IOR;\nuniform vec3 material_EmissiveColor;\nuniform float material_NormalIntensity;\nuniform float material_OcclusionIntensity;\nuniform float material_OcclusionTextureCoord;\nuniform float material_SpecularIntensity;\nuniform vec3  material_SpecularColor;\n\n#ifdef MATERIAL_ENABLE_CLEAR_COAT\n    uniform float material_ClearCoat;\n    uniform float material_ClearCoatRoughness;\n\n    #ifdef MATERIAL_HAS_CLEAR_COAT_TEXTURE\n        uniform sampler2D material_ClearCoatTexture;\n    #endif\n\n    #ifdef MATERIAL_HAS_CLEAR_COAT_ROUGHNESS_TEXTURE\n        uniform sampler2D material_ClearCoatRoughnessTexture;\n    #endif\n\n    #ifdef MATERIAL_HAS_CLEAR_COAT_NORMAL_TEXTURE\n        uniform sampler2D material_ClearCoatNormalTexture;\n    #endif\n#endif\n\n#ifdef MATERIAL_ENABLE_ANISOTROPY\n    uniform vec3 material_AnisotropyInfo;\n    #ifdef MATERIAL_HAS_ANISOTROPY_TEXTURE\n        uniform sampler2D material_AnisotropyTexture;\n    #endif\n#endif\n\n// Texture\n#ifdef MATERIAL_HAS_BASETEXTURE\n    uniform sampler2D material_BaseTexture;\n#endif\n\n#ifdef MATERIAL_HAS_NORMALTEXTURE\n    uniform sampler2D material_NormalTexture;\n#endif\n\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n    uniform sampler2D material_EmissiveTexture;\n#endif\n\n#ifdef MATERIAL_HAS_ROUGHNESS_METALLIC_TEXTURE\n    uniform sampler2D material_RoughnessMetallicTexture;\n#endif\n\n#ifdef MATERIAL_HAS_SPECULAR_TEXTURE\n    uniform sampler2D material_SpecularIntensityTexture;\n#endif\n\n#ifdef MATERIAL_HAS_SPECULAR_COLOR_TEXTURE\n    uniform sampler2D material_SpecularColorTexture;\n#endif\n\n#ifdef MATERIAL_HAS_OCCLUSION_TEXTURE\n    uniform sampler2D material_OcclusionTexture;\n#endif\n\n\n#ifdef MATERIAL_ENABLE_SHEEN\n    uniform float material_SheenRoughness;\n    uniform vec3 material_SheenColor;\n    #ifdef MATERIAL_HAS_SHEEN_TEXTURE\n       uniform sampler2D material_SheenTexture;\n    #endif\n\n    #ifdef MATERIAL_HAS_SHEEN_ROUGHNESS_TEXTURE\n       uniform sampler2D material_SheenRoughnessTexture;\n    #endif\n#endif\n\n\n#ifdef MATERIAL_ENABLE_IRIDESCENCE\n    uniform vec4 material_IridescenceInfo;\n    #ifdef MATERIAL_HAS_IRIDESCENCE_THICKNESS_TEXTURE\n       uniform sampler2D material_IridescenceThicknessTexture;\n    #endif\n\n    #ifdef MATERIAL_HAS_IRIDESCENCE_TEXTURE\n       uniform sampler2D material_IridescenceTexture;\n    #endif\n#endif\n\n#ifdef MATERIAL_ENABLE_TRANSMISSION\n    uniform float material_Transmission;\n    #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE\n        uniform sampler2D material_TransmissionTexture;\n    #endif\n\n    #ifdef MATERIAL_HAS_THICKNESS\n        uniform vec3 material_AttenuationColor;\n        uniform float material_AttenuationDistance;\n        uniform float material_Thickness;\n\n        #ifdef MATERIAL_HAS_THICKNESS_TEXTURE\n            uniform sampler2D material_ThicknessTexture;\n        #endif\n    #endif\n#endif\n\n// Runtime\nstruct ReflectedLight {\n    vec3 directDiffuse;\n    vec3 directSpecular;\n    vec3 indirectDiffuse;\n    vec3 indirectSpecular;\n};\n\nstruct Geometry {\n    vec3  position;\n    vec3  normal;\n    vec3  viewDir;\n    float dotNV;\n    \n    #ifdef MATERIAL_ENABLE_CLEAR_COAT\n        vec3 clearCoatNormal;\n        float clearCoatDotNV;\n    #endif\n\n    #ifdef MATERIAL_ENABLE_ANISOTROPY\n        vec3  anisotropicT;\n        vec3  anisotropicB;\n        vec3  anisotropicN;\n        float anisotropy;\n    #endif\n};\n\nstruct Material {\n    vec3  diffuseColor;\n    float roughness;\n    vec3  specularF0;\n    vec3  resolvedSpecularF0;\n    float specularF90;\n    float specularIntensity;\n    vec3  specularColor;\n    float opacity;\n    float diffuseAO;\n    float specularAO;\n    vec3  envSpecularDFG;\n    vec3  energyCompensation; // Multi-scattering energy compensation factor\n    float IOR;\n\n    #ifdef MATERIAL_ENABLE_CLEAR_COAT\n        float clearCoat;\n        float clearCoatRoughness;\n    #endif\n\n    #ifdef MATERIAL_ENABLE_IRIDESCENCE\n        float iridescenceIOR;\n        float iridescenceFactor;\n        float iridescenceThickness;\n        vec3 iridescenceSpecularColor;\n    #endif\n\n    #ifdef MATERIAL_ENABLE_SHEEN\n        float sheenRoughness;\n        vec3  sheenColor;\n        float sheenScaling;\n        float approxIBLSheenDG;\n    #endif\n\n    #ifdef MATERIAL_ENABLE_TRANSMISSION \n        vec3 absorptionCoefficient;\n        float transmission;\n        float thickness;\n    #endif\n};\n"; // eslint-disable-line
 
@@ -4918,7 +4896,9 @@ var force_over_lifetime_module = "#if defined(RENDERER_FOL_CONSTANT_MODE) || def
 
 var limit_velocity_over_lifetime_module = "#ifdef RENDERER_LVL_MODULE_ENABLED\n    uniform int renderer_LVLSpace;\n    uniform float renderer_LVLDampen;\n\n    // Scalar limit\n    #ifndef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform float renderer_LVLSpeedMaxConst;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform float renderer_LVLSpeedMinConst;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Per-axis limit\n    #ifdef RENDERER_LVL_SEPARATE_AXES\n        #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n            uniform vec3 renderer_LVLSpeedMaxConstVector;\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec3 renderer_LVLSpeedMinConstVector;\n            #endif\n        #endif\n        #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n            uniform vec2 renderer_LVLSpeedXMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedYMaxCurve[4];\n            uniform vec2 renderer_LVLSpeedZMaxCurve[4];\n            #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                uniform vec2 renderer_LVLSpeedXMinCurve[4];\n                uniform vec2 renderer_LVLSpeedYMinCurve[4];\n                uniform vec2 renderer_LVLSpeedZMinCurve[4];\n            #endif\n        #endif\n    #endif\n\n    // Drag curve\n    #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n        uniform vec2 renderer_LVLDragMaxCurve[4];\n        #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n            uniform vec2 renderer_LVLDragMinCurve[4];\n        #endif\n    #endif\n\n    float evaluateLVLDrag(float normalizedAge, float dragRand) {\n        #ifdef RENDERER_LVL_DRAG_CURVE_MODE\n            float dragMax = evaluateParticleCurve(renderer_LVLDragMaxCurve, normalizedAge);\n            #ifdef RENDERER_LVL_DRAG_IS_RANDOM_TWO\n                float dragMin = evaluateParticleCurve(renderer_LVLDragMinCurve, normalizedAge);\n                return mix(dragMin, dragMax, dragRand);\n            #else\n                return dragMax;\n            #endif\n        #else\n            return mix(renderer_LVLDragConstant.x, renderer_LVLDragConstant.y, dragRand);\n        #endif\n    }\n\n    vec3 applyLVLSpeedLimitTF(vec3 velocity, float normalizedAge, float limitRand, float effectiveDampen) {\n        #ifdef RENDERER_LVL_SEPARATE_AXES\n            vec3 limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConstVector;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConstVector, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = vec3(\n                    evaluateParticleCurve(renderer_LVLSpeedXMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedYMaxCurve, normalizedAge),\n                    evaluateParticleCurve(renderer_LVLSpeedZMaxCurve, normalizedAge)\n                );\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    vec3 minLimitSpeed = vec3(\n                        evaluateParticleCurve(renderer_LVLSpeedXMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedYMinCurve, normalizedAge),\n                        evaluateParticleCurve(renderer_LVLSpeedZMinCurve, normalizedAge)\n                    );\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            vec3 absVel = abs(velocity);\n            vec3 excess = max(absVel - limitSpeed, vec3(0.0));\n            velocity = sign(velocity) * (absVel - excess * effectiveDampen);\n        #else\n            float limitSpeed;\n            #ifdef RENDERER_LVL_SPEED_CONSTANT_MODE\n                limitSpeed = renderer_LVLSpeedMaxConst;\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    limitSpeed = mix(renderer_LVLSpeedMinConst, limitSpeed, limitRand);\n                #endif\n            #endif\n            #ifdef RENDERER_LVL_SPEED_CURVE_MODE\n                limitSpeed = evaluateParticleCurve(renderer_LVLSpeedMaxCurve, normalizedAge);\n                #ifdef RENDERER_LVL_SPEED_IS_RANDOM_TWO\n                    float minLimitSpeed = evaluateParticleCurve(renderer_LVLSpeedMinCurve, normalizedAge);\n                    limitSpeed = mix(minLimitSpeed, limitSpeed, limitRand);\n                #endif\n            #endif\n\n            float speed = length(velocity);\n            if (speed > limitSpeed && speed > 0.0) {\n                float excess = speed - limitSpeed;\n                velocity = velocity * ((speed - excess * effectiveDampen) / speed);\n            }\n        #endif\n        return velocity;\n    }\n\n#endif\n"; // eslint-disable-line
 
-var particle_feedback_simulation = "// Transform Feedback update shader for particle simulation.\n// Update order: VOL/FOL → Dampen → Drag → Position.\n// Runs once per particle per frame (no rasterization).\n\n// Previous frame TF data\nattribute vec3 a_FeedbackPosition;\nattribute vec3 a_FeedbackVelocity;\n\n// Per-particle instance data\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec3 a_StartSize;\nattribute float a_StartSpeed;\nattribute vec4 a_Random0;\nattribute vec4 a_Random1;\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\nattribute vec4 a_Random2;\n\n// Uniforms\nuniform float renderer_CurrentTime;\nuniform float renderer_DeltaTime;\nuniform vec3 renderer_Gravity;\nuniform vec2 renderer_LVLDragConstant;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform int renderer_SimulationSpace;\n\n// TF outputs\nvarying vec3 v_FeedbackPosition;\nvarying vec3 v_FeedbackVelocity;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <limit_velocity_over_lifetime_module>\n\n// Get VOL instantaneous velocity at normalizedAge\nvec3 getVOLVelocity(float normalizedAge) {\n    vec3 vel = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        #ifdef RENDERER_VOL_CONSTANT_MODE\n            vel = renderer_VOLMaxConst;\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vel = mix(renderer_VOLMinConst, vel, a_Random1.yzw);\n            #endif\n        #endif\n        #ifdef RENDERER_VOL_CURVE_MODE\n            vel = vec3(\n                evaluateParticleCurve(renderer_VOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_VOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_VOL_IS_RANDOM_TWO\n                vec3 minVel = vec3(\n                    evaluateParticleCurve(renderer_VOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_VOLMinGradientZ, normalizedAge)\n                );\n                vel = mix(minVel, vel, a_Random1.yzw);\n            #endif\n        #endif\n    #endif\n    return vel;\n}\n\n// Get FOL instantaneous acceleration at normalizedAge\nvec3 getFOLAcceleration(float normalizedAge) {\n    vec3 acc = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        #ifdef RENDERER_FOL_CONSTANT_MODE\n            acc = renderer_FOLMaxConst;\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                acc = mix(renderer_FOLMinConst, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n        #ifdef RENDERER_FOL_CURVE_MODE\n            acc = vec3(\n                evaluateParticleCurve(renderer_FOLMaxGradientX, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientY, normalizedAge),\n                evaluateParticleCurve(renderer_FOLMaxGradientZ, normalizedAge)\n            );\n            #ifdef RENDERER_FOL_IS_RANDOM_TWO\n                vec3 minAcc = vec3(\n                    evaluateParticleCurve(renderer_FOLMinGradientX, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientY, normalizedAge),\n                    evaluateParticleCurve(renderer_FOLMinGradientZ, normalizedAge)\n                );\n                acc = mix(minAcc, acc, vec3(a_Random2.x, a_Random2.y, a_Random2.z));\n            #endif\n        #endif\n    #endif\n    return acc;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float lifetime = a_ShapePositionStartLifeTime.w;\n    float normalizedAge = age / lifetime;\n    // Clamp to age on the first TF pass: particles emitted mid-frame have age < dt,\n    // so using the full dt would over-integrate. Subsequent passes are unaffected (age >= dt).\n    float dt = min(renderer_DeltaTime, age);\n\n    // normalizedAge < 0.0: stale TF slot whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 1.0 || normalizedAge < 0.0) {\n        v_FeedbackPosition = a_FeedbackPosition;\n        v_FeedbackVelocity = a_FeedbackVelocity;\n        gl_Position = vec4(0.0);\n        return;\n    }\n\n    vec4 worldRotation;\n    if (renderer_SimulationSpace == 0) {\n        worldRotation = renderer_WorldRotation;\n    } else {\n        worldRotation = a_SimulationWorldRotation;\n    }\n    vec4 invWorldRotation = quaternionConjugate(worldRotation);\n\n    // Read previous frame state (initialized by CPU on particle birth)\n    vec3 localVelocity = a_FeedbackVelocity;\n\n    // =====================================================\n    // Step 1: Apply velocity module deltas (VOL + FOL + Gravity)\n    // =====================================================\n\n    // Gravity (world space)\n    vec3 gravityDelta = renderer_Gravity * a_Random0.x * dt;\n\n    // VOL instantaneous velocity (animated velocity, not persisted)\n    vec3 volLocal = vec3(0.0);\n    vec3 volWorld = vec3(0.0);\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 vol = getVOLVelocity(normalizedAge);\n        if (renderer_VOLSpace == 0) {\n            volLocal = vol;\n        } else {\n            volWorld = vol;\n        }\n    #endif\n\n    // FOL acceleration → velocity delta (always persisted, like gravity)\n    vec3 folDeltaLocal = vec3(0.0);\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 folAcc = getFOLAcceleration(normalizedAge);\n        vec3 folVelDelta = folAcc * dt;\n        if (renderer_FOLSpace == 0) {\n            folDeltaLocal = folVelDelta;\n        } else {\n            // World FOL: convert to local and persist, same as gravity\n            folDeltaLocal = rotationByQuaternions(folVelDelta, invWorldRotation);\n        }\n    #endif\n\n    // Gravity and FOL contribute to base velocity (persisted, subject to dampen/drag).\n    vec3 gravityLocal = rotationByQuaternions(gravityDelta, invWorldRotation);\n    localVelocity += folDeltaLocal + gravityLocal;\n\n    // =====================================================\n    // Step 2 & 3: Dampen (Limit Velocity) + Drag\n    // VOL must be projected into the LVL target space so that\n    // limit/drag see the full velocity regardless of VOL.space vs LVL.space.\n    // =====================================================\n    #ifdef RENDERER_LVL_MODULE_ENABLED\n        // Precompute VOL in both spaces\n        vec3 volAsLocal = volLocal + rotationByQuaternions(volWorld, invWorldRotation);\n        vec3 volAsWorld = rotationByQuaternions(volLocal, worldRotation) + volWorld;\n\n        float limitRand = a_Random2.w;\n        float dampen = renderer_LVLDampen;\n        // Frame-rate independent dampen (30fps as reference)\n        float effectiveDampen = 1.0 - pow(1.0 - dampen, dt * 30.0);\n\n        if (renderer_LVLSpace == 0) {\n            // Local space: total = base + all VOL projected to local\n            vec3 totalLocal = localVelocity + volAsLocal;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalLocal, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = dampenedTotal - volAsLocal;\n        } else {\n            // World space: total = rotated base + all VOL projected to world\n            vec3 totalWorld = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n            vec3 dampenedTotal = applyLVLSpeedLimitTF(totalWorld, normalizedAge, limitRand, effectiveDampen);\n            localVelocity = rotationByQuaternions(dampenedTotal - volAsWorld, invWorldRotation);\n        }\n\n        // Drag: same space as dampen\n        {\n            float dragCoeff = evaluateLVLDrag(normalizedAge, a_Random2.w);\n            if (dragCoeff > 0.0) {\n                vec3 totalVel;\n                if (renderer_LVLSpace == 0) {\n                    totalVel = localVelocity + volAsLocal;\n                } else {\n                    totalVel = rotationByQuaternions(localVelocity, worldRotation) + volAsWorld;\n                }\n                float velMagSqr = dot(totalVel, totalVel);\n                float velMag = sqrt(velMagSqr);\n\n                float drag = dragCoeff;\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_SIZE\n                    float maxDim = max(a_StartSize.x, max(a_StartSize.y, a_StartSize.z));\n                    float radius = maxDim * 0.5;\n                    drag *= 3.14159265 * radius * radius;\n                #endif\n\n                #ifdef RENDERER_LVL_DRAG_MULTIPLY_VELOCITY\n                    drag *= velMagSqr;\n                #endif\n\n                if (velMag > 0.0) {\n                    float newVelMag = max(0.0, velMag - drag * dt);\n                    vec3 draggedTotal = totalVel * (newVelMag / velMag);\n                    if (renderer_LVLSpace == 0) {\n                        localVelocity = draggedTotal - volAsLocal;\n                    } else {\n                        localVelocity = rotationByQuaternions(draggedTotal - volAsWorld, invWorldRotation);\n                    }\n                }\n            }\n        }\n    #endif\n\n    // =====================================================\n    // Step 4: Integrate position in simulation space\n    // Local mode: position in local space, velocity rotated to local\n    // World mode: position in world space, velocity rotated to world\n    // =====================================================\n    // FOL is now fully in localVelocity (both local and world-space FOL).\n    // Only VOL overlay needs to be added here.\n    vec3 totalVelocity;\n    if (renderer_SimulationSpace == 0) {\n      // Local: integrate in local space\n      totalVelocity = localVelocity + volLocal\n        + rotationByQuaternions(volWorld, invWorldRotation);\n    } else {\n      // World: integrate in world space\n      totalVelocity = rotationByQuaternions(localVelocity + volLocal, worldRotation) + volWorld;\n    }\n    vec3 position = a_FeedbackPosition + totalVelocity * dt;\n\n    v_FeedbackPosition = position;\n    v_FeedbackVelocity = localVelocity;\n    gl_Position = vec4(0.0);\n}\n"; // eslint-disable-line
+var noise_module = "#ifdef RENDERER_NOISE_MODULE_ENABLED\n\n#include <noise_common>\n#include <noise_simplex_3D_grad>\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 sampleCurlNoise3D(vec3 coord) {\n    float axisOffset = 100.0;\n    vec3 gradX = simplexGrad(vec3(coord.z, coord.y, coord.x));\n    vec3 gradY = simplexGrad(vec3(coord.x + axisOffset, coord.z, coord.y));\n    vec3 gradZ = simplexGrad(vec3(coord.y, coord.x + axisOffset, coord.z));\n    return vec3(\n        gradZ.x - gradY.y,\n        gradX.x - gradZ.y,\n        gradY.x - gradX.y\n    );\n}\n\nvec3 computeNoiseVelocity(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 = sampleCurlNoise3D(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 * sampleCurlNoise3D(coord * octaveFrequencyMultiplier);\n\n        if (octaveCount >= 3) {\n            amplitude *= octaveIntensityMultiplier;\n            totalAmplitude += amplitude;\n            noiseValue += amplitude * sampleCurlNoise3D(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        // 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 += computeNoiseVelocity(noiseBasePos, normalizedAge);\n    #endif\n    vec3 position = a_FeedbackPosition + totalVelocity * dt;\n\n    v_FeedbackPosition = position;\n    v_FeedbackVelocity = localVelocity;\n    gl_Position = vec4(0.0);\n}\n"; // eslint-disable-line
 
 var sphere_billboard = "#ifdef RENDERER_MODE_SPHERE_BILLBOARD\n\tvec2 corner = a_CornerTextureCoordinate.xy + renderer_PivotOffset.xy;\n\tvec3 sideVector = normalize(cross(camera_Forward, camera_Up));\n\tvec3 upVector = normalize(cross(sideVector, camera_Forward));\n\tcorner *= computeParticleSizeBillboard(a_StartSize.xy, normalizedAge);\n    #if defined(RENDERER_ROL_CONSTANT_MODE) || defined(RENDERER_ROL_CURVE_MODE)\n        if (renderer_ThreeDStartRotation) {\n            vec3 rotation = radians(vec3(a_StartRotation0.xy, computeParticleRotationFloat(a_StartRotation0.z, age, normalizedAge)));\n            center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, rotation);\n        } else {\n            float rot = radians(computeParticleRotationFloat(a_StartRotation0.x, age, normalizedAge));\n            float c = cos(rot);\n            float s = sin(rot);\n            mat2 rotation = mat2(c, -s, s, c);\n            corner = rotation * corner;\n            center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n        }\n    #else\n        if (renderer_ThreeDStartRotation) {\n            center += renderer_SizeScale.xzy * rotationByEuler(corner.x * sideVector + corner.y * upVector, radians(a_StartRotation0));\n        } else {\n            float c = cos(radians(a_StartRotation0.x));\n            float s = sin(radians(a_StartRotation0.x));\n            mat2 rotation = mat2(c, -s, s, c);\n            corner = rotation * corner;\n            center += renderer_SizeScale.xzy * (corner.x * sideVector + corner.y * upVector);\n        }\n    #endif\n#endif"; // eslint-disable-line
 
@@ -4939,6 +4919,7 @@ var ParticleShaderLib = {
     texture_sheet_animation_module: texture_sheet_animation_module,
     force_over_lifetime_module: force_over_lifetime_module,
     limit_velocity_over_lifetime_module: limit_velocity_over_lifetime_module,
+    noise_module: noise_module,
     particle_feedback_simulation: particle_feedback_simulation,
     sphere_billboard: sphere_billboard,
     stretched_billboard: stretched_billboard,
@@ -4980,21 +4961,7 @@ var ShaderLib = _extends({
     begin_viewdir_frag: begin_viewdir_frag,
     mobile_blinnphong_frag: mobile_blinnphong_frag,
     noise_common: noise_common,
-    noise_cellular_2D: noise_cellular_2D,
-    noise_cellular_2x2: noise_cellular_2x2,
-    noise_cellular_2x2x2: noise_cellular_2x2x2,
-    noise_cellular_3D: noise_cellular_3D,
-    noise_cellular: noise_cellular,
-    noise_perlin_2D: noise_perlin_2D,
-    noise_perlin_3D: noise_perlin_3D,
-    noise_perlin_4D: noise_perlin_4D,
-    noise_perlin: noise_perlin,
-    noise_psrd_2D: noise_psrd_2D,
-    noise_simplex_2D: noise_simplex_2D,
-    noise_simplex_3D_grad: noise_simplex_3D_grad,
-    noise_simplex_3D: noise_simplex_3D,
-    noise_simplex_4D: noise_simplex_4D,
-    noise_simplex: noise_simplex
+    noise_simplex_3D_grad: noise_simplex_3D_grad
 }, ShadowLib, PBRShaderLib, {
     normal_get: normal_get
 }, ParticleShaderLib);
@@ -5787,26 +5754,492 @@ ShaderTagKey._nameMap = Object.create(null);
 }();
 ShaderProgram._counter = 0;
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/**
+ * Directive types for shader preprocessor instructions.
+ */ var ShaderPreprocessorDirective = /*#__PURE__*/ function(ShaderPreprocessorDirective) {
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Text"] = 0] = "Text";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfDef"] = 1] = "IfDef";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfNdef"] = 2] = "IfNdef";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfCmp"] = 3] = "IfCmp";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["IfExpr"] = 4] = "IfExpr";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Else"] = 5] = "Else";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Endif"] = 6] = "Endif";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Define"] = 7] = "Define";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["DefineVal"] = 8] = "DefineVal";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["DefineFunc"] = 9] = "DefineFunc";
+    ShaderPreprocessorDirective[ShaderPreprocessorDirective["Undef"] = 10] = "Undef";
+    return ShaderPreprocessorDirective;
+}({});
+
+/**
+ * @internal
+ */ var ShaderMacroProcessor = /*#__PURE__*/ function() {
+    function ShaderMacroProcessor() {}
+    /**
+   * Evaluate a flat instruction array with active macros.
+   * Macros are expanded immediately when text chunks are collected,
+   * using the current macro state at that point (conforming to GLSL/C99 §6.10 standard).
+   * @param instructions - Pre-parsed instruction array
+   * @param macros - Active runtime macros
+   * @returns Pure GLSL string with all conditionals resolved and macros expanded
+   */ ShaderMacroProcessor.evaluate = function evaluate(instructions, macros) {
+        var valueMacros = ShaderMacroProcessor._valueMacros;
+        var funcMacros = ShaderMacroProcessor._funcMacros;
+        var shaderChunks = ShaderMacroProcessor._shaderChunks;
+        valueMacros.clear();
+        funcMacros.clear();
+        shaderChunks.length = 0;
+        for(var _iterator = _create_for_of_iterator_helper_loose(macros), _step; !(_step = _iterator()).done;){
+            var _step_value = _step.value, name = _step_value[0], value = _step_value[1];
+            valueMacros.set(name, value);
+        }
+        ShaderMacroProcessor._macroFirstCharsDirty = true;
+        var index = 0;
+        var length = instructions.length;
+        while(index < length){
+            var instruction = instructions[index];
+            switch(instruction[0]){
+                case ShaderPreprocessorDirective.Text:
+                    // Immediately expand macros using current macro state (GLSL/C99 conformant)
+                    shaderChunks.push(ShaderMacroProcessor._expandChunk(instruction[1], valueMacros, funcMacros));
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.IfDef:
+                    {
+                        var name1 = instruction[1];
+                        index = valueMacros.has(name1) || funcMacros.has(name1) ? index + 1 : instruction[2];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfNdef:
+                    {
+                        var name2 = instruction[1];
+                        index = !valueMacros.has(name2) && !funcMacros.has(name2) ? index + 1 : instruction[2];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfCmp:
+                    {
+                        var name3 = instruction[1];
+                        var val = valueMacros.get(name3);
+                        var matched = val !== undefined && ShaderMacroProcessor._compareValues(Number(val) || 0, instruction[2], instruction[3]);
+                        index = matched ? index + 1 : instruction[4];
+                        break;
+                    }
+                case ShaderPreprocessorDirective.IfExpr:
+                    index = ShaderMacroProcessor._evalCondition(instruction[1], valueMacros, funcMacros) ? index + 1 : instruction[2];
+                    break;
+                case ShaderPreprocessorDirective.Else:
+                    index = instruction[1];
+                    break;
+                case ShaderPreprocessorDirective.Endif:
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.Define:
+                    valueMacros.set(instruction[1], "");
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.DefineVal:
+                    valueMacros.set(instruction[1], instruction[2]);
+                    ShaderMacroProcessor._macroFirstCharsDirty = true;
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.DefineFunc:
+                    funcMacros.set(instruction[1], {
+                        params: instruction[2],
+                        body: instruction[3]
+                    });
+                    ShaderMacroProcessor._macroFirstCharsDirty = true;
+                    index++;
+                    break;
+                case ShaderPreprocessorDirective.Undef:
+                    valueMacros.delete(instruction[1]);
+                    funcMacros.delete(instruction[1]);
+                    index++;
+                    break;
+                default:
+                    index++;
+                    break;
+            }
+        }
+        return ShaderMacroProcessor._concatChunks(shaderChunks);
+    };
+    /**
+   * Expand macros in a single text chunk using the current macro state.
+   * Returns the chunk as-is if no expandable macros exist.
+   */ ShaderMacroProcessor._expandChunk = function _expandChunk(chunk, valueMacros, funcMacros) {
+        // Fast path: no expandable macros at this point
+        if (funcMacros.size === 0) {
+            var hasExpandable = false;
+            for(var _iterator = _create_for_of_iterator_helper_loose(valueMacros), _step; !(_step = _iterator()).done;){
+                var _step_value = _step.value, val = _step_value[1];
+                if (val !== "") {
+                    hasExpandable = true;
+                    break;
+                }
+            }
+            if (!hasExpandable) return chunk;
+        }
+        // Rebuild first-char filter if macros changed
+        if (ShaderMacroProcessor._macroFirstCharsDirty) {
+            var macroFirstChars = ShaderMacroProcessor._macroFirstChars;
+            macroFirstChars.clear();
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(valueMacros.keys()), _step1; !(_step1 = _iterator1()).done;){
+                var name = _step1.value;
+                macroFirstChars.add(name.charCodeAt(0));
+            }
+            for(var _iterator2 = _create_for_of_iterator_helper_loose(funcMacros.keys()), _step2; !(_step2 = _iterator2()).done;){
+                var name1 = _step2.value;
+                macroFirstChars.add(name1.charCodeAt(0));
+            }
+            ShaderMacroProcessor._macroFirstCharsDirty = false;
+        }
+        var macroFirstChars1 = ShaderMacroProcessor._macroFirstChars;
+        var expandedNames = ShaderMacroProcessor._expandedNames;
+        var out = ShaderMacroProcessor._out;
+        out.length = 0;
+        var len = chunk.length;
+        var i = 0;
+        while(i < len){
+            var cc = chunk.charCodeAt(i);
+            if (ShaderMacroProcessor._isIdentifierStart(cc)) {
+                var start = i;
+                i++;
+                while(i < len && ShaderMacroProcessor._isIdentifierPart(chunk.charCodeAt(i)))i++;
+                // Fast path: first char not in any macro name
+                if (!macroFirstChars1.has(chunk.charCodeAt(start))) {
+                    out.push(chunk.substring(start, i));
+                    continue;
+                }
+                var name2 = chunk.substring(start, i);
+                // Try function macro
+                var func = funcMacros.get(name2);
+                if (func) {
+                    var lookAhead = i;
+                    while(lookAhead < len && (chunk.charCodeAt(lookAhead) === 32 /* space */  || chunk.charCodeAt(lookAhead) === 9))lookAhead++;
+                    if (lookAhead < len && chunk.charCodeAt(lookAhead) === 40 /* '(' */ ) {
+                        var args = ShaderMacroProcessor._parseFuncArgs(chunk, lookAhead);
+                        if (args) {
+                            i = args.end;
+                            var expanded = ShaderMacroProcessor._expandFuncBody(func, args.values);
+                            expandedNames.clear();
+                            expandedNames.add(name2);
+                            out.push(ShaderMacroProcessor._recursiveExpandMacro(expanded, valueMacros, funcMacros, expandedNames));
+                            continue;
+                        }
+                    }
+                }
+                // Try value macro
+                var val1 = valueMacros.get(name2);
+                if (val1 !== undefined && val1 !== "") {
+                    expandedNames.clear();
+                    expandedNames.add(name2);
+                    out.push(ShaderMacroProcessor._recursiveExpandMacro(val1, valueMacros, funcMacros, expandedNames));
+                    continue;
+                }
+                out.push(name2);
+                continue;
+            }
+            // Batch collect non-identifier characters
+            var batchStart = i;
+            while(i < len && !ShaderMacroProcessor._isIdentifierStart(chunk.charCodeAt(i)))i++;
+            out.push(chunk.substring(batchStart, i));
+        }
+        return out.join("");
+    };
+    /**
+   * Recursively expand macro substitution results until no more macros remain.
+   * @param macroExpansion - Intermediate text from a macro substitution that may contain further macro references
+   * @param valueMacros - Current value macro definitions
+   * @param funcMacros - Current function macro definitions
+   * @param expandedNames - Macro names already on the expansion chain, prevents circular references (C99 §6.10.3.4)
+   */ ShaderMacroProcessor._recursiveExpandMacro = function _recursiveExpandMacro(macroExpansion, valueMacros, funcMacros, expandedNames) {
+        if (macroExpansion.length === 0) return macroExpansion;
+        var len = macroExpansion.length;
+        var out = [];
+        var i = 0;
+        while(i < len){
+            var cc = macroExpansion.charCodeAt(i);
+            if (ShaderMacroProcessor._isIdentifierStart(cc)) {
+                var start = i;
+                i++;
+                while(i < len && ShaderMacroProcessor._isIdentifierPart(macroExpansion.charCodeAt(i)))i++;
+                var name = macroExpansion.substring(start, i);
+                // Skip already-expanded names (circular reference prevention)
+                // Skip GL_ prefixed names (reserved GLSL built-ins, charCodes: G=71, L=76, _=95)
+                if (expandedNames.has(name) || name.charCodeAt(0) === 71 && name.charCodeAt(1) === 76 && name.charCodeAt(2) === 95) {
+                    out.push(name);
+                    continue;
+                }
+                var func = funcMacros.get(name);
+                if (func) {
+                    var lookAhead = i;
+                    while(lookAhead < len && (macroExpansion.charCodeAt(lookAhead) === 32 /* space */  || macroExpansion.charCodeAt(lookAhead) === 9))lookAhead++;
+                    if (lookAhead < len && macroExpansion.charCodeAt(lookAhead) === 40 /* '(' */ ) {
+                        var args = ShaderMacroProcessor._parseFuncArgs(macroExpansion, lookAhead);
+                        if (args) {
+                            i = args.end;
+                            expandedNames.add(name);
+                            out.push(ShaderMacroProcessor._recursiveExpandMacro(ShaderMacroProcessor._expandFuncBody(func, args.values), valueMacros, funcMacros, expandedNames));
+                            expandedNames.delete(name);
+                            continue;
+                        }
+                    }
+                }
+                var val = valueMacros.get(name);
+                if (val !== undefined && val !== "") {
+                    expandedNames.add(name);
+                    out.push(ShaderMacroProcessor._recursiveExpandMacro(val, valueMacros, funcMacros, expandedNames));
+                    expandedNames.delete(name);
+                    continue;
+                }
+                out.push(name);
+                continue;
+            }
+            // Batch collect non-identifier characters
+            var batchStart = i;
+            while(i < len && !ShaderMacroProcessor._isIdentifierStart(macroExpansion.charCodeAt(i)))i++;
+            out.push(macroExpansion.substring(batchStart, i));
+        }
+        return out.join("");
+    };
+    /**
+   * Substitute function macro params in body.
+   */ ShaderMacroProcessor._expandFuncBody = function _expandFuncBody(func, args) {
+        if (func.params.length === 0 || args.length !== func.params.length) return func.body;
+        var result = func.body;
+        for(var i = 0; i < func.params.length; i++){
+            result = ShaderMacroProcessor._replaceWord(result, func.params[i], args[i]);
+        }
+        return result;
+    };
+    /**
+   * Evaluate a compound condition tree.
+   */ ShaderMacroProcessor._evalCondition = function _evalCondition(cond, valueMacros, funcMacros) {
+        switch(cond.t){
+            case "def":
+                return valueMacros.has(cond.m) || funcMacros.has(cond.m);
+            case "ndef":
+                return !valueMacros.has(cond.m) && !funcMacros.has(cond.m);
+            case "cmp":
+                {
+                    var val = valueMacros.get(cond.m);
+                    if (val === undefined) return false;
+                    return ShaderMacroProcessor._compareValues(Number(val) || 0, cond.op, cond.v);
+                }
+            case "and":
+                return ShaderMacroProcessor._evalCondition(cond.l, valueMacros, funcMacros) && ShaderMacroProcessor._evalCondition(cond.r, valueMacros, funcMacros);
+            case "or":
+                return ShaderMacroProcessor._evalCondition(cond.l, valueMacros, funcMacros) || ShaderMacroProcessor._evalCondition(cond.r, valueMacros, funcMacros);
+            case "not":
+                return !ShaderMacroProcessor._evalCondition(cond.c, valueMacros, funcMacros);
+            case "bool":
+                return cond.v;
+        }
+    };
+    /**
+   * Evaluate a comparison operator.
+   */ ShaderMacroProcessor._compareValues = function _compareValues(numVal, op, value) {
+        switch(op){
+            case "==":
+                return numVal === value;
+            case "!=":
+                return numVal !== value;
+            case ">":
+                return numVal > value;
+            case "<":
+                return numVal < value;
+            case ">=":
+                return numVal >= value;
+            case "<=":
+                return numVal <= value;
+            default:
+                return false;
+        }
+    };
+    /**
+   * Parse function macro call arguments.
+   * Returns reusable static result object to avoid allocation.
+   */ ShaderMacroProcessor._parseFuncArgs = function _parseFuncArgs(text, openParen) {
+        var result = ShaderMacroProcessor._parsedFuncArgs;
+        result.values.length = 0;
+        var level = 1;
+        var argStart = openParen + 1;
+        var k = argStart;
+        var len = text.length;
+        while(k < len && level > 0){
+            var cc = text.charCodeAt(k);
+            if (cc === 40 /* '(' */ ) {
+                level++;
+            } else if (cc === 41 /* ')' */ ) {
+                if (--level === 0) {
+                    var arg = text.substring(argStart, k).trim();
+                    if (arg.length > 0 || result.values.length > 0) result.values.push(arg);
+                    result.end = k + 1;
+                    return result;
+                }
+            } else if (cc === 44 /* ',' */  && level === 1) {
+                result.values.push(text.substring(argStart, k).trim());
+                argStart = k + 1;
+            }
+            k++;
+        }
+        return null;
+    };
+    /**
+   * Replace all whole-word occurrences of `word` in `text` with `replacement`.
+   */ ShaderMacroProcessor._replaceWord = function _replaceWord(text, word, replacement) {
+        var wLen = word.length;
+        var parts = ShaderMacroProcessor._replaceWordParts;
+        parts.length = 0;
+        var start = 0;
+        var idx = text.indexOf(word, start);
+        while(idx !== -1){
+            if (idx > 0 && ShaderMacroProcessor._isIdentifierPart(text.charCodeAt(idx - 1))) {
+                idx = text.indexOf(word, idx + 1);
+                continue;
+            }
+            var afterIdx = idx + wLen;
+            if (afterIdx < text.length && ShaderMacroProcessor._isIdentifierPart(text.charCodeAt(afterIdx))) {
+                idx = text.indexOf(word, idx + 1);
+                continue;
+            }
+            parts.push(text.substring(start, idx));
+            parts.push(replacement);
+            start = afterIdx;
+            idx = text.indexOf(word, start);
+        }
+        if (start === 0) return text;
+        parts.push(text.substring(start));
+        return parts.join("");
+    };
+    /**
+   * Concatenate shader chunks with consecutive blank lines collapsed to a single newline.
+   */ ShaderMacroProcessor._concatChunks = function _concatChunks(shaderChunks) {
+        var out = ShaderMacroProcessor._out;
+        out.length = 0;
+        var lastNewline = false;
+        for(var p = 0; p < shaderChunks.length; p++){
+            var text = shaderChunks[p];
+            var len = text.length;
+            var i = 0;
+            while(i < len){
+                if (text.charCodeAt(i) === 10 /* \n */ ) {
+                    if (!lastNewline) {
+                        out.push("\n");
+                        lastNewline = true;
+                    }
+                    i++;
+                    while(i < len){
+                        var c = text.charCodeAt(i);
+                        if (c === 32 /* space */  || c === 9 /* tab */  || c === 10 /* \n */ ) i++;
+                        else break;
+                    }
+                } else {
+                    var batchStart = i;
+                    while(i < len && text.charCodeAt(i) !== 10 /* \n */ )i++;
+                    out.push(text.substring(batchStart, i));
+                    lastNewline = false;
+                }
+            }
+        }
+        return out.join("");
+    };
+    /**
+   * Check if char code is a valid identifier start.
+   * Matches: [A-Z] | [a-z] | _
+   */ ShaderMacroProcessor._isIdentifierStart = function _isIdentifierStart(charCode) {
+        return charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 95;
+    };
+    /**
+   * Check if char code is a valid identifier part.
+   * Matches: [A-Z] | [a-z] | [0-9] | _
+   */ ShaderMacroProcessor._isIdentifierPart = function _isIdentifierPart(charCode) {
+        return charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode >= 48 && charCode <= 57 || charCode === 95;
+    };
+    return ShaderMacroProcessor;
+}();
+ShaderMacroProcessor._valueMacros = new Map();
+ShaderMacroProcessor._funcMacros = new Map();
+ShaderMacroProcessor._shaderChunks = [];
+ShaderMacroProcessor._out = [];
+ShaderMacroProcessor._expandedNames = new Set();
+ShaderMacroProcessor._macroFirstChars = new Set();
+ShaderMacroProcessor._macroFirstCharsDirty = true;
+ShaderMacroProcessor._replaceWordParts = [];
+ShaderMacroProcessor._parsedFuncArgs = {
+    values: [],
+    end: 0
+};
+
 var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision highp float;\n      precision highp int;\n    #else\n      precision mediump float;\n      precision mediump int;\n    #endif\n    ";
 /**
  * Shader pass containing vertex and fragment source.
  */ var ShaderPass = /*#__PURE__*/ function(ShaderPart) {
     _inherits(ShaderPass, ShaderPart);
-    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSource, fragmentSourceOrTags, tags) {
+    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSourceOrInstructions, fragmentSourceOrTags, tagsOrPlatformTarget, tags) {
         var _this;
         _this = ShaderPart.call(this) || this, /** @internal */ _this._shaderPassId = 0, /** @internal */ _this._renderStateDataMap = {}, /** @internal */ _this._shaderProgramPools = [];
         _this._shaderPassId = ShaderPass._shaderPassCounter++;
-        if (typeof fragmentSourceOrTags === "string") {
+        if (Array.isArray(vertexSourceOrFragmentSourceOrInstructions)) {
+            // Instructions overload: (name, vertexInst, fragInst, platformTarget, tags?)
             _this._name = nameOrVertexSource;
-            _this._vertexSource = vertexSourceOrFragmentSource;
-            _this._fragmentSource = fragmentSourceOrTags;
+            _this._vertexShaderInstructions = vertexSourceOrFragmentSourceOrInstructions;
+            _this._fragmentShaderInstructions = fragmentSourceOrTags;
+            _this._platformTarget = tagsOrPlatformTarget;
             tags = _extends({
                 pipelineStage: PipelineStage.Forward
             }, tags);
+        } else if (typeof fragmentSourceOrTags === "string") {
+            // Named overload: (name, vertexSource, fragmentSource, tags?)
+            _this._name = nameOrVertexSource;
+            _this._vertexSource = vertexSourceOrFragmentSourceOrInstructions;
+            _this._fragmentSource = fragmentSourceOrTags;
+            tags = _extends({
+                pipelineStage: PipelineStage.Forward
+            }, tagsOrPlatformTarget);
         } else {
+            // Unnamed overload: (vertexSource, fragmentSource, tags?)
             _this._name = "Default";
             _this._vertexSource = nameOrVertexSource;
-            _this._fragmentSource = vertexSourceOrFragmentSource;
+            _this._fragmentSource = vertexSourceOrFragmentSourceOrInstructions;
             tags = _extends({
                 pipelineStage: PipelineStage.Forward
             }, fragmentSourceOrTags);
@@ -5842,15 +6275,16 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         shaderProgramPools.length = 0;
     };
     _proto._getCanonicalShaderProgram = function _getCanonicalShaderProgram(engine, macroCollection) {
-        if (this._platformTarget != undefined) {
-            return this._getShaderLabProgram(engine, macroCollection);
-        }
-        var _ShaderFactory_compilePlatformSource = ShaderFactory.compilePlatformSource(engine, macroCollection, this._vertexSource, this._fragmentSource), vertexSource = _ShaderFactory_compilePlatformSource.vertexSource, fragmentSource = _ShaderFactory_compilePlatformSource.fragmentSource;
+        var _ref = this._platformTarget != undefined ? this._compileShaderLabSource(engine, macroCollection) : this._compilePlatformSource(engine, macroCollection), vertexSource = _ref.vertexSource, fragmentSource = _ref.fragmentSource;
         return new ShaderProgram(engine, vertexSource, fragmentSource);
     };
-    _proto._getShaderLabProgram = function _getShaderLabProgram(engine, macroCollection) {
+    _proto._compilePlatformSource = function _compilePlatformSource(engine, macroCollection) {
+        return ShaderFactory.compilePlatformSource(engine, macroCollection, this._vertexSource, this._fragmentSource);
+    };
+    _proto._compileShaderLabSource = function _compileShaderLabSource(engine, macroCollection) {
         var isWebGL2 = engine._hardwareRenderer.isWebGL2;
-        var shaderMacroList = new Array();
+        var shaderMacroList = ShaderPass._shaderMacroList;
+        shaderMacroList.length = 0;
         ShaderMacro._getMacrosElements(macroCollection, shaderMacroList);
         shaderMacroList.push(ShaderMacro.getByName(isWebGL2 ? "GRAPHICS_API_WEBGL2" : "GRAPHICS_API_WEBGL1"));
         if (engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
@@ -5859,23 +6293,31 @@ var precisionStr = "\n    #ifdef GL_FRAGMENT_PRECISION_HIGH\n      precision hig
         if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
             shaderMacroList.push(ShaderMacro.getByName("HAS_DERIVATIVES"));
         }
-        var noIncludeVertex = ShaderFactory.parseIncludes(this._vertexSource);
-        var noIncludeFrag = ShaderFactory.parseIncludes(this._fragmentSource);
-        noIncludeVertex = Shader._shaderLab._parseMacros(noIncludeVertex, shaderMacroList);
-        noIncludeFrag = Shader._shaderLab._parseMacros(noIncludeFrag, shaderMacroList);
+        var macroMap = ShaderPass._macroMap;
+        macroMap.clear();
+        for(var i = 0, n = shaderMacroList.length; i < n; i++){
+            var macro = shaderMacroList[i];
+            var _macro_value;
+            macroMap.set(macro.name, (_macro_value = macro.value) != null ? _macro_value : "");
+        }
+        var vertexSource = ShaderMacroProcessor.evaluate(this._vertexShaderInstructions, macroMap);
+        var fragmentSource = ShaderMacroProcessor.evaluate(this._fragmentShaderInstructions, macroMap);
         if (isWebGL2 && this._platformTarget === ShaderLanguage.GLSLES100) {
-            noIncludeVertex = ShaderFactory.convertTo300(noIncludeVertex);
-            noIncludeFrag = ShaderFactory.convertTo300(noIncludeFrag, true);
+            vertexSource = ShaderFactory.convertTo300(vertexSource);
+            fragmentSource = ShaderFactory.convertTo300(fragmentSource, true);
         }
         var versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
-        var vertexSource = " " + versionStr + "\n        " + noIncludeVertex + "\n      ";
-        var fragmentSource = " " + versionStr + "\n        " + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + "\n        " + precisionStr + "\n        " + noIncludeFrag + "\n      ";
-        return new ShaderProgram(engine, vertexSource, fragmentSource);
+        return {
+            vertexSource: " " + versionStr + "\n        " + vertexSource + "\n      ",
+            fragmentSource: " " + versionStr + "\n        " + (isWebGL2 ? "" : ShaderFactory._shaderExtension) + "\n        " + precisionStr + "\n        " + fragmentSource + "\n      "
+        };
     };
     return ShaderPass;
 }(ShaderPart);
 /** @internal */ ShaderPass._shaderPassCounter = 0;
 /** @internal */ ShaderPass._shaderRootPath = "shaders://root/";
+ShaderPass._shaderMacroList = [];
+ShaderPass._macroMap = new Map();
 
 /**
  * Sub shader.
@@ -6624,36 +7066,14 @@ __decorate([
             var subShaderList = shaderSource.subShaders.map(function(subShaderSource) {
                 var passList = subShaderSource.passes.map(function(passSource) {
                     if (passSource.isUsePass) {
-                        var _Shader_find_subShaders_find, _Shader_find;
-                        var _passSource_name_split = passSource.name.split("/"), shaderName = _passSource_name_split[0], subShaderName = _passSource_name_split[1], passName = _passSource_name_split[2];
-                        return (_Shader_find = Shader.find(shaderName)) == null ? void 0 : (_Shader_find_subShaders_find = _Shader_find.subShaders.find(function(subShader) {
-                            return subShader.name === subShaderName;
-                        })) == null ? void 0 : _Shader_find_subShaders_find.passes.find(function(pass) {
-                            return pass.name === passName;
-                        });
+                        return Shader._resolveUsePass(passSource.name);
                     }
                     var shaderPassSource = Shader._shaderLab._parseShaderPass(passSource.contents, passSource.vertexEntry, passSource.fragmentEntry, vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget, new URL(fragmentSourceOrPath != null ? fragmentSourceOrPath : "", ShaderPass._shaderRootPath).href);
                     if (!shaderPassSource) {
                         throw 'Shader pass "' + shaderSource.name + "." + subShaderSource.name + "." + passSource.name + '" parse failed, please check the shader source code.';
                     }
-                    var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertex, shaderPassSource.fragment, passSource.tags);
-                    shaderPass._platformTarget = vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget;
-                    var _passSource_renderStates = passSource.renderStates, constantMap = _passSource_renderStates.constantMap, variableMap = _passSource_renderStates.variableMap;
-                    // Compatible shader lab no render state use material `renderState` to modify render state
-                    if (Object.keys(constantMap).length > 0 || Object.keys(variableMap).length > 0) {
-                        // Parse const render state
-                        var renderState = new RenderState();
-                        for(var k in constantMap){
-                            Shader._applyConstRenderStates(renderState, +k, constantMap[k]);
-                        }
-                        shaderPass._renderState = renderState;
-                        // Parse variable render state
-                        var renderStateDataMap = {};
-                        for(var k1 in variableMap){
-                            renderStateDataMap[k1] = ShaderProperty.getByName(variableMap[k1]);
-                        }
-                        shaderPass._renderStateDataMap = renderStateDataMap;
-                    }
+                    var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertexShaderInstructions, shaderPassSource.fragmentShaderInstructions, vertexSourceOrShaderPassesOrSubShadersOrPlatformTarget, passSource.tags);
+                    Shader._applyRenderStates(shaderPass, passSource.renderStates.constantMap, passSource.renderStates.variableMap, false);
                     return shaderPass;
                 });
                 return new SubShader(subShaderSource.name, passList, subShaderSource.tags);
@@ -6698,6 +7118,29 @@ __decorate([
     };
     /**
    * @internal
+   */ Shader._createFromPrecompiled = function _createFromPrecompiled(data) {
+        var shaderMap = Shader._shaderMap;
+        if (shaderMap[data.name]) {
+            console.error('Shader named "' + data.name + '" already exists.');
+            return;
+        }
+        var subShaderList = data.subShaders.map(function(subData) {
+            var passList = subData.passes.map(function(passData) {
+                if (passData.isUsePass) {
+                    return Shader._resolveUsePass(passData.name);
+                }
+                var shaderPass = new ShaderPass(passData.name, passData.vertexShaderInstructions, passData.fragmentShaderInstructions, data.platformTarget, passData.tags);
+                Shader._applyRenderStates(shaderPass, passData.renderStates.constantMap, passData.renderStates.variableMap, true);
+                return shaderPass;
+            });
+            return new SubShader(subData.name, passList, subData.tags);
+        });
+        var shader = new Shader(data.name, subShaderList);
+        shaderMap[data.name] = shader;
+        return shader;
+    };
+    /**
+   * @internal
    */ Shader._clear = function _clear(engine) {
         var shaderMap = Shader._shaderMap;
         for(var key in shaderMap){
@@ -6718,6 +7161,34 @@ __decorate([
             }
         }
     };
+    Shader._resolveUsePass = function _resolveUsePass(passName) {
+        var _Shader_find_subShaders_find, _Shader_find;
+        var _passName_split = passName.split("/"), shaderName = _passName_split[0], subShaderName = _passName_split[1], passNamePart = _passName_split[2];
+        return (_Shader_find = Shader.find(shaderName)) == null ? void 0 : (_Shader_find_subShaders_find = _Shader_find.subShaders.find(function(subShader) {
+            return subShader.name === subShaderName;
+        })) == null ? void 0 : _Shader_find_subShaders_find.passes.find(function(pass) {
+            return pass.name === passNamePart;
+        });
+    };
+    Shader._applyRenderStates = function _applyRenderStates(shaderPass, constantMap, variableMap, deserializeColor) {
+        if (Object.keys(constantMap).length > 0 || Object.keys(variableMap).length > 0) {
+            var renderState = new RenderState();
+            for(var k in constantMap){
+                var value = constantMap[k];
+                if (deserializeColor && Array.isArray(value)) {
+                    Shader._applyConstRenderStates(renderState, +k, new engineMath.Color(value[0], value[1], value[2], value[3]));
+                } else {
+                    Shader._applyConstRenderStates(renderState, +k, value);
+                }
+            }
+            shaderPass._renderState = renderState;
+            var renderStateDataMap = {};
+            for(var k1 in variableMap){
+                renderStateDataMap[k1] = ShaderProperty.getByName(variableMap[k1]);
+            }
+            shaderPass._renderStateDataMap = renderStateDataMap;
+        }
+    };
     Shader._applyConstRenderStates = function _applyConstRenderStates(renderState, key, value) {
         switch(key){
             case RenderStateElementKey.BlendStateEnabled0:
@@ -9158,7 +9629,15 @@ exports.Camera = /*#__PURE__*/ function(Component) {
    */ _proto._getInvViewProjMat = function _getInvViewProjMat() {
         if (this._isInvViewProjDirty.flag) {
             this._isInvViewProjDirty.flag = false;
-            engineMath.Matrix.multiply(this._entity.transform.worldMatrix, this._getInverseProjectionMatrix(), this._invViewProjMat);
+            var matrix = this._invViewProjMat;
+            if (this._isCustomViewMatrix) {
+                engineMath.Matrix.invert(this.viewMatrix, matrix);
+            } else {
+                // Ignore scale, consistent with viewMatrix getter
+                var transform = this._entity.transform;
+                engineMath.Matrix.rotationTranslation(transform.worldRotationQuaternion, transform.worldPosition, matrix);
+            }
+            matrix.multiply(this._getInverseProjectionMatrix());
         }
         return this._invViewProjMat;
     };
@@ -22447,7 +22926,7 @@ __decorate([
     deepClone
 ], Skin.prototype, "inverseBindMatrices", void 0);
 __decorate([
-    ignoreClone
+    deepClone
 ], Skin.prototype, "_skinMatrices", void 0);
 __decorate([
     ignoreClone
@@ -23447,7 +23926,10 @@ var ComponentCloner = /*#__PURE__*/ function() {
     _proto._setActiveComponents = function _setActiveComponents(isActive, activeChangeFlag) {
         var activeChangedComponents = this._activeChangedComponents;
         for(var i = 0, length = activeChangedComponents.length; i < length; ++i){
-            activeChangedComponents[i]._setActive(isActive, activeChangeFlag);
+            var component = activeChangedComponents[i];
+            // Skip components whose scene was already cleared by an earlier callback's removeChild
+            if (!isActive && !component._entity._scene) continue;
+            component._setActive(isActive, activeChangeFlag);
         }
         this._scene._componentsManager.putActiveChangedTempList(activeChangedComponents);
         this._activeChangedComponents = null;
@@ -23467,18 +23949,19 @@ var ComponentCloner = /*#__PURE__*/ function() {
         }
     };
     _proto._setInActiveInHierarchy = function _setInActiveInHierarchy(activeChangedComponents, activeChangeFlag) {
+        // Children-first, reverse traversal for safe removeChild during callbacks
+        var children = this._children;
+        for(var i = children.length - 1; i >= 0; i--){
+            var child = children[i];
+            child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
+        }
         activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = false);
         activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = false);
         var components = this._components;
-        for(var i = 0, n = components.length; i < n; i++){
-            var component = components[i];
+        for(var i1 = 0, n = components.length; i1 < n; i1++){
+            var component = components[i1];
             component.enabled && activeChangedComponents.push(component);
         }
-        var children = this._children;
-        for(var i1 = 0, n1 = children.length; i1 < n1; i1++){
-            var child = children[i1];
-            child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
-        }
     };
     _proto._setSiblingIndex = function _setSiblingIndex(sibling, target) {
         target = Math.min(target, sibling.length - 1);
@@ -26390,7 +26873,7 @@ var depthOnlyVs = "#define MATERIAL_OMIT_NORMAL\n#include <common>\n#include <co
 
 var particleFs = "#include <common>\n\nvarying vec4 v_Color;\nvarying vec2 v_TextureCoordinate;\nuniform sampler2D material_BaseTexture;\nuniform vec4 material_BaseColor;\n \nuniform mediump vec3 material_EmissiveColor;\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n    uniform sampler2D material_EmissiveTexture;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n\tvarying vec4 v_MeshColor;\n#endif\n\nvoid main() {\n\tvec4 color = material_BaseColor * v_Color;\n\n\t#if defined(RENDERER_MODE_MESH) && defined(RENDERER_ENABLE_VERTEXCOLOR)\n\t\tcolor *= v_MeshColor;\n\t#endif\n\n\t#ifdef MATERIAL_HAS_BASETEXTURE\n\t\tcolor *= texture2DSRGB(material_BaseTexture, v_TextureCoordinate);\n\t#endif\n\t\n\t// Emissive\n\tvec3 emissiveRadiance = material_EmissiveColor;\n\t#ifdef MATERIAL_HAS_EMISSIVETEXTURE\n\t\temissiveRadiance *= texture2DSRGB(material_EmissiveTexture, v_TextureCoordinate).rgb;\n\t#endif\n\n\tcolor.rgb += emissiveRadiance;\n\n\tgl_FragColor = color;\n}"; // eslint-disable-line
 
-var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\n#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE) || defined(RENDERER_LVL_MODULE_ENABLED)\n    attribute vec4 a_Random2;\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\n#ifdef RENDERER_TRANSFORM_FEEDBACK\n    attribute vec3 a_FeedbackPosition;\n    attribute vec3 a_FeedbackVelocity;\n#endif\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = startVelocity * age;\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    // normalizedAge >= 0.0: skip stale TF slots whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 0.0 && normalizedAge < 1.0) {\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity;\n        vec3 worldVelocity;\n\n        #ifdef RENDERER_TRANSFORM_FEEDBACK\n            // Transform Feedback mode: position in simulation space (local or world).\n            // Local: transform to world; World: use directly.\n            vec3 center;\n            if (renderer_SimulationSpace == 0) {\n                center = rotationByQuaternions(a_FeedbackPosition, worldRotation) + renderer_WorldPosition;\n            } else if (renderer_SimulationSpace == 1) {\n                center = a_FeedbackPosition;\n            }\n            localVelocity = a_FeedbackVelocity;\n            worldVelocity = vec3(0.0);\n\n            #ifdef _VOL_MODULE_ENABLED\n                vec3 instantVOLVelocity;\n                computeVelocityPositionOffset(normalizedAge, age, instantVOLVelocity);\n                if (renderer_VOLSpace == 0) {\n                    localVelocity += instantVOLVelocity;\n                } else {\n                    worldVelocity += instantVOLVelocity;\n                }\n            #endif\n        #else\n            // Original analytical path\n            vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n            vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n            localVelocity = startVelocity;\n            worldVelocity = gravityVelocity;\n            vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, localVelocity, worldVelocity);\n        #endif\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
+var particleVs = "#if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n    attribute vec4 a_CornerTextureCoordinate;\n#endif\n\n#ifdef RENDERER_MODE_MESH\n    attribute vec3 POSITION;\n    #ifdef RENDERER_ENABLE_VERTEXCOLOR\n        attribute vec4 COLOR_0;\n    #endif\n    attribute vec2 TEXCOORD_0;\n    varying vec4 v_MeshColor;\n#endif\n\nattribute vec4 a_ShapePositionStartLifeTime;\nattribute vec4 a_DirectionTime;\nattribute vec4 a_StartColor;\nattribute vec3 a_StartSize;\nattribute vec3 a_StartRotation0;\nattribute float a_StartSpeed;\n\n//#if defined(COLOR_OVER_LIFETIME) || defined(RENDERER_COL_RANDOM_GRADIENTS) || defined(RENDERER_SOL_RANDOM_CURVES) || defined(RENDERER_SOL_RANDOM_CURVES_SEPARATE) || defined(ROTATION_OVER_LIFE_TIME_RANDOM_CONSTANTS) || defined(ROTATION_OVER_LIFETIME_RANDOM_CURVES)\n    attribute vec4 a_Random0;\n//#endif\n\n#if defined(RENDERER_TSA_FRAME_RANDOM_CURVES) || defined(RENDERER_VOL_IS_RANDOM_TWO)\n    attribute vec4 a_Random1; // x:texture sheet animation random\n#endif\n\n#if defined(RENDERER_FOL_CONSTANT_MODE) || defined(RENDERER_FOL_CURVE_MODE) || defined(RENDERER_LVL_MODULE_ENABLED)\n    attribute vec4 a_Random2;\n#endif\n\nattribute vec3 a_SimulationWorldPosition;\nattribute vec4 a_SimulationWorldRotation;\n\n#ifdef RENDERER_TRANSFORM_FEEDBACK\n    attribute vec3 a_FeedbackPosition;\n    attribute vec3 a_FeedbackVelocity;\n#endif\n\nvarying vec4 v_Color;\n#ifdef MATERIAL_HAS_BASETEXTURE\n    attribute vec4 a_SimulationUV;\n    varying vec2 v_TextureCoordinate;\n#endif\n\nuniform float renderer_CurrentTime;\nuniform vec3 renderer_Gravity;\nuniform vec3 renderer_WorldPosition;\nuniform vec4 renderer_WorldRotation;\nuniform bool renderer_ThreeDStartRotation;\nuniform int renderer_ScalingMode;\nuniform vec3 renderer_PositionScale;\nuniform vec3 renderer_SizeScale;\nuniform vec3 renderer_PivotOffset;\n\nuniform mat4 camera_ViewMat;\nuniform mat4 camera_ProjMat;\n\n#ifdef RENDERER_MODE_STRETCHED_BILLBOARD\n    uniform vec3 camera_Position;\n#endif\nuniform vec3 camera_Forward; // TODO:只有几种广告牌模式需要用\nuniform vec3 camera_Up;\n\nuniform float renderer_StretchedBillboardLengthScale;\nuniform float renderer_StretchedBillboardSpeedScale;\nuniform int renderer_SimulationSpace;\n\n#include <particle_common>\n#include <velocity_over_lifetime_module>\n#include <force_over_lifetime_module>\n#include <color_over_lifetime_module>\n#include <size_over_lifetime_module>\n#include <rotation_over_lifetime_module>\n#include <texture_sheet_animation_module>\n#include <noise_module>\n\nvec3 computeParticlePosition(in vec3 startVelocity, in float age, in float normalizedAge, vec3 gravityVelocity, vec4 worldRotation, inout vec3 localVelocity, inout vec3 worldVelocity) {\n    vec3 startPosition = startVelocity * age;\n\n    vec3 finalPosition;\n    vec3 localPositionOffset = startPosition;\n    vec3 worldPositionOffset;\n\n    #ifdef _VOL_MODULE_ENABLED\n        vec3 lifeVelocity;      \n        vec3 velocityPositionOffset = computeVelocityPositionOffset(normalizedAge, age, lifeVelocity);\n        if (renderer_VOLSpace == 0) {\n            localVelocity += lifeVelocity;\n            localPositionOffset += velocityPositionOffset;\n        } else {\n            worldVelocity += lifeVelocity;\n            worldPositionOffset += velocityPositionOffset;\n        }\n    #endif\n\n    #ifdef _FOL_MODULE_ENABLED\n        vec3 forceVelocity;\n        vec3 forcePositionOffset = computeForcePositionOffset(normalizedAge, age, forceVelocity);\n        if (renderer_FOLSpace == 0) {\n            localVelocity += forceVelocity;\n            localPositionOffset += forcePositionOffset;\n        } else {\n            worldVelocity += forceVelocity;\n            worldPositionOffset += forcePositionOffset;\n        }\n    #endif\n\n    finalPosition = rotationByQuaternions(a_ShapePositionStartLifeTime.xyz + localPositionOffset, worldRotation) + worldPositionOffset;\n\n    if (renderer_SimulationSpace == 0) {\n        finalPosition = finalPosition + renderer_WorldPosition;\n    } else if (renderer_SimulationSpace == 1) {\n\t    finalPosition = finalPosition + a_SimulationWorldPosition;\n\t}\n\n    finalPosition += 0.5 * gravityVelocity * age;\n\n    return finalPosition;\n}\n\nvoid main() {\n    float age = renderer_CurrentTime - a_DirectionTime.w;\n    float normalizedAge = age / a_ShapePositionStartLifeTime.w;\n    // normalizedAge >= 0.0: skip stale TF slots whose startTime is from a previous playback (e.g. after StopEmittingAndClear).\n    if (normalizedAge >= 0.0 && normalizedAge < 1.0) {\n        vec4 worldRotation;\n        if (renderer_SimulationSpace == 0) {\n            worldRotation = renderer_WorldRotation;\n        } else {\n            worldRotation = a_SimulationWorldRotation;\n        }\n\n        vec3 localVelocity;\n        vec3 worldVelocity;\n\n        #ifdef RENDERER_TRANSFORM_FEEDBACK\n            // Transform Feedback mode: position in simulation space (local or world).\n            // Local: transform to world; World: use directly.\n            vec3 center;\n            if (renderer_SimulationSpace == 0) {\n                center = rotationByQuaternions(a_FeedbackPosition, worldRotation) + renderer_WorldPosition;\n            } else if (renderer_SimulationSpace == 1) {\n                center = a_FeedbackPosition;\n            }\n            localVelocity = a_FeedbackVelocity;\n            worldVelocity = vec3(0.0);\n\n            #ifdef _VOL_MODULE_ENABLED\n                vec3 instantVOLVelocity;\n                computeVelocityPositionOffset(normalizedAge, age, instantVOLVelocity);\n                if (renderer_VOLSpace == 0) {\n                    localVelocity += instantVOLVelocity;\n                } else {\n                    worldVelocity += instantVOLVelocity;\n                }\n            #endif\n        #else\n            // Original analytical path\n            vec3 startVelocity = a_DirectionTime.xyz * a_StartSpeed;\n            vec3 gravityVelocity = renderer_Gravity * a_Random0.x * age;\n            localVelocity = startVelocity;\n            worldVelocity = gravityVelocity;\n            vec3 center = computeParticlePosition(startVelocity, age, normalizedAge, gravityVelocity, worldRotation, localVelocity, worldVelocity);\n        #endif\n\n        #include <sphere_billboard>\n        #include <stretched_billboard>\n        #include <horizontal_billboard>\n        #include <vertical_billboard>\n        #include <particle_mesh>\n\n        gl_Position = camera_ProjMat * camera_ViewMat * vec4(center, 1.0);\n        v_Color = computeParticleColor(a_StartColor, normalizedAge);\n\n        #ifdef MATERIAL_HAS_BASETEXTURE\n            vec2 simulateUV;\n            #if defined(RENDERER_MODE_SPHERE_BILLBOARD) || defined(RENDERER_MODE_STRETCHED_BILLBOARD) || defined(RENDERER_MODE_HORIZONTAL_BILLBOARD) || defined(RENDERER_MODE_VERTICAL_BILLBOARD)\n                simulateUV = a_CornerTextureCoordinate.zw * a_SimulationUV.xy + a_SimulationUV.zw;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n            #ifdef RENDERER_MODE_MESH\n                simulateUV = a_SimulationUV.zw + TEXCOORD_0 * a_SimulationUV.xy;\n                v_TextureCoordinate = computeParticleUV(simulateUV, normalizedAge);\n            #endif\n        #endif\n    } else {\n\t    gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard use out of X(-1,1),Y(-1,1),Z(0,1)\n    }\n}"; // eslint-disable-line
 
 var pbrSpecularFs = "#include <common>\n#include <camera_declare>\n\n#include <FogFragmentDeclaration>\n\n#include <uv_share>\n#include <normal_share>\n#include <color_share>\n#include <worldpos_share>\n\n#include <light_frag_define>\n\n\n#include <pbr_frag_define>\n#include <pbr_helper>\n\nvoid main() {\n    #include <pbr_frag>\n    #include <FogFragment>\n}\n"; // eslint-disable-line
 
@@ -28860,45 +29343,6 @@ Scene._fogColorProperty = ShaderProperty.getByName("scene_FogColor");
 Scene._fogParamsProperty = ShaderProperty.getByName("scene_FogParams");
 Scene._prefilterdDFGProperty = ShaderProperty.getByName("scene_PrefilteredDFG");
 
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-    return arr2;
-}
-
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-
-function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
-    if (it) return (it = it.call(o)).next.bind(it);
-    // Fallback for engines without symbol support
-    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-
-        var i = 0;
-
-        return function() {
-            if (i >= o.length) return { done: true };
-
-            return { done: false, value: o[i++] };
-        };
-    }
-
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
 /**
  * Script class, used for logic writing.
  */ var Script = /*#__PURE__*/ function(Component) {
@@ -33293,7 +33737,7 @@ var ParticleStopMode = /*#__PURE__*/ function(ParticleStopMode) {
     _inherits(ParticleRenderer, Renderer);
     function ParticleRenderer(entity) {
         var _this;
-        _this = Renderer.call(this, entity) || this, /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0, /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2, /** The pivot of particle. */ _this.pivot = new engineMath.Vector3(), /** @internal */ _this._generatorBounds = new engineMath.BoundingBox(), /** @internal */ _this._transformedBounds = new engineMath.BoundingBox();
+        _this = Renderer.call(this, entity) || this, /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0, /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2, /** The pivot of particle. */ _this.pivot = new engineMath.Vector3(), /** @internal */ _this._generatorBounds = new engineMath.BoundingBox(), /** @internal */ _this._transformedBounds = new engineMath.BoundingBox(), _this._renderMode = ParticleRenderMode.Billboard;
         _this._onGeneratorParamsChanged = _this._onGeneratorParamsChanged.bind(_this);
         _this.generator = new ParticleGenerator(_this);
         _this._currentRenderModeMacro = ParticleRenderer._billboardModeMacro;
@@ -33899,6 +34343,7 @@ ParticleTransformFeedbackSimulator._deltaTimeProperty = ShaderProperty.getByName
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["GravityModifier"] = 2759560269] = "GravityModifier";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["ForceOverLifetime"] = 3875246972] = "ForceOverLifetime";
     ParticleRandomSubSeeds[ParticleRandomSubSeeds["LimitVelocityOverLifetime"] = 3047300990] = "LimitVelocityOverLifetime";
+    ParticleRandomSubSeeds[ParticleRandomSubSeeds["Noise"] = 4105357473] = "Noise";
     return ParticleRandomSubSeeds;
 }({});
 
@@ -35282,7 +35727,7 @@ __decorate([
                         return;
                     }
                     this._enabled = value;
-                    this._generator._setTransformFeedback(value);
+                    this._generator._setTransformFeedback();
                     this._generator._renderer._onGeneratorParamsChanged();
                 }
             }
@@ -36228,6 +36673,298 @@ __decorate([
     ignoreClone
 ], TextureSheetAnimationModule.prototype, "_onTilingChanged", null);
 
+/**
+ * Noise module for particle system.
+ * Adds simplex noise-based turbulence displacement to particles.
+ */ var NoiseModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
+    _inherits(NoiseModule, ParticleGeneratorModule);
+    function NoiseModule(generator) {
+        var _this;
+        _this = ParticleGeneratorModule.call(this, generator) || this, /** @internal */ _this._noiseRand = new engineMath.Rand(0, ParticleRandomSubSeeds.Noise), _this._noiseParams = new engineMath.Vector4(), _this._noiseOctaveParams = new engineMath.Vector4(), _this._strengthMinConst = new engineMath.Vector3(), _this._scrollSpeed = 0, _this._separateAxes = false, _this._frequency = 0.5, _this._octaveCount = 1, _this._octaveIntensityMultiplier = 0.5, _this._octaveFrequencyMultiplier = 2.0;
+        _this.strengthX = new ParticleCompositeCurve(1);
+        _this.strengthY = new ParticleCompositeCurve(1);
+        _this.strengthZ = new ParticleCompositeCurve(1);
+        return _this;
+    }
+    var _proto = NoiseModule.prototype;
+    /**
+   * @internal
+   */ _proto._updateShaderData = function _updateShaderData(shaderData) {
+        var enabledMacro = null;
+        var strengthCurveMacro = null;
+        var strengthIsRandomTwoMacro = null;
+        var separateAxesMacro = null;
+        if (this.enabled) {
+            enabledMacro = NoiseModule._enabledMacro;
+            var strengthX = this._strengthX;
+            var strengthY = this._strengthY;
+            var strengthZ = this._strengthZ;
+            var separateAxes = this._separateAxes;
+            // Determine strength curve mode (following SOL pattern)
+            var isRandomCurveMode = separateAxes ? strengthX.mode === ParticleCurveMode.TwoCurves && strengthY.mode === ParticleCurveMode.TwoCurves && strengthZ.mode === ParticleCurveMode.TwoCurves : strengthX.mode === ParticleCurveMode.TwoCurves;
+            var isCurveMode = isRandomCurveMode || (separateAxes ? strengthX.mode === ParticleCurveMode.Curve && strengthY.mode === ParticleCurveMode.Curve && strengthZ.mode === ParticleCurveMode.Curve : strengthX.mode === ParticleCurveMode.Curve);
+            var isRandomConstMode = separateAxes ? strengthX.mode === ParticleCurveMode.TwoConstants && strengthY.mode === ParticleCurveMode.TwoConstants && strengthZ.mode === ParticleCurveMode.TwoConstants : strengthX.mode === ParticleCurveMode.TwoConstants;
+            // noiseParams.w = frequency (always needed)
+            var noiseParams = this._noiseParams;
+            if (isCurveMode) {
+                // Curve/TwoCurves: encode curve data as float arrays
+                shaderData.setFloatArray(NoiseModule._strengthMaxCurveXProperty, strengthX.curveMax._getTypeArray());
+                if (separateAxes) {
+                    shaderData.setFloatArray(NoiseModule._strengthMaxCurveYProperty, strengthY.curveMax._getTypeArray());
+                    shaderData.setFloatArray(NoiseModule._strengthMaxCurveZProperty, strengthZ.curveMax._getTypeArray());
+                }
+                if (isRandomCurveMode) {
+                    shaderData.setFloatArray(NoiseModule._strengthMinCurveXProperty, strengthX.curveMin._getTypeArray());
+                    if (separateAxes) {
+                        shaderData.setFloatArray(NoiseModule._strengthMinCurveYProperty, strengthY.curveMin._getTypeArray());
+                        shaderData.setFloatArray(NoiseModule._strengthMinCurveZProperty, strengthZ.curveMin._getTypeArray());
+                    }
+                    strengthIsRandomTwoMacro = NoiseModule._strengthIsRandomTwoMacro;
+                }
+                strengthCurveMacro = NoiseModule._strengthCurveMacro;
+                // xyz unused in curve mode, just set frequency
+                noiseParams.set(0, 0, 0, this._frequency);
+            } else {
+                // Constant/TwoConstants: pack strength into noiseParams.xyz
+                if (separateAxes) {
+                    noiseParams.set(strengthX.constantMax, strengthY.constantMax, strengthZ.constantMax, this._frequency);
+                } else {
+                    var s = strengthX.constantMax;
+                    noiseParams.set(s, s, s, this._frequency);
+                }
+                if (isRandomConstMode) {
+                    var minConst = this._strengthMinConst;
+                    if (separateAxes) {
+                        minConst.set(strengthX.constantMin, strengthY.constantMin, strengthZ.constantMin);
+                    } else {
+                        var sMin = strengthX.constantMin;
+                        minConst.set(sMin, sMin, sMin);
+                    }
+                    shaderData.setVector3(NoiseModule._strengthMinConstProperty, minConst);
+                    strengthIsRandomTwoMacro = NoiseModule._strengthIsRandomTwoMacro;
+                }
+            }
+            shaderData.setVector4(NoiseModule._noiseProperty, noiseParams);
+            if (separateAxes) {
+                separateAxesMacro = NoiseModule._separateAxesMacro;
+            }
+            var noiseOctaveParams = this._noiseOctaveParams;
+            noiseOctaveParams.set(this._scrollSpeed, this._octaveCount, this._octaveIntensityMultiplier, this._octaveFrequencyMultiplier);
+            shaderData.setVector4(NoiseModule._noiseOctaveProperty, noiseOctaveParams);
+        }
+        this._enabledModuleMacro = this._enableMacro(shaderData, this._enabledModuleMacro, enabledMacro);
+        this._strengthCurveModeMacro = this._enableMacro(shaderData, this._strengthCurveModeMacro, strengthCurveMacro);
+        this._strengthIsRandomTwoModeMacro = this._enableMacro(shaderData, this._strengthIsRandomTwoModeMacro, strengthIsRandomTwoMacro);
+        this._separateAxesModeMacro = this._enableMacro(shaderData, this._separateAxesModeMacro, separateAxesMacro);
+    };
+    /**
+   * @internal
+   */ _proto._resetRandomSeed = function _resetRandomSeed(seed) {
+        this._noiseRand.reset(seed, ParticleRandomSubSeeds.Noise);
+    };
+    _create_class(NoiseModule, [
+        {
+            key: "separateAxes",
+            get: /**
+   * Specifies whether the strength is separate on each axis, when disabled, only `strength` is used.
+   */ function get() {
+                return this._separateAxes;
+            },
+            set: function set(value) {
+                if (value !== this._separateAxes) {
+                    this._separateAxes = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "strengthX",
+            get: /**
+   * Noise strength. When `separateAxes` is disabled, applies to all axes.
+   * When `separateAxes` is enabled, applies only to x axis.
+   */ function get() {
+                return this._strengthX;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthX;
+                if (value !== lastValue) {
+                    this._strengthX = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "strengthY",
+            get: /**
+   * Noise strength for y axis, used when `separateAxes` is enabled.
+   */ function get() {
+                return this._strengthY;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthY;
+                if (value !== lastValue) {
+                    this._strengthY = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "strengthZ",
+            get: /**
+   * Noise strength for z axis, used when `separateAxes` is enabled.
+   */ function get() {
+                return this._strengthZ;
+            },
+            set: function set(value) {
+                var lastValue = this._strengthZ;
+                if (value !== lastValue) {
+                    this._strengthZ = value;
+                    this._onCompositeCurveChange(lastValue, value);
+                }
+            }
+        },
+        {
+            key: "frequency",
+            get: /**
+   * Noise spatial frequency.
+   */ function get() {
+                return this._frequency;
+            },
+            set: function set(value) {
+                value = Math.max(1e-6, value);
+                if (value !== this._frequency) {
+                    this._frequency = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "scrollSpeed",
+            get: /**
+   * Noise field scroll speed over time.
+   */ function get() {
+                return this._scrollSpeed;
+            },
+            set: function set(value) {
+                if (value !== this._scrollSpeed) {
+                    this._scrollSpeed = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveCount",
+            get: /**
+   * Number of noise octave layers (1-3).
+   */ function get() {
+                return this._octaveCount;
+            },
+            set: function set(value) {
+                value = Math.max(1, Math.min(3, Math.floor(value)));
+                if (value !== this._octaveCount) {
+                    this._octaveCount = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveIntensityMultiplier",
+            get: /**
+   * Intensity multiplier for each successive octave, only effective when `octaveCount` > 1.
+   * Each layer's contribution is scaled by this factor relative to the previous layer, range [0, 1].
+   */ function get() {
+                return this._octaveIntensityMultiplier;
+            },
+            set: function set(value) {
+                value = Math.max(0, Math.min(1, value));
+                if (value !== this._octaveIntensityMultiplier) {
+                    this._octaveIntensityMultiplier = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "octaveFrequencyMultiplier",
+            get: /**
+   * Frequency multiplier for each successive octave, only effective when `octaveCount` > 1.
+   * Each layer samples at this multiple of the previous layer's frequency, range [1, 4].
+   */ function get() {
+                return this._octaveFrequencyMultiplier;
+            },
+            set: function set(value) {
+                value = Math.max(1, Math.min(4, value));
+                if (value !== this._octaveFrequencyMultiplier) {
+                    this._octaveFrequencyMultiplier = value;
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        },
+        {
+            key: "enabled",
+            get: function get() {
+                return this._enabled;
+            },
+            set: function set(value) {
+                if (value !== this._enabled) {
+                    if (value && !this._generator._renderer.engine._hardwareRenderer.isWebGL2) {
+                        return;
+                    }
+                    this._enabled = value;
+                    this._generator._setTransformFeedback();
+                    this._generator._renderer._onGeneratorParamsChanged();
+                }
+            }
+        }
+    ]);
+    return NoiseModule;
+}(ParticleGeneratorModule);
+NoiseModule._enabledMacro = ShaderMacro.getByName("RENDERER_NOISE_MODULE_ENABLED");
+NoiseModule._strengthCurveMacro = ShaderMacro.getByName("RENDERER_NOISE_STRENGTH_CURVE");
+NoiseModule._strengthIsRandomTwoMacro = ShaderMacro.getByName("RENDERER_NOISE_STRENGTH_IS_RANDOM_TWO");
+NoiseModule._separateAxesMacro = ShaderMacro.getByName("RENDERER_NOISE_IS_SEPARATE");
+NoiseModule._noiseProperty = ShaderProperty.getByName("renderer_NoiseParams");
+NoiseModule._noiseOctaveProperty = ShaderProperty.getByName("renderer_NoiseOctaveParams");
+NoiseModule._strengthMinConstProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinConst");
+NoiseModule._strengthMaxCurveXProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveX");
+NoiseModule._strengthMaxCurveYProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveY");
+NoiseModule._strengthMaxCurveZProperty = ShaderProperty.getByName("renderer_NoiseStrengthMaxCurveZ");
+NoiseModule._strengthMinCurveXProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveX");
+NoiseModule._strengthMinCurveYProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveY");
+NoiseModule._strengthMinCurveZProperty = ShaderProperty.getByName("renderer_NoiseStrengthMinCurveZ");
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_enabledModuleMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthCurveModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthIsRandomTwoModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_separateAxesModeMacro", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseRand", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseParams", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_noiseOctaveParams", void 0);
+__decorate([
+    ignoreClone
+], NoiseModule.prototype, "_strengthMinConst", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthX", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthY", void 0);
+__decorate([
+    deepClone
+], NoiseModule.prototype, "_strengthZ", void 0);
+
 /**
  * Velocity over lifetime module.
  */ var VelocityOverLifetimeModule = /*#__PURE__*/ function(ParticleGeneratorModule) {
@@ -36434,6 +37171,7 @@ __decorate([
         this.forceOverLifetime = new ForceOverLifetimeModule(this);
         this.sizeOverLifetime = new SizeOverLifetimeModule(this);
         this.limitVelocityOverLifetime = new LimitVelocityOverLifetimeModule(this);
+        this.noise = new NoiseModule(this);
         this.emission.enabled = true;
     }
     var _proto = ParticleGenerator.prototype;
@@ -36741,6 +37479,7 @@ __decorate([
         this.sizeOverLifetime._updateShaderData(shaderData);
         this.rotationOverLifetime._updateShaderData(shaderData);
         this.colorOverLifetime._updateShaderData(shaderData);
+        this.noise._updateShaderData(shaderData);
     };
     /**
    * @internal
@@ -36754,16 +37493,19 @@ __decorate([
         this.limitVelocityOverLifetime._resetRandomSeed(seed);
         this.rotationOverLifetime._resetRandomSeed(seed);
         this.colorOverLifetime._resetRandomSeed(seed);
+        this.noise._resetRandomSeed(seed);
     };
     /**
    * @internal
-   */ _proto._setTransformFeedback = function _setTransformFeedback(enabled) {
-        this._useTransformFeedback = enabled;
+   */ _proto._setTransformFeedback = function _setTransformFeedback() {
+        var needed = this.limitVelocityOverLifetime.enabled || this.noise.enabled;
+        if (needed === this._useTransformFeedback) return;
+        this._useTransformFeedback = needed;
         // Switching TF mode invalidates all active particle state: feedback buffers and instance
         // buffer layout are incompatible between the two paths. Clear rather than show a one-frame
         // jump; new particles will fill in naturally from the next emit cycle.
         this._clearActiveParticles();
-        if (enabled) {
+        if (needed) {
             if (!this._feedbackSimulator) {
                 this._feedbackSimulator = new ParticleTransformFeedbackSimulator(this._renderer.engine);
             }
@@ -36813,9 +37555,7 @@ __decorate([
     /**
    * @internal
    */ _proto._cloneTo = function _cloneTo(target) {
-        if (target.limitVelocityOverLifetime.enabled) {
-            target._setTransformFeedback(true);
-        }
+        target._setTransformFeedback();
     };
     /**
    * @internal
@@ -36977,10 +37717,6 @@ __decorate([
         // Start rotation
         var startRotationRand = main._startRotationRand, flipRotation = main.flipRotation;
         var isFlip = flipRotation > startRotationRand.random();
-        // @todo:None-Mesh mode should inverse the rotation, maybe should unify it
-        if (this._renderer.renderMode !== ParticleRenderMode.Mesh) {
-            isFlip = !isFlip;
-        }
         var rotationZ = main.startRotationZ.evaluate(undefined, startRotationRand.random());
         if (main.startRotation3D) {
             var rotationX = main.startRotationX.evaluate(undefined, startRotationRand.random());
@@ -37006,7 +37742,9 @@ __decorate([
         if (colorOverLifetime.enabled && colorOverLifetime.color.mode === ParticleGradientMode.TwoGradients) {
             instanceVertices[offset + 20] = colorOverLifetime._colorGradientRand.random();
         }
-        // instanceVertices[offset + 21] = rand.random();
+        if (this.noise.enabled) {
+            instanceVertices[offset + 21] = this.noise._noiseRand.random();
+        }
         var rotationOverLifetime = this.rotationOverLifetime;
         if (rotationOverLifetime.enabled && rotationOverLifetime.rotationZ.mode === ParticleCurveMode.TwoConstants) {
             instanceVertices[offset + 22] = rotationOverLifetime._rotationRand.random();
@@ -37294,6 +38032,21 @@ __decorate([
         out.transform(rotateMat);
         min.add(worldOffsetMin);
         max.add(worldOffsetMax);
+        // Noise module impact: noise output is normalized to [-1, 1],
+        // max displacement = |strength_max|
+        var noise = this.noise;
+        if (noise.enabled) {
+            var noiseMaxX, noiseMaxY, noiseMaxZ;
+            if (noise.separateAxes) {
+                noiseMaxX = Math.abs(noise.strengthX._getMax());
+                noiseMaxY = Math.abs(noise.strengthY._getMax());
+                noiseMaxZ = Math.abs(noise.strengthZ._getMax());
+            } else {
+                noiseMaxX = noiseMaxY = noiseMaxZ = Math.abs(noise.strengthX._getMax());
+            }
+            min.set(min.x - noiseMaxX, min.y - noiseMaxY, min.z - noiseMaxZ);
+            max.set(max.x + noiseMaxX, max.y + noiseMaxY, max.z + noiseMaxZ);
+        }
         min.add(worldPosition);
         max.add(worldPosition);
     };
@@ -37391,6 +38144,9 @@ __decorate([
 __decorate([
     deepClone
 ], ParticleGenerator.prototype, "textureSheetAnimation", void 0);
+__decorate([
+    deepClone
+], ParticleGenerator.prototype, "noise", void 0);
 __decorate([
     ignoreClone
 ], ParticleGenerator.prototype, "_playTime", void 0);
@@ -39594,6 +40350,7 @@ exports.MeshRenderer = MeshRenderer;
 exports.MeshShape = MeshShape;
 exports.MeshTopology = MeshTopology;
 exports.ModelMesh = ModelMesh;
+exports.NoiseModule = NoiseModule;
 exports.OverflowMode = OverflowMode;
 exports.PBRMaterial = PBRMaterial;
 exports.ParticleCompositeCurve = ParticleCompositeCurve;