@neutrinoparticles/js-v1.1-phaser 1.1.0 → 1.1.2

package/dist/neutrinoparticles.js-v1.1-phaser.es.js

@@ -1,12 +1,20 @@
 var K = Object.defineProperty;
-var z = (s, e, t) => e in s ? K(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var n = (s, e, t) => z(s, typeof e != "symbol" ? e + "" : e, t);
+var N = (s, e, t) => e in s ? K(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var n = (s, e, t) => N(s, typeof e != "symbol" ? e + "" : e, t);
 import Phaser from "phaser";
 import * as Neutrino from "@neutrinoparticles/js-v1.1";
 const vertexShaderSource = `#version 300 es
 precision highp float;
-
-uniform sampler2D uDataTexture;
+precision highp int;
+precision highp usampler2D;
+
+// RGBA32UI, not RGBA32F: the record mixes f32 fields with u32-packed words
+// (flags, color, grid config, strip neighbor indices). Fetched as floats those
+// words are subnormal/NaN patterns, which a driver may flush or canonicalize —
+// Mali does (issue #348) — and a lowp/mediump float sampler may even return
+// them through fp16. An integer fetch is bit-exact by spec; the f32 fields are
+// reinterpreted with uintBitsToFloat, which is lossless for normal floats.
+uniform usampler2D uDataTexture;
 uniform int uDataTextureWidth;
 uniform vec3 uCameraRight;
 uniform vec3 uCameraUp;
@@ -47,12 +55,16 @@ flat out int vBatchTextureIndex;
 flat out vec4 vAtlasRemap;
 flat out int vStripPath;
 
-vec4 fetchTexel(int globalTexelIndex) {
+uvec4 fetchTexelU(int globalTexelIndex) {
     int x = globalTexelIndex % uDataTextureWidth;
     int y = globalTexelIndex / uDataTextureWidth;
     return texelFetch(uDataTexture, ivec2(x, y), 0);
 }
 
+vec4 fetchTexel(int globalTexelIndex) {
+    return uintBitsToFloat(fetchTexelU(globalTexelIndex));
+}
+
 // Strip geometry helpers (port of GPU33 makeScreenSpaceStrip).
 // 2D screen-space variant used by the Faced strip frame; world Z reaches
 // gl_Position only through uViewProjMatrix (ortho or v1.0-parity perspective).
@@ -66,13 +78,17 @@ void main() {
 
     int baseTexel = particleIndex * 4;
 
-    vec4 t0 = fetchTexel(baseTexel + 0);
+    // Texels 0 and 3 carry the u32-packed words: keep their raw uvec4 next to
+    // the float view so the words never pass through a float.
+    uvec4 u0 = fetchTexelU(baseTexel + 0);
+    uvec4 u3 = fetchTexelU(baseTexel + 3);
+    vec4 t0 = uintBitsToFloat(u0);
     vec4 t1 = fetchTexel(baseTexel + 1);
     vec4 t2 = fetchTexel(baseTexel + 2);
-    vec4 t3 = fetchTexel(baseTexel + 3);
+    vec4 t3 = uintBitsToFloat(u3);
 
-    // Texel 0: flags (uint32 bits in float), posX, posY, posZ
-    uint flags = floatBitsToUint(t0.r);
+    // Texel 0: flags (u32), posX, posY, posZ
+    uint flags = u0.r;
     vec3 position = t0.gba;
     uint rotationType = (flags >> 8u) & 3u;
     uint ctorType = (flags >> 10u) & 3u;
@@ -105,7 +121,8 @@ void main() {
         int siblingTexel = isCur ? (baseTexel + 4) : (baseTexel - 4);
         vec4 ts0 = fetchTexel(siblingTexel + 0);
         vec4 ts1 = fetchTexel(siblingTexel + 1);
-        vec4 ts3 = fetchTexel(siblingTexel + 3);
+        uvec4 us3 = fetchTexelU(siblingTexel + 3);
+        vec4 ts3 = uintBitsToFloat(us3);
 
         // p1 always = position of the meta_cur end; p2 = meta_nex end.
         vec3 p1 = isCur ? t0.gba : ts0.gba;
@@ -117,8 +134,8 @@ void main() {
         float texU2 = isCur ? ts1.g : t1.g;
 
         // Color: meta_cur stores color of p1, meta_nex stores color of p2.
-        uint packedColorCur = floatBitsToUint(isCur ? t3.r : ts3.r);
-        uint packedColorNex = floatBitsToUint(isCur ? ts3.r : t3.r);
+        uint packedColorCur = isCur ? u3.r : us3.r;
+        uint packedColorNex = isCur ? us3.r : u3.r;
         vec4 color1 = vec4(
             float(packedColorCur & 0xFFu) / 255.0,
             float((packedColorCur >> 8u) & 0xFFu) / 255.0,
@@ -147,8 +164,8 @@ void main() {
         // Both are direct position-texel indices (NOT pair-cur indices that
         // would need a +1 offset for the nex slot). Boundary detection uses
         // selfPairCurTexel for both.
-        uint neighborIdxP0 = floatBitsToUint(isCur ? t3.g : ts3.g);
-        uint neighborIdxP3 = floatBitsToUint(isCur ? ts3.b : t3.b);
+        uint neighborIdxP0 = isCur ? u3.g : us3.g;
+        uint neighborIdxP3 = isCur ? us3.b : u3.b;
         uint selfPairCurTexel = uint(isCur ? baseTexel : siblingTexel) / 4u;
 
         vec3 p0 = (neighborIdxP0 == selfPairCurTexel)
@@ -521,8 +538,8 @@ void main() {
     vec2 origin = t1.rg;
     vec2 size = t1.ba;
 
-    // Texel 3: packed colorRGBA (uint32 bits in float), packed gridConfig (uint32 bits), gridIndex
-    uint packedColor = floatBitsToUint(t3.r);
+    // Texel 3: packed colorRGBA (u32), packed gridConfig (u32), gridIndex (f32)
+    uint packedColor = u3.r;
     vColor = vec4(
         float(packedColor & 0xFFu) / 255.0,
         float((packedColor >> 8u) & 0xFFu) / 255.0,
@@ -534,7 +551,7 @@ void main() {
     // here. S=1 for LDR colors (no-op). Alpha is untouched.
     vColor.rgb *= t3.a;
 
-    uint gridConfig = floatBitsToUint(t3.g);
+    uint gridConfig = u3.g;
     float gridWidth = max(float(gridConfig & 0xFFFFu), 1.0);
     float gridHeight = max(float((gridConfig >> 16u) & 0xFFFFu), 1.0);
     // gridIndex must be truncated to an integer to pick a single cell —
@@ -601,8 +618,16 @@ void main() {
     // Texture coordinates with grid + atlas remap
     vec2 baseTexCoord = TEX_COORD[vertexIndex];
 
-    float gx = mod(gridIndex, gridWidth);
+    // #283: gx must come from the SAME quotient as gy. GLSL mod(x,y) is
+    // x - y*floor(x/y), but the driver may evaluate its internal quotient
+    // differently from the floor() below (reciprocal-multiply / FMA). At exact
+    // multiples of gridWidth the two disagreed — mod(15,15) gave 15 while
+    // floor(15/15) gave 0 — addressing column 15 of a 15-column grid, whose U
+    // range starts at 1.0 (off the atlas), so the first cell of every row
+    // sampled the clamped transparent edge and vanished. The clamp keeps a
+    // rounding-induced gx == gridWidth inside the last column.
     float gy = floor(gridIndex / gridWidth);
+    float gx = clamp(gridIndex - gy * gridWidth, 0.0, gridWidth - 1.0);
     float cellW = 1.0 / gridWidth;
     float cellH = 1.0 / gridHeight;
 
@@ -688,6 +713,13 @@ void main() {
     else texColor = useGrad ? textureGrad(uTextures[7], atlasUV, gradX, gradY) : texture(uTextures[7], atlasUV);
 
     fragColor = texColor * vColor;
+    // Premultiply the per-particle alpha into RGB. texColor is premultiplied but
+    // vColor.a is not, and every blend func expects a premultiplied source:
+    // NORMAL (ONE, 1-src.a) would only reduce how much background shows through,
+    // ADD (ONE, ONE) would ignore alpha entirely, and MULTIPLY
+    // (DST_COLOR, 1-src.a) would brighten the destination as alpha drops instead
+    // of leaving it untouched.
+    fragColor.rgb *= vColor.a;
     // Apply host world alpha. texColor is premultiplied and the blend funcs use
     // a src factor of ONE (NORMAL) / ONE,ONE (ADD), so the whole RGBA must be
     // scaled — fading RGB, not just the alpha channel — to dim correctly in both
@@ -1227,8 +1259,12 @@ void main() {
     // Texture coordinates with grid + atlas remap
     vec2 baseTexCoord = texCoordOf(corner);
 
-    float gx = mod(gridIndex, gridWidth);
+    // #283: gx must come from the SAME quotient as gy — see particle.vert.
+    // mod(x,y) and a separate floor(x/y) can disagree at exact multiples of
+    // gridWidth (mod(15,15) -> 15, floor(15/15) -> 0), which addressed a
+    // column past the grid and blanked the first cell of every row.
     float gy = floor(gridIndex / gridWidth);
+    float gx = clamp(gridIndex - gy * gridWidth, 0.0, gridWidth - 1.0);
     float cellW = 1.0 / gridWidth;
     float cellH = 1.0 / gridHeight;
 
@@ -1296,8 +1332,13 @@ void main() {
     // texColor is premultiplied and blend src factors are ONE-based, so the
     // world alpha scales the whole RGBA (mirror of the ES 3.00 shader).
     gl_FragColor = texColor * vColor * uWorldAlpha;
+    // Premultiply the per-particle alpha into RGB: vColor.a is not premultiplied,
+    // so without this ADD ignores alpha entirely, NORMAL only reduces background
+    // show-through, and MULTIPLY brightens the destination as alpha drops.
+    // Mirror of the ES 3.00 shader.
+    gl_FragColor.rgb *= vColor.a;
 }
-`, A = class A {
+`, S = class S {
   constructor(e, t) {
     n(this, "neutrino");
     // On a WebGL1 context this actually holds a WebGLRenderingContext; the
@@ -1310,7 +1351,7 @@ void main() {
     n(this, "_vao", null);
     // WebGL1 render path state (TDD_js-v1.1-webgl1.md)
     n(this, "_isWebGL1", !1);
-    n(this, "_maxBatchTextures", A.MAX_BATCH_TEXTURES);
+    n(this, "_maxBatchTextures", S.MAX_BATCH_TEXTURES);
     n(this, "_hasElementIndexUint", !1);
     n(this, "_vaoExt", null);
     n(this, "_aIdBuffer", null);
@@ -1413,14 +1454,14 @@ void main() {
       throw new Error(
         `NeutrinoParticles (js-v1.1): the effect needs 32-bit indices (${e} particles) but this WebGL1 context lacks OES_element_index_uint.`
       );
-    const c = l ? new Uint32Array(e * 6) : new Uint16Array(e * 6);
+    const d = l ? new Uint32Array(e * 6) : new Uint16Array(e * 6);
     for (let i = 0; i < e; i++) {
-      const u = i * 4, _ = i * 6;
-      c[_ + 0] = u + 0, c[_ + 1] = u + 1, c[_ + 2] = u + 2, c[_ + 3] = u + 0, c[_ + 4] = u + 2, c[_ + 5] = u + 3;
+      const c = i * 4, g = i * 6;
+      d[g + 0] = c + 0, d[g + 1] = c + 1, d[g + 2] = c + 2, d[g + 3] = c + 0, d[g + 4] = c + 2, d[g + 5] = c + 3;
     }
-    if (this._indexBuffer = t.createBuffer(), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this._indexBuffer), t.bufferData(t.ELEMENT_ARRAY_BUFFER, c, t.STATIC_DRAW), this._isWebGL1) {
+    if (this._indexBuffer = t.createBuffer(), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this._indexBuffer), t.bufferData(t.ELEMENT_ARRAY_BUFFER, d, t.STATIC_DRAW), this._isWebGL1) {
       const i = new Float32Array(e * 4);
-      for (let u = 0; u < i.length; u++) i[u] = u;
+      for (let c = 0; c < i.length; c++) i[c] = c;
       this._aIdBuffer = t.createBuffer(), t.bindBuffer(t.ARRAY_BUFFER, this._aIdBuffer), t.bufferData(t.ARRAY_BUFFER, i, t.STATIC_DRAW);
     } else
       this._dummyVB = t.createBuffer(), t.bindBuffer(t.ARRAY_BUFFER, this._dummyVB), t.bufferData(t.ARRAY_BUFFER, e * 4, t.STATIC_DRAW), this._vao = t.createVertexArray(), t.bindVertexArray(this._vao), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this._indexBuffer), t.bindBuffer(t.ARRAY_BUFFER, this._dummyVB), t.enableVertexAttribArray(0), t.vertexAttribPointer(0, 1, t.UNSIGNED_BYTE, !1, 0, 0), t.bindVertexArray(a);
@@ -1470,7 +1511,7 @@ void main() {
     const r = e.getParameter(e.MAX_COMBINED_TEXTURE_IMAGE_UNITS), o = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS);
     this._maxBatchTextures = Math.max(
       1,
-      Math.min(A.MAX_BATCH_TEXTURES, r - 2, o)
+      Math.min(S.MAX_BATCH_TEXTURES, r - 2, o)
     );
   }
   /**
@@ -1495,33 +1536,33 @@ void main() {
 `, a = `precision mediump float;
 varying vec4 vC;
 void main() { gl_FragColor = vC; }
-`, r = e.getParameter(e.VIEWPORT), o = e.getParameter(e.CURRENT_PROGRAM), l = e.getParameter(e.ARRAY_BUFFER_BINDING), c = e.getParameter(e.FRAMEBUFFER_BINDING), i = e.getParameter(e.ACTIVE_TEXTURE);
+`, r = e.getParameter(e.VIEWPORT), o = e.getParameter(e.CURRENT_PROGRAM), l = e.getParameter(e.ARRAY_BUFFER_BINDING), d = e.getParameter(e.FRAMEBUFFER_BINDING), i = e.getParameter(e.ACTIVE_TEXTURE);
     e.activeTexture(e.TEXTURE0);
-    const u = e.getParameter(e.TEXTURE_BINDING_2D);
+    const c = e.getParameter(e.TEXTURE_BINDING_2D);
     e.activeTexture(e.TEXTURE1);
-    const _ = e.getParameter(e.TEXTURE_BINDING_2D), y = e.isEnabled(e.BLEND), E = e.isEnabled(e.DEPTH_TEST), I = e.isEnabled(e.SCISSOR_TEST);
-    let m = null, w = null, B = null, f = null, v = null, g = null, d = -1, b = !1, x = null, h = 4, U = 0, p = 0, R = 0, D = !1, S = !1;
-    const T = new Uint8Array(4);
+    const g = e.getParameter(e.TEXTURE_BINDING_2D), U = e.isEnabled(e.BLEND), P = e.isEnabled(e.DEPTH_TEST), A = e.isEnabled(e.SCISSOR_TEST);
+    let v = null, b = null, R = null, y = null, x = null, m = null, u = -1, T = !1, E = null, p = 4, h = 0, f = 0, w = 0, C = !1, B = !1;
+    const _ = new Uint8Array(4);
     try {
-      m = e.createProgram(), e.attachShader(m, this._compileShader(e.VERTEX_SHADER, t)), e.attachShader(m, this._compileShader(e.FRAGMENT_SHADER, a)), e.linkProgram(m);
-      const C = (P, F) => {
+      v = e.createProgram(), e.attachShader(v, this._compileShader(e.VERTEX_SHADER, t)), e.attachShader(v, this._compileShader(e.FRAGMENT_SHADER, a)), e.linkProgram(v);
+      const D = (I, F) => {
         const M = e.createTexture();
-        return e.bindTexture(e.TEXTURE_2D, M), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, P, F), M;
+        return e.bindTexture(e.TEXTURE_2D, M), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, I, F), M;
       };
-      e.activeTexture(e.TEXTURE0), w = C(e.FLOAT, new Float32Array([1, 0.5, 0.25, 1])), B = C(e.UNSIGNED_BYTE, new Uint8Array([51, 102, 153, 255])), f = e.createTexture(), e.bindTexture(e.TEXTURE_2D, f), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, e.UNSIGNED_BYTE, null), v = e.createFramebuffer(), e.bindFramebuffer(e.FRAMEBUFFER, v), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, f, 0), g = e.createBuffer(), e.bindBuffer(e.ARRAY_BUFFER, g), e.bufferData(e.ARRAY_BUFFER, new Float32Array([0]), e.STATIC_DRAW), S = e.getProgramParameter(m, e.LINK_STATUS), S && (e.useProgram(m), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, w), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, B), e.uniform1i(e.getUniformLocation(m, "uF"), 0), e.uniform1i(e.getUniformLocation(m, "uB"), 1), d = e.getAttribLocation(m, "aId"), b = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_ENABLED), x = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING), h = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_SIZE), U = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_TYPE), D = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_NORMALIZED), p = e.getVertexAttrib(d, e.VERTEX_ATTRIB_ARRAY_STRIDE), R = e.getVertexAttribOffset(d, e.VERTEX_ATTRIB_ARRAY_POINTER), e.enableVertexAttribArray(d), e.vertexAttribPointer(d, 1, e.FLOAT, !1, 0, 0), e.viewport(0, 0, 1, 1), e.disable(e.BLEND), e.disable(e.DEPTH_TEST), e.disable(e.SCISSOR_TEST), e.drawArrays(e.POINTS, 0, 1), e.readPixels(0, 0, 1, 1, e.RGBA, e.UNSIGNED_BYTE, T), S = Math.abs(T[0] - 51) <= 2 && Math.abs(T[1] - 51) <= 2 && Math.abs(T[2] - 38) <= 2);
+      e.activeTexture(e.TEXTURE0), b = D(e.FLOAT, new Float32Array([1, 0.5, 0.25, 1])), R = D(e.UNSIGNED_BYTE, new Uint8Array([51, 102, 153, 255])), y = e.createTexture(), e.bindTexture(e.TEXTURE_2D, y), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, e.UNSIGNED_BYTE, null), x = e.createFramebuffer(), e.bindFramebuffer(e.FRAMEBUFFER, x), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, y, 0), m = e.createBuffer(), e.bindBuffer(e.ARRAY_BUFFER, m), e.bufferData(e.ARRAY_BUFFER, new Float32Array([0]), e.STATIC_DRAW), B = e.getProgramParameter(v, e.LINK_STATUS), B && (e.useProgram(v), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, b), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, R), e.uniform1i(e.getUniformLocation(v, "uF"), 0), e.uniform1i(e.getUniformLocation(v, "uB"), 1), u = e.getAttribLocation(v, "aId"), T = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_ENABLED), E = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING), p = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_SIZE), h = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_TYPE), C = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_NORMALIZED), f = e.getVertexAttrib(u, e.VERTEX_ATTRIB_ARRAY_STRIDE), w = e.getVertexAttribOffset(u, e.VERTEX_ATTRIB_ARRAY_POINTER), e.enableVertexAttribArray(u), e.vertexAttribPointer(u, 1, e.FLOAT, !1, 0, 0), e.viewport(0, 0, 1, 1), e.disable(e.BLEND), e.disable(e.DEPTH_TEST), e.disable(e.SCISSOR_TEST), e.drawArrays(e.POINTS, 0, 1), e.readPixels(0, 0, 1, 1, e.RGBA, e.UNSIGNED_BYTE, _), B = Math.abs(_[0] - 51) <= 2 && Math.abs(_[1] - 51) <= 2 && Math.abs(_[2] - 38) <= 2);
     } finally {
-      d >= 0 && (x && (e.bindBuffer(e.ARRAY_BUFFER, x), e.vertexAttribPointer(
-        d,
-        h,
-        U,
-        D,
+      u >= 0 && (E && (e.bindBuffer(e.ARRAY_BUFFER, E), e.vertexAttribPointer(
+        u,
         p,
-        R
-      )), b ? e.enableVertexAttribArray(d) : e.disableVertexAttribArray(d)), v && e.deleteFramebuffer(v), f && e.deleteTexture(f), w && e.deleteTexture(w), B && e.deleteTexture(B), g && e.deleteBuffer(g), m && e.deleteProgram(m), e.bindFramebuffer(e.FRAMEBUFFER, c), e.bindBuffer(e.ARRAY_BUFFER, l), e.useProgram(o), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, u), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, _), e.activeTexture(i), y && e.enable(e.BLEND), E && e.enable(e.DEPTH_TEST), I && e.enable(e.SCISSOR_TEST), e.viewport(r[0], r[1], r[2], r[3]);
+        h,
+        C,
+        f,
+        w
+      )), T ? e.enableVertexAttribArray(u) : e.disableVertexAttribArray(u)), x && e.deleteFramebuffer(x), y && e.deleteTexture(y), b && e.deleteTexture(b), R && e.deleteTexture(R), m && e.deleteBuffer(m), v && e.deleteProgram(v), e.bindFramebuffer(e.FRAMEBUFFER, d), e.bindBuffer(e.ARRAY_BUFFER, l), e.useProgram(o), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, c), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, g), e.activeTexture(i), U && e.enable(e.BLEND), P && e.enable(e.DEPTH_TEST), A && e.enable(e.SCISSOR_TEST), e.viewport(r[0], r[1], r[2], r[3]);
     }
-    if (!S)
+    if (!B)
       throw new Error(
-        `NeutrinoParticles (js-v1.1): WebGL1 vertex texture fetch smoke test failed (got ${T[0]},${T[1]},${T[2]}); WebGL2 or WebGL1 with working vertex float textures is required.`
+        `NeutrinoParticles (js-v1.1): WebGL1 vertex texture fetch smoke test failed (got ${_[0]},${_[1]},${_[2]}); WebGL2 or WebGL1 with working vertex float textures is required.`
       );
   }
   _initShader() {
@@ -1529,7 +1570,7 @@ void main() { gl_FragColor = vC; }
     if (this._shaderProgram = e.createProgram(), e.attachShader(this._shaderProgram, r), e.attachShader(this._shaderProgram, o), e.linkProgram(this._shaderProgram), !e.getProgramParameter(this._shaderProgram, e.LINK_STATUS))
       throw new Error("Shader link error: " + e.getProgramInfoLog(this._shaderProgram));
     e.deleteShader(r), e.deleteShader(o), this._uDataTexture = e.getUniformLocation(this._shaderProgram, "uDataTexture"), this._uCameraRight = e.getUniformLocation(this._shaderProgram, "uCameraRight"), this._uCameraUp = e.getUniformLocation(this._shaderProgram, "uCameraUp"), this._uCameraDir = e.getUniformLocation(this._shaderProgram, "uCameraDir"), this._uViewProjMatrix = e.getUniformLocation(this._shaderProgram, "uViewProjMatrix"), this._uModelMatrix = e.getUniformLocation(this._shaderProgram, "uModelMatrix"), this._uViewportAspect = e.getUniformLocation(this._shaderProgram, "uViewportAspect"), this._uWorldAlpha = e.getUniformLocation(this._shaderProgram, "uWorldAlpha"), this._isWebGL1 ? (this._uMetaTexture = e.getUniformLocation(this._shaderProgram, "uMetaTexture"), this._uDataTexSize = e.getUniformLocation(this._shaderProgram, "uDataTexSize"), this._aIdLocation = e.getAttribLocation(this._shaderProgram, "aId")) : this._uDataTextureWidth = e.getUniformLocation(this._shaderProgram, "uDataTextureWidth"), this._uTextures = [], this._uTexRemaps = [];
-    for (let l = 0; l < A.MAX_BATCH_TEXTURES; l++)
+    for (let l = 0; l < S.MAX_BATCH_TEXTURES; l++)
       this._uTextures.push(e.getUniformLocation(this._shaderProgram, `uTextures[${l}]`)), this._uTexRemaps.push(e.getUniformLocation(this._shaderProgram, `uTexRemaps[${l}]`));
   }
   _compileShader(e, t) {
@@ -1541,8 +1582,8 @@ void main() { gl_FragColor = vC; }
     return r;
   }
 };
-n(A, "MAX_BATCH_TEXTURES", 8);
-let NeutrinoContext = A;
+n(S, "MAX_BATCH_TEXTURES", 8);
+let NeutrinoContext = S;
 class GamePlugin extends Phaser.Plugins.BasePlugin {
   constructor() {
     super(...arguments);
@@ -1610,14 +1651,14 @@ return new NeutrinoEffect(ctx);
       const a = this.effectModel.textures[t], r = this.gamePlugin.texturesBasePath + a, o = noext(r);
       let l = this._findFrameInAtlases(s, a);
       if (l || (l = this._findFrameInAtlases(s, noext(a))), !l && this.scene.sys.textures.exists(o)) {
-        const c = this.scene.sys.textures.get(o);
-        l = c.get(c.firstFrame);
+        const d = this.scene.sys.textures.get(o);
+        l = d.get(d.firstFrame);
       }
       l ? this._onTextureLoaded(t, l) : (this.scene.load.once(
         "filecomplete-image-" + o,
-        /* @__PURE__ */ ((c, i) => () => {
-          const u = this.scene.sys.textures.get(i);
-          this._onTextureLoaded(c, u.get(u.firstFrame));
+        /* @__PURE__ */ ((d, i) => () => {
+          const c = this.scene.sys.textures.get(i);
+          this._onTextureLoaded(d, c.get(c.firstFrame));
         })(t, o)
       ), this.scene.load.image(o, r));
     }
@@ -1660,14 +1701,14 @@ return new NeutrinoEffect(ctx);
 }
 class NeutrinoFile extends Phaser.Loader.File {
   constructor(t, a) {
-    const { key: r, url: o, options: l, xhrSettings: c } = a;
+    const { key: r, url: o, options: l, xhrSettings: d } = a;
     super(t, {
       type: "binary",
       extension: "js",
       responseType: "text",
       key: r,
       url: o,
-      xhrSettings: c
+      xhrSettings: d
     });
     n(this, "_options");
     this.cache = t.cacheManager.binary, this._options = l;
@@ -1683,9 +1724,7 @@ const RING_BUFFER_SIZE$1 = 3;
 class DataTextureManager {
   /**
    * @param gl - WebGL2 context (from the host renderer)
-   * @param data - Uint32Array from the runtime. A Float32Array view over the
-   *   same buffer is uploaded as RGBA32F — bit patterns (incl. NaN/Inf) pass
-   *   through unchanged.
+   * @param data - Uint32Array from the runtime, uploaded as-is as RGBA32UI.
    * @param textureWidth - from runtime (system.dataTextureWidth)
    * @param textureHeight - from runtime (system.dataTextureHeight)
    */
@@ -1693,7 +1732,7 @@ class DataTextureManager {
     n(this, "textureWidth");
     n(this, "textureHeight");
     n(this, "_gl");
-    n(this, "_floatView");
+    n(this, "_data");
     n(this, "_textures", []);
     n(this, "_currentIndex", 0);
     const o = e.getParameter(e.MAX_TEXTURE_SIZE);
@@ -1701,20 +1740,20 @@ class DataTextureManager {
       throw new Error(
         `NeutrinoParticles: data texture ${a}x${r} exceeds GL MAX_TEXTURE_SIZE (${o}). Reduce effect particle capacity.`
       );
-    this._gl = e, this.textureWidth = a, this.textureHeight = r, this._floatView = new Float32Array(t.buffer, t.byteOffset, t.length);
+    this._gl = e, this.textureWidth = a, this.textureHeight = r, this._data = t;
     for (let l = 0; l < RING_BUFFER_SIZE$1; l++) {
-      const c = e.createTexture();
-      e.bindTexture(e.TEXTURE_2D, c), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texImage2D(
+      const d = e.createTexture();
+      e.bindTexture(e.TEXTURE_2D, d), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texImage2D(
         e.TEXTURE_2D,
         0,
-        e.RGBA32F,
+        e.RGBA32UI,
         a,
         r,
         0,
-        e.RGBA,
-        e.FLOAT,
+        e.RGBA_INTEGER,
+        e.UNSIGNED_INT,
         null
-      ), this._textures.push(c);
+      ), this._textures.push(d);
     }
     e.bindTexture(e.TEXTURE_2D, null);
   }
@@ -1731,9 +1770,9 @@ class DataTextureManager {
       0,
       this.textureWidth,
       this.textureHeight,
-      t.RGBA,
-      t.FLOAT,
-      this._floatView
+      t.RGBA_INTEGER,
+      t.UNSIGNED_INT,
+      this._data
     );
   }
   advance() {
@@ -1791,10 +1830,10 @@ class DataTextureManagerGL1 {
     this._gl = e, this.textureWidth = a, this.textureHeight = r, this._floatView = new Float32Array(t.buffer, t.byteOffset, t.length), this.meta = new MetaTextureManager(a, r);
     const l = e.getParameter(e.ACTIVE_TEXTURE);
     e.activeTexture(e.TEXTURE0);
-    const c = e.getParameter(e.TEXTURE_BINDING_2D);
+    const d = e.getParameter(e.TEXTURE_BINDING_2D);
     for (let i = 0; i < RING_BUFFER_SIZE; i++)
       this._dataTextures.push(this._createTexture(e.FLOAT)), this._metaTextures.push(this._createTexture(e.UNSIGNED_BYTE));
-    e.bindTexture(e.TEXTURE_2D, c), e.activeTexture(l);
+    e.bindTexture(e.TEXTURE_2D, d), e.activeTexture(l);
   }
   get currentDataTexture() {
     return this._dataTextures[this._currentIndex];
@@ -1810,7 +1849,7 @@ class DataTextureManagerGL1 {
   upload(e, t, a) {
     const r = this._gl, o = this.textureWidth, l = Math.min(this.textureHeight, Math.ceil(e * 4 / o));
     if (l === 0) return;
-    const c = l * o * 4;
+    const d = l * o * 4;
     r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL, !1), r.pixelStorei(r.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), r.pixelStorei(r.UNPACK_ALIGNMENT, 4), r.activeTexture(r.TEXTURE0 + t), r.bindTexture(r.TEXTURE_2D, this.currentDataTexture), r.texSubImage2D(
       r.TEXTURE_2D,
       0,
@@ -1820,7 +1859,7 @@ class DataTextureManagerGL1 {
       l,
       r.RGBA,
       r.FLOAT,
-      this._floatView.subarray(0, c)
+      this._floatView.subarray(0, d)
     ), r.activeTexture(r.TEXTURE0 + a), r.bindTexture(r.TEXTURE_2D, this.currentMetaTexture), r.texSubImage2D(
       r.TEXTURE_2D,
       0,
@@ -1830,7 +1869,7 @@ class DataTextureManagerGL1 {
       l,
       r.RGBA,
       r.UNSIGNED_BYTE,
-      this.meta.bytes.subarray(0, c)
+      this.meta.bytes.subarray(0, d)
     );
   }
   advance() {
@@ -1881,82 +1920,87 @@ class NeutrinoRenderer {
     n(this, "_texSlotMap", /* @__PURE__ */ new Map());
     n(this, "_batchPool");
     n(this, "_batchCount", 0);
+    n(this, "_samplerUnitsProgram", null);
     this._batchPool = [];
     for (let e = 0; e < MAX_BATCHES; e++)
       this._batchPool.push(new DrawBatch());
   }
-  render(e, t, a, r, o, l, c) {
+  render(e, t, a, r, o, l, d) {
     if (l === 0) return;
-    const i = e.gl, u = e.isWebGL1, _ = e.maxBatchTextures, y = c.renderStyles, E = c.materials, I = u ? t.meta : null;
-    I && I.build(r, l), this._batchCount = 0;
-    const m = this._texSlotMap;
+    const i = e.gl, c = e.isWebGL1, g = c ? PARTICLE_TEXTURE_START_UNIT_GL1 : PARTICLE_TEXTURE_START_UNIT, U = e.maxBatchTextures, P = d.renderStyles, A = d.materials, v = c ? t.meta : null;
+    v && v.build(r, l), this._batchCount = 0;
+    const b = this._texSlotMap;
     for (; this._batchPool.length < o.length; )
       this._batchPool.push(new DrawBatch());
-    let w = 0;
-    for (; w < o.length; ) {
-      const f = this._batchPool[this._batchCount];
-      f.reset(), f.blendMode = this._resolveBlend(o[w].blendMode, E), f.startParticle = o[w].startParticleIndex, m.clear();
-      let v = w;
-      for (; v < o.length && this._resolveBlend(o[v].blendMode, E) === f.blendMode; ) {
-        const g = y[o[v].renderStyleIndex].textureIndices[0];
-        if (!m.has(g)) {
-          if (m.size >= _) break;
-          const x = m.size;
-          m.set(g, x), f.glTextures[x] = c.glTextures[g] || null, f.remaps[x] = c.remaps[g] || null, f.numTextures = x + 1;
+    let R = 0;
+    for (; R < o.length; ) {
+      const x = this._batchPool[this._batchCount];
+      x.reset(), x.blendMode = this._resolveBlend(o[R].blendMode, A), x.startParticle = o[R].startParticleIndex, b.clear();
+      let m = R;
+      for (; m < o.length && this._resolveBlend(o[m].blendMode, A) === x.blendMode; ) {
+        const u = P[o[m].renderStyleIndex].textureIndices[0];
+        if (!b.has(u)) {
+          if (b.size >= U) break;
+          const p = b.size;
+          b.set(u, p), x.glTextures[p] = d.glTextures[u] || null, x.remaps[p] = d.remaps[u] || null, x.numTextures = p + 1;
         }
-        const d = m.get(g), b = o[v];
-        if (I)
-          I.patchSlot(b.startParticleIndex, b.numParticles, d);
-        else if (d !== 0)
-          for (let x = 0; x < b.numParticles; x++) {
-            const h = (b.startParticleIndex + x) * BYTES_PER_PARTICLE, U = a.getUint32(h, !0);
-            a.setUint32(h, U & 4294967040 | d, !0);
+        const T = b.get(u), E = o[m];
+        if (v)
+          v.patchSlot(E.startParticleIndex, E.numParticles, T);
+        else if (T !== 0)
+          for (let p = 0; p < E.numParticles; p++) {
+            const h = (E.startParticleIndex + p) * BYTES_PER_PARTICLE, f = a.getUint32(h, !0);
+            a.setUint32(h, f & 4294967040 | T, !0);
           }
-        f.numParticles += b.numParticles, v++;
+        x.numParticles += E.numParticles, m++;
       }
-      this._batchCount++, w = v;
+      this._batchCount++, R = m;
     }
-    const B = i.isEnabled(i.SCISSOR_TEST);
+    const y = i.isEnabled(i.SCISSOR_TEST);
     try {
-      if (i.disable(i.DEPTH_TEST), i.disable(i.STENCIL_TEST), i.disable(i.SCISSOR_TEST), i.disable(i.CULL_FACE), i.depthMask(!1), i.colorMask(!0, !0, !0, !0), i.useProgram(e.shaderProgram), u) {
-        const p = t;
-        p.upload(l, DATA_TEXTURE_UNIT, META_TEXTURE_UNIT), i.uniform1i(e.uDataTexture, DATA_TEXTURE_UNIT), i.uniform1i(e.uMetaTexture, META_TEXTURE_UNIT), i.uniform2f(e.uDataTexSize, p.textureWidth, p.textureHeight);
+      if (i.disable(i.DEPTH_TEST), i.disable(i.STENCIL_TEST), i.disable(i.SCISSOR_TEST), i.disable(i.CULL_FACE), i.depthMask(!1), i.colorMask(!0, !0, !0, !0), i.useProgram(e.shaderProgram), this._samplerUnitsProgram !== e.shaderProgram) {
+        const f = c ? e.maxBatchTextures : NeutrinoContext.MAX_BATCH_TEXTURES;
+        for (let w = 0; w < f; w++)
+          i.uniform1i(e.uTextures[w], g + w);
+        this._samplerUnitsProgram = e.shaderProgram;
+      }
+      if (c) {
+        const f = t;
+        f.upload(l, DATA_TEXTURE_UNIT, META_TEXTURE_UNIT), i.uniform1i(e.uDataTexture, DATA_TEXTURE_UNIT), i.uniform1i(e.uMetaTexture, META_TEXTURE_UNIT), i.uniform2f(e.uDataTexSize, f.textureWidth, f.textureHeight);
       } else {
-        const p = t;
-        p.uploadAndBind(DATA_TEXTURE_UNIT), i.uniform1i(e.uDataTexture, DATA_TEXTURE_UNIT), i.uniform1i(e.uDataTextureWidth, p.textureWidth);
+        const f = t;
+        f.uploadAndBind(DATA_TEXTURE_UNIT), i.uniform1i(e.uDataTexture, DATA_TEXTURE_UNIT), i.uniform1i(e.uDataTextureWidth, f.textureWidth);
       }
       i.uniform3f(e.uCameraRight, 1, 0, 0), i.uniform3f(e.uCameraUp, 0, -1, 0), i.uniform3f(e.uCameraDir, 0, 0, -1);
-      const f = c.viewportWidth, v = c.viewportHeight, g = c.zoom || 1, d = this._orthoMatrix;
-      if (d.fill(0), d[0] = 2 / f * g, d[5] = -2 / v * g, d[10] = 0, d[15] = 1, d[12] = -1 - 2 / f * g * c.scrollX, d[13] = 1 + 2 / v * g * c.scrollY, c.projection) {
-        const p = this._projFrame;
-        p.x = 0, p.y = 0, p.width = f, p.height = v, c.projection.setScreenFrame(p), c.projection.writeMatrix(this._perspMatrix), this._mulMatrix(this._vpMatrix, d, this._perspMatrix), i.uniformMatrix4fv(e.uViewProjMatrix, !1, this._vpMatrix);
+      const x = d.viewportWidth, m = d.viewportHeight, u = d.zoom || 1, T = this._orthoMatrix;
+      if (T.fill(0), T[0] = 2 / x * u, T[5] = -2 / m * u, T[10] = 0, T[15] = 1, T[12] = -1 - 2 / x * u * d.scrollX, T[13] = 1 + 2 / m * u * d.scrollY, d.projection) {
+        const f = this._projFrame;
+        f.x = 0, f.y = 0, f.width = x, f.height = m, d.projection.setScreenFrame(f), d.projection.writeMatrix(this._perspMatrix), this._mulMatrix(this._vpMatrix, T, this._perspMatrix), i.uniformMatrix4fv(e.uViewProjMatrix, !1, this._vpMatrix);
       } else
-        i.uniformMatrix4fv(e.uViewProjMatrix, !1, d);
-      const b = v > 0 ? f / v : 1;
-      e.uViewportAspect && i.uniform1f(e.uViewportAspect, b), e.uWorldAlpha && i.uniform1f(e.uWorldAlpha, c.worldAlpha);
-      const x = c.model, h = this._modelMatrix;
-      h[0] = x.a, h[1] = x.b, h[2] = 0, h[3] = 0, h[4] = x.c, h[5] = x.d, h[6] = 0, h[7] = 0, h[8] = 0, h[9] = 0, h[10] = 1, h[11] = 0, h[12] = x.tx, h[13] = x.ty, h[14] = 0, h[15] = 1, i.uniformMatrix4fv(e.uModelMatrix, !1, h), u ? (e.unbindVao(), i.bindBuffer(i.ARRAY_BUFFER, e.aIdBuffer), i.enableVertexAttribArray(e.aIdLocation), i.vertexAttribPointer(e.aIdLocation, 1, i.FLOAT, !1, 0, 0), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, e.indexBuffer)) : i.bindVertexArray(e.vao);
-      const U = u ? PARTICLE_TEXTURE_START_UNIT_GL1 : PARTICLE_TEXTURE_START_UNIT;
-      i.enable(i.BLEND);
-      for (let p = 0; p < this._batchCount; p++) {
-        const R = this._batchPool[p];
-        this._applyBlendMode(i, R.blendMode);
-        for (let T = 0; T < R.numTextures; T++) {
-          const C = U + T;
-          i.activeTexture(i.TEXTURE0 + C), i.bindTexture(i.TEXTURE_2D, R.glTextures[T]), i.uniform1i(e.uTextures[T], C);
-          const P = R.remaps[T];
-          P ? i.uniform4f(e.uTexRemaps[T], P.x, P.y, P.width, P.height) : i.uniform4f(e.uTexRemaps[T], 0, 0, 1, 1);
+        i.uniformMatrix4fv(e.uViewProjMatrix, !1, T);
+      const E = m > 0 ? x / m : 1;
+      e.uViewportAspect && i.uniform1f(e.uViewportAspect, E), e.uWorldAlpha && i.uniform1f(e.uWorldAlpha, d.worldAlpha);
+      const p = d.model, h = this._modelMatrix;
+      h[0] = p.a, h[1] = p.b, h[2] = 0, h[3] = 0, h[4] = p.c, h[5] = p.d, h[6] = 0, h[7] = 0, h[8] = 0, h[9] = 0, h[10] = 1, h[11] = 0, h[12] = p.tx, h[13] = p.ty, h[14] = 0, h[15] = 1, i.uniformMatrix4fv(e.uModelMatrix, !1, h), c ? (e.unbindVao(), i.bindBuffer(i.ARRAY_BUFFER, e.aIdBuffer), i.enableVertexAttribArray(e.aIdLocation), i.vertexAttribPointer(e.aIdLocation, 1, i.FLOAT, !1, 0, 0), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, e.indexBuffer)) : i.bindVertexArray(e.vao), i.enable(i.BLEND);
+      for (let f = 0; f < this._batchCount; f++) {
+        const w = this._batchPool[f];
+        this._applyBlendMode(i, w.blendMode);
+        for (let _ = 0; _ < w.numTextures; _++) {
+          const D = g + _;
+          i.activeTexture(i.TEXTURE0 + D), i.bindTexture(i.TEXTURE_2D, w.glTextures[_]);
+          const I = w.remaps[_];
+          I ? i.uniform4f(e.uTexRemaps[_], I.x, I.y, I.width, I.height) : i.uniform4f(e.uTexRemaps[_], 0, 0, 1, 1);
         }
-        const D = R.startParticle * 6, S = R.numParticles * 6;
+        const C = w.startParticle * 6, B = w.numParticles * 6;
         i.drawElements(
           i.TRIANGLES,
-          S,
+          B,
           e.indexType,
-          D * (e.indexType === i.UNSIGNED_INT ? 4 : 2)
+          C * (e.indexType === i.UNSIGNED_INT ? 4 : 2)
         );
       }
     } finally {
-      u ? (i.disableVertexAttribArray(e.aIdLocation), i.bindBuffer(i.ARRAY_BUFFER, null), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, null)) : i.bindVertexArray(null), i.useProgram(null), B && i.enable(i.SCISSOR_TEST);
+      c ? (i.disableVertexAttribArray(e.aIdLocation), i.bindBuffer(i.ARRAY_BUFFER, null), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, null)) : i.bindVertexArray(null), i.useProgram(null), i.activeTexture(i.TEXTURE0 + DATA_TEXTURE_UNIT), i.bindTexture(i.TEXTURE_2D, null), y && i.enable(i.SCISSOR_TEST);
     }
   }
   // Resolve a renderStyle's compacted material INDEX to the real blend enum (0=Normal/
@@ -1968,8 +2012,8 @@ class NeutrinoRenderer {
   // Column-major 4x4 multiply: out = a * b. Preallocated outputs only.
   _mulMatrix(e, t, a) {
     for (let r = 0; r < 16; r += 4) {
-      const o = a[r], l = a[r + 1], c = a[r + 2], i = a[r + 3];
-      e[r] = t[0] * o + t[4] * l + t[8] * c + t[12] * i, e[r + 1] = t[1] * o + t[5] * l + t[9] * c + t[13] * i, e[r + 2] = t[2] * o + t[6] * l + t[10] * c + t[14] * i, e[r + 3] = t[3] * o + t[7] * l + t[11] * c + t[15] * i;
+      const o = a[r], l = a[r + 1], d = a[r + 2], i = a[r + 3];
+      e[r] = t[0] * o + t[4] * l + t[8] * d + t[12] * i, e[r + 1] = t[1] * o + t[5] * l + t[9] * d + t[13] * i, e[r + 2] = t[2] * o + t[6] * l + t[10] * d + t[14] * i, e[r + 3] = t[3] * o + t[7] * l + t[11] * d + t[15] * i;
     }
   }
   _resolveBlend(e, t) {
@@ -2060,24 +2104,24 @@ class Effect extends Phaser.GameObjects.GameObject {
     this._checkUnpauseOnUpdateRender();
     const o = this.gamePlugin.ctx, l = this._dataTextureManager;
     this.effect.construct([0, 0, -1]);
-    const c = this.effect.renderInstructions, i = c._totalParticles;
+    const d = this.effect.renderInstructions, i = d._totalParticles;
     if (i === 0) return;
     t.flush();
-    const u = this.effectModel.effectModel.textures.length, _ = this._glTexturesScratch;
-    _.length = u;
-    for (let E = 0; E < u; ++E)
-      _[E] = this.effectModel.glTexture(E);
-    const y = this._worldScale;
+    const c = this.effectModel.effectModel.textures.length, g = this._glTexturesScratch;
+    g.length = c;
+    for (let P = 0; P < c; ++P)
+      g[P] = this.effectModel.glTexture(P);
+    const U = this._worldScale;
     try {
       sharedRenderer.render(
         o,
         l,
         this.effect.particleDataView,
         this.effect.particleDataUint32,
-        c,
+        d,
         i,
         {
-          model: { a: y, b: 0, c: 0, d: y, tx: 0, ty: 0 },
+          model: { a: U, b: 0, c: 0, d: U, tx: 0, ty: 0 },
           viewportWidth: t.width,
           viewportHeight: t.height,
           scrollX: r.scrollX * this.scrollFactorX,
@@ -2085,7 +2129,7 @@ class Effect extends Phaser.GameObjects.GameObject {
           zoom: r.zoom,
           worldAlpha: this.alpha,
           projection: this.projection,
-          glTextures: _,
+          glTextures: g,
           remaps: this.effectModel.texturesRemap,
           renderStyles: this.effect.model.renderStyles,
           materials: this.effect.model.materials
@@ -2156,8 +2200,8 @@ class Effect extends Phaser.GameObjects.GameObject {
   _updateWorldTransform() {
     const t = (o, l) => {
       if (!o) return;
-      const c = this._tempMatrix2;
-      c.applyITRS(o.x, o.y, o.rotation, o.scaleX, o.scaleY), c.multiply(l.matrix, l.matrix), l.angle += o.angle, l.scale *= (o.scaleX + o.scaleY) * 0.5, t(o.parentContainer, l);
+      const d = this._tempMatrix2;
+      d.applyITRS(o.x, o.y, o.rotation, o.scaleX, o.scaleY), d.multiply(l.matrix, l.matrix), l.angle += o.angle, l.scale *= (o.scaleX + o.scaleY) * 0.5, t(o.parentContainer, l);
     }, a = {
       matrix: this._tempMatrix1.loadIdentity(),
       angle: this.angle,