@neutrinoparticles/js-v1.1-pixi8 1.0.0

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

@@ -0,0 +1,2211 @@
+var V = Object.defineProperty;
+var L = (l, e, t) => e in l ? V(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
+var i = (l, e, t) => L(l, typeof e != "symbol" ? e + "" : e, t);
+import { ExtensionType, EventEmitter, Cache, Assets, LoaderParserPriority, DOMAdapter, Rectangle, Bounds, ViewContainer, Point, extensions } from "pixi.js";
+import * as Neutrino from "@neutrinoparticles/js-v1.1";
+const vertexShaderSource = `#version 300 es
+precision highp float;
+
+uniform sampler2D uDataTexture;
+uniform int uDataTextureWidth;
+uniform vec3 uCameraRight;
+uniform vec3 uCameraUp;
+uniform vec3 uCameraDir;
+uniform mat4 uViewProjMatrix;
+uniform mat4 uModelMatrix;
+uniform float uViewportAspect; // viewport width / height — strip-only
+uniform vec4 uTexRemaps[8];
+
+const vec2 ORIGIN_MUL[4] = vec2[4](
+    vec2(-1.0, 0.0),
+    vec2(-1.0, -1.0),
+    vec2(0.0, -1.0),
+    vec2(0.0, 0.0)
+);
+
+const vec2 INV_ORIGIN_MUL[4] = vec2[4](
+    vec2(0.0, 1.0),
+    vec2(0.0, 0.0),
+    vec2(1.0, 0.0),
+    vec2(1.0, 1.0)
+);
+
+const vec2 TEX_COORD[4] = vec2[4](
+    vec2(0.0, 0.0),
+    vec2(0.0, 1.0),
+    vec2(1.0, 1.0),
+    vec2(1.0, 0.0)
+);
+
+out vec2 vTexCoord;
+out vec4 vColor;
+flat out int vBatchTextureIndex;
+// Atlas slot rect (origin.xy, extent.zw) used by the strip path to wrap
+// U inside its own slot at the fragment stage. Quad path keeps the old
+// vertex-side remap so quad sampling stays bit-perfect with prior IBCT
+// snapshots. The flag distinguishes the two paths in the fragment.
+flat out vec4 vAtlasRemap;
+flat out int vStripPath;
+
+vec4 fetchTexel(int globalTexelIndex) {
+    int x = globalTexelIndex % uDataTextureWidth;
+    int y = globalTexelIndex / uDataTextureWidth;
+    return texelFetch(uDataTexture, ivec2(x, y), 0);
+}
+
+// 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).
+vec2 stripOrtho(vec2 v) {
+    return vec2(-v.y, v.x);
+}
+
+void main() {
+    int vertexIndex = gl_VertexID % 4;
+    int particleIndex = gl_VertexID / 4;
+
+    int baseTexel = particleIndex * 4;
+
+    vec4 t0 = fetchTexel(baseTexel + 0);
+    vec4 t1 = fetchTexel(baseTexel + 1);
+    vec4 t2 = fetchTexel(baseTexel + 2);
+    vec4 t3 = fetchTexel(baseTexel + 3);
+
+    // Texel 0: flags (uint32 bits in float), posX, posY, posZ
+    uint flags = floatBitsToUint(t0.r);
+    vec3 position = t0.gba;
+    uint rotationType = (flags >> 8u) & 3u;
+    uint ctorType = (flags >> 10u) & 3u;
+    int batchTexIdx = int(flags & 0xFFu);
+    vBatchTextureIndex = batchTexIdx;
+
+    // ─── Strip path ───────────────────────────────────────────────────────
+    // ctorType: 0 = Quad, 1 = StripCur, 2 = StripNex.
+    // Strip meta records come in pairs: meta_cur describes the "p1" end and
+    // meta_nex describes the "p2" end of one segment. Sibling meta is at the
+    // adjacent texel base (cur + 4 = nex; nex - 4 = cur). p0 (= prev pair's
+    // p1) and p3 (= next pair's p2) are reached via neighborIdxP0 / P3 stored
+    // as uint32 in t3.g / t3.b. Boundary particles use self-reference: when
+    // p0==p1 the shader sets dir01=dir12 and the knee degenerates.
+    //
+    // rotationType handling in the strip path:
+    //   0 (Faced): screen-space ortho to dir12 — equivalent to camera-faced
+    //              billboard normal in a 2D camera setup.
+    //   1 (Free):  the quaternion stored in texel 2 nominally encodes a 3D
+    //              orientation. The PIXI7 renderer has no true 3D camera
+    //              (uViewProjMatrix is ortho or the v1.0-parity perspective),
+    //              so the quat is read but its 3D y-axis is projected to screen
+    //              and used as the section normal. When the projection
+    //              degenerates (looking along the y-axis) we fall back to
+    //              the screen-space ortho. Real 3D free-rotation requires a
+    //              future 3D pipeline; this is documented as a deviation in
+    //              docs/tdd/TDD_80-js-v1.1-constructor-strip.md.
+    if (ctorType >= 1u) {
+        bool isCur = (ctorType == 1u);
+        int siblingTexel = isCur ? (baseTexel + 4) : (baseTexel - 4);
+        vec4 ts0 = fetchTexel(siblingTexel + 0);
+        vec4 ts1 = fetchTexel(siblingTexel + 1);
+        vec4 ts3 = fetchTexel(siblingTexel + 3);
+
+        // p1 always = position of the meta_cur end; p2 = meta_nex end.
+        vec3 p1 = isCur ? t0.gba : ts0.gba;
+        vec3 p2 = isCur ? ts0.gba : t0.gba;
+
+        float halfSize1 = isCur ? t1.r : ts1.r;
+        float halfSize2 = isCur ? ts1.r : t1.r;
+        float texU1 = isCur ? t1.g : ts1.g;
+        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);
+        vec4 color1 = vec4(
+            float(packedColorCur & 0xFFu) / 255.0,
+            float((packedColorCur >> 8u) & 0xFFu) / 255.0,
+            float((packedColorCur >> 16u) & 0xFFu) / 255.0,
+            float((packedColorCur >> 24u) & 0xFFu) / 255.0);
+        vec4 color2 = vec4(
+            float(packedColorNex & 0xFFu) / 255.0,
+            float((packedColorNex >> 8u) & 0xFFu) / 255.0,
+            float((packedColorNex >> 16u) & 0xFFu) / 255.0,
+            float((packedColorNex >> 24u) & 0xFFu) / 255.0);
+
+        // neighborIdxP0 / neighborIdxP3 are stored on every meta of a pair
+        // (both meta_cur and meta_nex hold the same pair of indices), so we
+        // can read them from either self or sibling.
+        //
+        // Runtime convention (\`_constructStripParticles\` in system.js):
+        //   neighborIdxP0 = global texel index of the position of W
+        //                   (= lnkdPrev(X)); boundary sentinel = curTexIdx
+        //                   (the pair's meta_cur texel index).
+        //   neighborIdxP3 = global texel index of the position of Z
+        //                   (= lnkdNext(Y)); boundary sentinel = curTexIdx.
+        // 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 selfPairCurTexel = uint(isCur ? baseTexel : siblingTexel) / 4u;
+
+        vec3 p0 = (neighborIdxP0 == selfPairCurTexel)
+            ? p1
+            : fetchTexel(int(neighborIdxP0) * 4 + 0).gba;
+        vec3 p3 = (neighborIdxP3 == selfPairCurTexel)
+            ? p2
+            : fetchTexel(int(neighborIdxP3) * 4 + 0).gba;
+
+        // Segment frame. Two completely separate frames depending on
+        // rotationType — MIRROR of preview3 DataTextureRenderer3 (the editor's
+        // own JS1.1 renderer) so all data-texture renderers stay identical:
+        //   Faced (rotationType 0/2): screen-space NDC frame around dir12.
+        //   Free  (rotationType 1):   FULL world-space 3D frame (make3DStrip);
+        //     the ribbon keeps its 3D orientation from the quat and Z collapses
+        //     naturally only at projection (front-planar is a camera artifact,
+        //     not a shader simplification). Mixing world-space section into a
+        //     screen-space miter distorts sharp bends and makes geometry track
+        //     the camera even with a static quat — Free stays camera-independent.
+        mat4 mvpMatrix = uViewProjMatrix * uModelMatrix;
+        bool isFreeRotation = (rotationType == 1u);
+
+        // Anchor projections — both branches use them for gl_Position.
+        vec4 sp1 = mvpMatrix * vec4(p1, 1.0);
+        vec4 sp2 = mvpMatrix * vec4(p2, 1.0);
+
+        // Near-plane guard (Faced only; the world-space Free frame is unaffected
+        // by the sign of w). Forces a discard outside the [-w,w] cube at the end.
+        bool nearPlaneClipped = (sp1.w < 1e-3) || (sp2.w < 1e-3);
+
+        // Aspect correction so the 2D Faced ortho gives visually-perpendicular
+        // dirs on non-square viewports (inverted before gl_Position).
+        vec2 aspectMul = vec2(1.0, 1.0 / max(uViewportAspect, 1e-6));
+
+        vec4 ts2 = fetchTexel(siblingTexel + 2);
+        vec4 q1 = isCur ? t2 : ts2;
+        vec4 q2 = isCur ? ts2 : t2;
+
+        // Frame outputs: Faced fills the 2D (k/b/IK), Free fills the 3D
+        // (worldK/B/IK); the vertex ladder picks the right one per gl_Position.
+        vec3 worldK1, worldB1, worldIK1, worldK2, worldB2, worldIK2;
+        vec2 k1, b1, IK1, k2, b2, IK2;
+        float Bmul1, Bmul2, kb1, kb2;
+        bool noKnee1, noKnee2;
+        float pathLen12; // len12 in the active frame's units (NDC for Faced, world for Free)
+
+        if (isFreeRotation) {
+            // World-space frame (mirror of GPU33 make3DStrip). Section normal
+            // n = quat z-axis (local Z ⟂ ribbon plane); ribbon lies in local XY
+            // (travel along local X, width along local Y). B = cross(dir12, n).
+            float xz1 = 2.0 * q1.x * q1.z;
+            float wy1 = 2.0 * q1.w * q1.y;
+            float yz1 = 2.0 * q1.y * q1.z;
+            float wx1 = 2.0 * q1.w * q1.x;
+            vec3 n1 = vec3(xz1 + wy1, yz1 - wx1, 1.0 - 2.0 * (q1.x * q1.x + q1.y * q1.y));
+            float xz2 = 2.0 * q2.x * q2.z;
+            float wy2 = 2.0 * q2.w * q2.y;
+            float yz2 = 2.0 * q2.y * q2.z;
+            float wx2 = 2.0 * q2.w * q2.x;
+            vec3 n2 = vec3(xz2 + wy2, yz2 - wx2, 1.0 - 2.0 * (q2.x * q2.x + q2.y * q2.y));
+
+            vec3 wp01 = p1 - p0;
+            vec3 wp12 = p2 - p1;
+            vec3 wp23 = p3 - p2;
+            float wlen01 = length(wp01);
+            float wlen12 = length(wp12);
+            float wlen23 = length(wp23);
+            vec3 wdir12 = (wlen12 > 1e-6) ? (wp12 / wlen12) : vec3(1.0, 0.0, 0.0);
+            vec3 wdir01 = (wlen01 > 1e-6) ? (wp01 / wlen01) : wdir12;
+            vec3 wdir23 = (wlen23 > 1e-6) ? (wp23 / wlen23) : wdir12;
+            noKnee1 = dot(wdir01, wdir12) > 0.999;
+            noKnee2 = dot(wdir12, wdir23) > 0.999;
+            pathLen12 = wlen12;
+
+            if (!noKnee1) {
+                vec3 B1raw = normalize(cross(wdir12, n1));
+                vec3 c1 = normalize(cross(wdir01, wdir12));
+                float Kmul1 = sign(dot(c1, n1));
+                vec3 K1 = Kmul1 * normalize(cross(wdir01 + wdir12, n1));
+                Bmul1 = sign(dot(B1raw, K1));
+                vec3 B1 = B1raw * Bmul1;
+                float ik1 = halfSize1 / max(dot(B1, K1), 1e-6);
+                if (dot(-wdir01, ik1 * -K1) > wlen01) ik1 = wlen01;
+                if (dot( wdir12, ik1 * -K1) > wlen12) ik1 = wlen12;
+                worldK1 = p1 + K1 * halfSize1;
+                worldB1 = p1 + B1 * halfSize1;
+                worldIK1 = p1 - K1 * ik1;
+                kb1 = distance(worldK1, worldB1);
+            } else {
+                Bmul1 = 1.0;
+                vec3 B1 = normalize(cross(wdir01 + wdir12, n1));
+                worldK1 = p1 + B1 * halfSize1;
+                worldB1 = worldK1;
+                worldIK1 = p1 - B1 * halfSize1;
+                kb1 = 0.0;
+            }
+
+            if (!noKnee2) {
+                vec3 B2raw = normalize(cross(wdir12, n2));
+                vec3 c2 = normalize(cross(wdir12, wdir23));
+                float Kmul2 = sign(dot(c2, n2));
+                vec3 K2 = Kmul2 * normalize(cross(wdir12 + wdir23, n2));
+                Bmul2 = sign(dot(B2raw, K2));
+                vec3 B2 = B2raw * Bmul2;
+                float ik2 = halfSize2 / max(dot(B2, K2), 1e-6);
+                if (dot(-wdir12, ik2 * -K2) > wlen12) ik2 = wlen12;
+                if (dot( wdir23, ik2 * -K2) > wlen23) ik2 = wlen23;
+                worldK2 = p2 + K2 * halfSize2;
+                worldB2 = p2 + B2 * halfSize2;
+                worldIK2 = p2 - K2 * ik2;
+                kb2 = distance(worldK2, worldB2);
+            } else {
+                Bmul2 = 1.0;
+                vec3 B2 = normalize(cross(wdir12 + wdir23, n2));
+                worldK2 = p2 + B2 * halfSize2;
+                worldB2 = worldK2;
+                worldIK2 = p2 - B2 * halfSize2;
+                kb2 = 0.0;
+            }
+        } else {
+            // Faced: screen-space NDC frame around dir12.
+            vec4 sp0 = mvpMatrix * vec4(p0, 1.0);
+            vec4 sp3 = mvpMatrix * vec4(p3, 1.0);
+            vec2 ndc1 = (sp1.xy / sp1.w) * aspectMul;
+            vec2 ndc2 = (sp2.xy / sp2.w) * aspectMul;
+            // Neighbor anchors behind the near plane produce garbage NDC after
+            // the perspective divide (possible only with Projection3D, where w
+            // varies); collapse them onto their segment anchor so the existing
+            // zero-length degeneracy path (dir01 = dir12 / dir23 = dir12)
+            // handles the knee instead of a poisoned miter. spU1/spU2 need no
+            // guard: uCameraUp has zero Z, so their w equals sp1.w / sp2.w.
+            vec2 ndc0 = (sp0.w < 1e-3) ? ndc1 : (sp0.xy / sp0.w) * aspectMul;
+            vec2 ndc3 = (sp3.w < 1e-3) ? ndc2 : (sp3.xy / sp3.w) * aspectMul;
+
+            vec2 d01 = ndc1 - ndc0;
+            vec2 d12 = ndc2 - ndc1;
+            vec2 d23 = ndc3 - ndc2;
+            float len01 = length(d01);
+            float len12 = length(d12);
+            float len23 = length(d23);
+            vec2 dir12 = (len12 > 1e-6) ? (d12 / len12) : vec2(1.0, 0.0);
+            vec2 dir01 = (len01 > 1e-6) ? (d01 / len01) : dir12;
+            vec2 dir23 = (len23 > 1e-6) ? (d23 / len23) : dir12;
+            noKnee1 = dot(dir01, dir12) > 0.999;
+            noKnee2 = dot(dir12, dir23) > 0.999;
+            pathLen12 = len12;
+
+            // Section magnitude: project camera_up*halfSize per anchor into NDC.
+            vec4 spU1 = mvpMatrix * vec4(p1 + uCameraUp * halfSize1, 1.0);
+            vec4 spU2 = mvpMatrix * vec4(p2 + uCameraUp * halfSize2, 1.0);
+            float ndcHalfSize1 = length((spU1.xy / spU1.w) * aspectMul - ndc1);
+            float ndcHalfSize2 = length((spU2.xy / spU2.w) * aspectMul - ndc2);
+
+            vec2 B = stripOrtho(dir12);
+            if (!noKnee1) {
+                float Kmul1 = -sign(dot(stripOrtho(dir01), dir12));
+                vec2 K1 = Kmul1 * normalize(stripOrtho(dir01 + dir12));
+                Bmul1 = sign(dot(B, K1));
+                vec2 B1 = B * Bmul1;
+                float ik1 = ndcHalfSize1 / max(dot(B1, K1), 1e-6);
+                if (dot(-dir01, ik1 * -K1) > len01) ik1 = len01;
+                if (dot(dir12, ik1 * -K1) > len12) ik1 = len12;
+                k1 = ndc1 + K1 * ndcHalfSize1;
+                b1 = ndc1 + B1 * ndcHalfSize1;
+                IK1 = ndc1 - K1 * ik1;
+                kb1 = distance(k1, b1);
+            } else {
+                vec2 B1 = normalize(stripOrtho(dir01 + dir12));
+                Bmul1 = 1.0;
+                k1 = ndc1 + B1 * ndcHalfSize1;
+                b1 = k1;
+                IK1 = ndc1 - B1 * ndcHalfSize1;
+                kb1 = 0.0;
+            }
+            if (!noKnee2) {
+                float Kmul2 = -sign(dot(stripOrtho(dir12), dir23));
+                vec2 K2 = Kmul2 * normalize(stripOrtho(dir12 + dir23));
+                Bmul2 = sign(dot(B, K2));
+                vec2 B2 = B * Bmul2;
+                float ik2 = ndcHalfSize2 / max(dot(B2, K2), 1e-6);
+                if (dot(-dir12, ik2 * -K2) > len12) ik2 = len12;
+                if (dot(dir23, ik2 * -K2) > len23) ik2 = len23;
+                k2 = ndc2 + K2 * ndcHalfSize2;
+                b2 = ndc2 + B2 * ndcHalfSize2;
+                IK2 = ndc2 - K2 * ik2;
+                kb2 = distance(k2, b2);
+            } else {
+                vec2 B2 = normalize(stripOrtho(dir12 + dir23));
+                Bmul2 = 1.0;
+                k2 = ndc2 + B2 * ndcHalfSize2;
+                b2 = k2;
+                IK2 = ndc2 - B2 * ndcHalfSize2;
+                kb2 = 0.0;
+            }
+        }
+
+        // V coords (mirror of preview3 / GPU33 make*Strip):
+        //   V at outer knee (k)  = (Bmul + 1) * 0.5
+        //   V at inner knee (IK) = 1 - V_outer ; bend (b) = outer
+        float Vtop1 = (Bmul1 + 1.0) * 0.5;
+        float Vbot1 = 1.0 - Vtop1;
+        float Vtop2 = (Bmul2 + 1.0) * 0.5;
+        float Vbot2 = 1.0 - Vtop2;
+
+        // Vertex layout per meta (4 vertices × IBO [0,1,2, 0,2,3] = 2 tris):
+        //
+        // Bmul1*Bmul2 ≥ 0 (knees same side):
+        //   meta_cur: v0=b1, v1=k1, v2=IK1, v3=b2
+        //     T1=(b1,k1,IK1) — knee at p1 ✓
+        //     T2=(b1,IK1,b2) — top half segment ✓
+        //   meta_nex: v0=b2, v1=IK1, v2=IK2, v3=k2
+        //     T1=(b2,IK1,IK2) — bottom half segment ✓
+        //     T2=(b2,IK2,k2) — knee at p2 ✓
+        //
+        // Bmul1*Bmul2 < 0 (knees opposite sides):
+        //   meta_cur: v0=b1, v1=k1, v2=IK1, v3=IK2
+        //     T1=(b1,k1,IK1) ✓
+        //     T2=(b1,IK1,IK2) — diagonal cross ✓
+        //   meta_nex: v0=IK2, v1=IK1, v2=b2, v3=k2
+        //     T1=(IK2,IK1,b2) — diagonal cross ✓
+        //     T2=(IK2,b2,k2) — knee at p2 ✓
+        //
+        // The shader picks v0..v3 based on (isCur, vertexIndex, sign(Bmul1*Bmul2)).
+        bool sameSide = (Bmul1 * Bmul2 >= 0.0);
+        // Distance for U interpolation along the bend point. Clamped to a
+        // small epsilon to avoid NaN on fully degenerate segments (p1≈p2 or
+        // 1-particle "strip" reached through self-references).
+        float dPath = max(sameSide ? (kb1 + pathLen12 + kb2) : (kb1 + pathLen12), 1e-6);
+        float dPathNex = max(sameSide ? dPath : (kb2 + pathLen12), 1e-6);
+
+        // Per-vertex colour follows the same kb / dPath ratio as texU.
+        // Knee corners (k1/IK1, k2/IK2) are anchored to their own particle;
+        // bend points (b1/b2) blend between color1 and color2 by the same
+        // fraction the U coord uses. Opposite-side bend uses the shorter
+        // denominator (kb*+len12) and IK on the far end is the other colour.
+        float bUcur = kb1 / dPath;
+        float bUnex = sameSide ? (kb2 / dPath) : (kb2 / dPathNex);
+        vec4 colorB1 = mix(color1, color2, bUcur);
+        vec4 colorB2 = mix(color2, color1, bUnex);
+
+        // vertPos holds the picked vertex in the 2D Faced frame (NDC);
+        // vertPos3D holds it in world space for Free. A single ladder over the
+        // IBO layout picks both, then gl_Position chooses by isFreeRotation.
+        vec2 vertPos;
+        vec3 vertPos3D = vec3(0.0);
+        vec2 vertUV;
+        vec4 vertColor;
+        if (isCur) {
+            // meta_cur vertices
+            if (vertexIndex == 0) {
+                vertPos = b1; vertPos3D = worldB1;
+                vertUV = vec2(mix(texU1, texU2, kb1 / dPath), Vtop1);
+                vertColor = colorB1;
+            } else if (vertexIndex == 1) {
+                vertPos = k1; vertPos3D = worldK1;
+                vertUV = vec2(texU1, Vtop1);
+                vertColor = color1;
+            } else if (vertexIndex == 2) {
+                vertPos = IK1; vertPos3D = worldIK1;
+                vertUV = vec2(texU1, Vbot1);
+                vertColor = color1;
+            } else {
+                // v3 = b2 (sameSide) or IK2 (different side)
+                if (sameSide) {
+                    vertPos = b2; vertPos3D = worldB2;
+                    vertUV = vec2(mix(texU2, texU1, kb2 / dPath), Vtop2);
+                    vertColor = colorB2;
+                } else {
+                    vertPos = IK2; vertPos3D = worldIK2;
+                    vertUV = vec2(texU2, Vbot2);
+                    vertColor = color2;
+                }
+            }
+            // noKnee fallback: collapse to k1/IK1 to produce degenerate segments.
+            if (noKnee1) {
+                if (vertexIndex == 0) { vertPos = k1; vertPos3D = worldK1; vertUV = vec2(texU1, Vtop1); vertColor = color1; }
+            }
+        } else {
+            // meta_nex vertices
+            if (sameSide) {
+                if (vertexIndex == 0)      { vertPos = b2;  vertPos3D = worldB2;  vertUV = vec2(mix(texU2, texU1, kb2 / dPath), Vtop2); vertColor = colorB2; }
+                else if (vertexIndex == 1) { vertPos = IK1; vertPos3D = worldIK1; vertUV = vec2(texU1, Vbot1); vertColor = color1; }
+                else if (vertexIndex == 2) { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+                else                       { vertPos = k2;  vertPos3D = worldK2;  vertUV = vec2(texU2, Vtop2); vertColor = color2; }
+            } else {
+                if (vertexIndex == 0)      { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+                else if (vertexIndex == 1) { vertPos = IK1; vertPos3D = worldIK1; vertUV = vec2(texU1, Vbot1); vertColor = color1; }
+                else if (vertexIndex == 2) { vertPos = b2;  vertPos3D = worldB2;  vertUV = vec2(mix(texU2, texU1, kb2 / dPathNex), Vtop2); vertColor = colorB2; }
+                else                       { vertPos = k2;  vertPos3D = worldK2;  vertUV = vec2(texU2, Vtop2); vertColor = color2; }
+            }
+            if (noKnee2) {
+                if (vertexIndex == 3) { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+            }
+        }
+
+        // Free projects the world-space vertex through MVP directly; Faced
+        // reconstructs clip space from aspect-corrected NDC (mirror of preview3).
+        if (isFreeRotation) {
+            gl_Position = mvpMatrix * vec4(vertPos3D, 1.0);
+        } else if (nearPlaneClipped) {
+            // At least one anchor is at / behind the near plane → the NDC math
+            // is garbage; emit a point outside the [-w,w] cube to discard.
+            gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+        } else {
+            // Inverse aspect, × anchor w; reuse anchor z/w for a consistent
+            // perspective divide within a pair-half.
+            vec4 anchorProj = isCur ? sp1 : sp2;
+            vec2 vertPosClip = vertPos / aspectMul;
+            gl_Position = vec4(vertPosClip * anchorProj.w, anchorProj.zw);
+        }
+        vColor = vertColor;
+
+        // Strip emits *raw* (U, V) — fragment wraps U via fract() before
+        // scaling into the atlas slot. Otherwise a Distance/PerSegment U
+        // > 1 would step into the neighbouring atlas tile.
+        vTexCoord = vertUV;
+        vAtlasRemap = uTexRemaps[batchTexIdx];
+        vStripPath = 1;
+        return;
+    }
+    // ─── End strip path ───────────────────────────────────────────────────
+
+    // Texel 1: originX, originY, sizeX, sizeY
+    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);
+    vColor = vec4(
+        float(packedColor & 0xFFu) / 255.0,
+        float((packedColor >> 8u) & 0xFFu) / 255.0,
+        float((packedColor >> 16u) & 0xFFu) / 255.0,
+        float((packedColor >> 24u) & 0xFFu) / 255.0
+    );
+
+    uint gridConfig = floatBitsToUint(t3.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 —
+    // otherwise a fractional index (animated frames) blends UVs from two
+    // adjacent cells horizontally (gx = mod(frac, W) leaks the fractional
+    // part into the column offset). Matches the original int(*data.inIndex_) cast.
+    float gridIndex = floor(t3.b);
+
+    // Texel 2: rotation
+    vec3 xaxis, yaxis;
+
+    if (rotationType == 0u) {
+        float angle = t2.r;
+        float rad = angle * 3.14159265 / 180.0;
+        float s = -sin(rad);
+        float c = cos(rad);
+        xaxis = uCameraRight * c + uCameraUp * s;
+        yaxis = -uCameraRight * s + uCameraUp * c;
+    } else if (rotationType == 1u) {
+        vec4 q = t2;
+        float z2 = 2.0 * q.z * q.z;
+        float xy = 2.0 * q.x * q.y;
+        float wz = 2.0 * q.w * q.z;
+        xaxis = vec3(
+            1.0 - 2.0 * q.y * q.y - z2,
+            xy + wz,
+            2.0 * q.x * q.z - 2.0 * q.w * q.y);
+        yaxis = vec3(
+            xy - wz,
+            1.0 - 2.0 * q.x * q.x - z2,
+            2.0 * q.y * q.z + 2.0 * q.w * q.x);
+    } else {
+        xaxis = cross(uCameraUp, uCameraDir);
+        yaxis = uCameraUp;
+    }
+
+    xaxis *= size.x;
+    yaxis *= size.y;
+
+    vec2 vOrigin = ORIGIN_MUL[vertexIndex] * origin
+        + INV_ORIGIN_MUL[vertexIndex] * (vec2(1.0) - origin);
+    vec3 posDisp = vOrigin.x * xaxis + vOrigin.y * yaxis;
+
+    mat4 mvpMatrix = uViewProjMatrix * uModelMatrix;
+    vec3 worldPos = position + posDisp;
+    gl_Position = mvpMatrix * vec4(worldPos, 1.0);
+
+    // v1.0-parity near-plane culling for the perspective projection: the
+    // whole quad is discarded when ANY of its 4 corners is behind the near
+    // plane (w < 0.01 == pos.z > 0.99 * z_cam in PerspectiveProjection
+    // terms). w is linear in position, so the corner minimum comes from the
+    // w-row and the corner offsets (x in {-ox, 1-ox}, y in {-oy, 1-oy}).
+    // Without a projection every w is 1.0 and this is a no-op.
+    vec4 wRow = vec4(mvpMatrix[0].w, mvpMatrix[1].w, mvpMatrix[2].w, mvpMatrix[3].w);
+    float wx = dot(wRow.xyz, xaxis);
+    float wy = dot(wRow.xyz, yaxis);
+    float minW = dot(wRow.xyz, position) + wRow.w
+        - origin.x * wx + min(wx, 0.0)
+        - origin.y * wy + min(wy, 0.0);
+    if (minW < 0.01) {
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    }
+
+    // Texture coordinates with grid + atlas remap
+    vec2 baseTexCoord = TEX_COORD[vertexIndex];
+
+    float gx = mod(gridIndex, gridWidth);
+    float gy = floor(gridIndex / gridWidth);
+    float cellW = 1.0 / gridWidth;
+    float cellH = 1.0 / gridHeight;
+
+    vec2 gridTexCoord = vec2(
+        (gx + baseTexCoord.x) * cellW,
+        1.0 - (gy + 1.0 - baseTexCoord.y) * cellH
+    );
+
+    // Quad keeps the old vertex-side atlas remap so existing IBCT
+    // snapshots (interpolated vTexCoord = final atlas UV) stay bit-
+    // perfect identical. Strip uses the fragment-side wrap path
+    // (vStripPath = 1) for atlas-aware tiling of accumulated U.
+    vec4 remap = uTexRemaps[batchTexIdx];
+    vTexCoord = remap.xy + gridTexCoord * remap.zw;
+    vAtlasRemap = remap; // unused by fragment when vStripPath == 0
+    vStripPath = 0;
+}
+`, fragmentShaderSource = `#version 300 es
+precision highp float;
+
+uniform sampler2D uTextures[8];
+// Host scene-graph container/world alpha. The particle already carries its own
+// per-particle alpha in vColor; this is the global multiplier (e.g. a faded
+// parent). Mirrors JS1.0, which scaled vertex.color[3] by worldAlpha.
+uniform float uWorldAlpha;
+
+in vec2 vTexCoord;
+in vec4 vColor;
+flat in int vBatchTextureIndex;
+flat in vec4 vAtlasRemap;
+flat in int vStripPath;
+
+out vec4 fragColor;
+
+void main() {
+    // Quad path (vStripPath == 0): vTexCoord is already the final atlas
+    // UV multiplied through in the vertex stage — kept bit-perfect with
+    // the original quad shader so IBCT snapshots remain identical.
+    //
+    // Strip path (vStripPath == 1): vTexCoord is a raw [0;..]-domain UV
+    // because the strip's accumulated U can exceed 1 (Distance mode
+    // accumulates dist / repeat, PerSegment counts up by 1 per segment).
+    // We wrap U via mod-style fract per-pixel before scaling into the
+    // emitter's atlas slot, so it tiles inside the slot instead of
+    // bleeding into a neighbouring atlas tile. fract(1.0) == 0.0, so a
+    // plain fract() would collapse U == 1.0 to U == 0.0 — we leave
+    // exact-[0;1] U values alone and only wrap outside that range.
+    // Atlas-space gradients of the RAW (un-wrapped) strip U. Hoisted above the
+    // strip/quad branch so the derivatives are taken in uniform control flow.
+    // For the affine atlas remap, d(vec2(u,y)*remap.zw+remap.xy) == d(u,y)*remap.zw,
+    // so differentiate the incoming varying (branch-invariant) and scale.
+    vec2 tcDx = dFdx(vTexCoord);
+    vec2 tcDy = dFdy(vTexCoord);
+    vec2 gradX = tcDx * vAtlasRemap.zw;
+    vec2 gradY = tcDy * vAtlasRemap.zw;
+
+    vec2 atlasUV;
+    // useGrad: strip atlas slot → sample with the un-wrapped-U gradients so the
+    // frac(u) discontinuity at a tile junction no longer poisons the mip/aniso
+    // LOD (the "chewed" column). Non-atlas strips (identity remap) and quads
+    // keep the implicit-LOD texture() sample so their baselines stay identical.
+    bool useGrad = false;
+    if (vStripPath == 0) {
+        atlasUV = vTexCoord;
+    } else {
+        float u = vTexCoord.x;
+        float wrappedU = u - floor(u);
+        if (u >= 0.0 && u <= 1.0) wrappedU = u;
+        atlasUV = vec2(wrappedU, vTexCoord.y) * vAtlasRemap.zw + vAtlasRemap.xy;
+        bool isAtlas = vAtlasRemap != vec4(0.0, 0.0, 1.0, 1.0);
+        useGrad = isAtlas;
+    }
+
+    vec4 texColor;
+    // WebGL2 requires static indexing for sampler arrays.
+    if (vBatchTextureIndex == 0) texColor = useGrad ? textureGrad(uTextures[0], atlasUV, gradX, gradY) : texture(uTextures[0], atlasUV);
+    else if (vBatchTextureIndex == 1) texColor = useGrad ? textureGrad(uTextures[1], atlasUV, gradX, gradY) : texture(uTextures[1], atlasUV);
+    else if (vBatchTextureIndex == 2) texColor = useGrad ? textureGrad(uTextures[2], atlasUV, gradX, gradY) : texture(uTextures[2], atlasUV);
+    else if (vBatchTextureIndex == 3) texColor = useGrad ? textureGrad(uTextures[3], atlasUV, gradX, gradY) : texture(uTextures[3], atlasUV);
+    else if (vBatchTextureIndex == 4) texColor = useGrad ? textureGrad(uTextures[4], atlasUV, gradX, gradY) : texture(uTextures[4], atlasUV);
+    else if (vBatchTextureIndex == 5) texColor = useGrad ? textureGrad(uTextures[5], atlasUV, gradX, gradY) : texture(uTextures[5], atlasUV);
+    else if (vBatchTextureIndex == 6) texColor = useGrad ? textureGrad(uTextures[6], atlasUV, gradX, gradY) : texture(uTextures[6], atlasUV);
+    else texColor = useGrad ? textureGrad(uTextures[7], atlasUV, gradX, gradY) : texture(uTextures[7], atlasUV);
+
+    fragColor = texColor * vColor;
+    // 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
+    // alpha-blended and additive modes.
+    fragColor *= uWorldAlpha;
+}
+`, vertexShaderSourceGL1 = `// WebGL1 (GLSL ES 1.00) port of particle.vert — variant C: the RGBA32F data
+// texture is sampled with texture2DLod + computed UV, the u32-bit-packed
+// fields come from the RGBA8 meta texture (ES 1.00 has no floatBitsToUint),
+// and vertex identity comes from the static aId attribute (no gl_VertexID).
+// Design: docs/tdd/TDD_js-v1.1-webgl1.md §4.5.
+precision highp float;
+
+attribute float aId; // particleIndex * 4 + corner
+
+uniform sampler2D uDataTexture; // RGBA/FLOAT, 4 texels per particle
+uniform sampler2D uMetaTexture; // RGBA8, same dimensions (meta texel i ~ data texel i)
+uniform vec2 uDataTexSize;
+uniform vec3 uCameraRight;
+uniform vec3 uCameraUp;
+uniform vec3 uCameraDir;
+uniform mat4 uViewProjMatrix;
+uniform mat4 uModelMatrix;
+uniform float uViewportAspect; // viewport width / height — strip-only
+uniform vec4 uTexRemaps[8];
+
+varying vec2 vTexCoord;
+varying vec4 vColor;
+// Constant across the 4 vertices of a particle, so plain (smooth) varyings
+// interpolate to the same value — ES 1.00 has no \`flat\`. The fragment stage
+// re-quantizes vBatchTextureIndex via floor(x + 0.5).
+varying float vBatchTextureIndex;
+varying vec4 vAtlasRemap;
+varying float vStripPath;
+
+// idx -> row/column with the x-range fix-up: floor(idx/W) is exact on an
+// IEEE-correct driver for idx < 2^24 (TDD §4.7), the fix-up defends against
+// the division imprecision GLSL ES 1.00 permits.
+vec2 texelUv(float idx) {
+    float y = floor(idx / uDataTexSize.x);
+    float x = idx - y * uDataTexSize.x;
+    if (x < 0.0) { y -= 1.0; x += uDataTexSize.x; }
+    if (x >= uDataTexSize.x) { y += 1.0; x -= uDataTexSize.x; }
+    return (vec2(x, y) + 0.5) / uDataTexSize;
+}
+
+vec4 fetchData(float idx) { return texture2DLod(uDataTexture, texelUv(idx), 0.0); }
+vec4 fetchMeta(float idx) { return texture2DLod(uMetaTexture, texelUv(idx), 0.0); }
+
+// Exact byte recovery from an RGBA8 UNORM sample (b/255 is spec-exact).
+float byteOf(float v) { return floor(v * 255.0 + 0.5); }
+
+// Strip geometry helper (port of GPU33 makeScreenSpaceStrip).
+vec2 stripOrtho(vec2 v) {
+    return vec2(-v.y, v.x);
+}
+
+// Corner tables (ES 1.00 has no const-array initializers — if-ladder like
+// the CS1.2 GL cornerTables()).
+vec2 originMul(float corner) {
+    if (corner < 0.5) return vec2(-1.0, 0.0);
+    if (corner < 1.5) return vec2(-1.0, -1.0);
+    if (corner < 2.5) return vec2(0.0, -1.0);
+    return vec2(0.0, 0.0);
+}
+vec2 invOriginMul(float corner) {
+    if (corner < 0.5) return vec2(0.0, 1.0);
+    if (corner < 1.5) return vec2(0.0, 0.0);
+    if (corner < 2.5) return vec2(1.0, 0.0);
+    return vec2(1.0, 1.0);
+}
+vec2 texCoordOf(float corner) {
+    if (corner < 0.5) return vec2(0.0, 0.0);
+    if (corner < 1.5) return vec2(0.0, 1.0);
+    if (corner < 2.5) return vec2(1.0, 1.0);
+    return vec2(1.0, 0.0);
+}
+
+void main() {
+    // Canonical aId decomposition (exact for aId < 2^24, TDD §4.5).
+    float corner = mod(aId, 4.0);
+    float particleIndex = (aId - corner) * 0.25;
+    float baseTexel = particleIndex * 4.0;
+
+    vec4 t0 = fetchData(baseTexel);
+    vec4 t1 = fetchData(baseTexel + 1.0);
+    vec4 t2 = fetchData(baseTexel + 2.0);
+    vec4 t3 = fetchData(baseTexel + 3.0);
+
+    // Meta M0: flags bytes — [batchTexIdx, rotationType|ctorType bits, -, -].
+    vec4 m0 = fetchMeta(baseTexel);
+    float batchTexIdx = byteOf(m0.r);
+    float flagsByte1 = byteOf(m0.g);
+    float rotationType = mod(flagsByte1, 4.0);       // bits 1:0
+    float ctorType = mod(floor(flagsByte1 * 0.25), 4.0); // bits 3:2
+    vBatchTextureIndex = batchTexIdx;
+
+    vec3 position = t0.gba;
+
+    // ─── Strip path ───────────────────────────────────────────────────────
+    // Port of the ES 3.00 strip branch (particle.vert). Same algorithm and
+    // record conventions; deltas are purely mechanical: texel fetches via
+    // texture2DLod, packed colors read directly from meta M1 (the sample IS
+    // the color), neighbor RECORD indices decoded from 3 meta bytes
+    // (M2 @ pair-cur = neighborIdxP0, M3 @ pair-nex = neighborIdxP3), and
+    // the corner/int ladders in float math.
+    if (ctorType >= 0.5) {
+        bool isCur = (ctorType < 1.5);
+        float siblingTexel = isCur ? (baseTexel + 4.0) : (baseTexel - 4.0);
+        vec4 ts0 = fetchData(siblingTexel);
+        vec4 ts1 = fetchData(siblingTexel + 1.0);
+
+        // Pair bases: cur = the "p1" end, nex = the "p2" end.
+        float curBase = isCur ? baseTexel : siblingTexel;
+        float nexBase = isCur ? siblingTexel : baseTexel;
+
+        // p1 always = position of the meta_cur end; p2 = meta_nex end.
+        vec3 p1 = isCur ? t0.gba : ts0.gba;
+        vec3 p2 = isCur ? ts0.gba : t0.gba;
+
+        float halfSize1 = isCur ? t1.r : ts1.r;
+        float halfSize2 = isCur ? ts1.r : t1.r;
+        float texU1 = isCur ? t1.g : ts1.g;
+        float texU2 = isCur ? ts1.g : t1.g;
+
+        // Colors: the meta M1 sample is the normalized RGBA directly.
+        vec4 color1 = fetchMeta(curBase + 1.0);
+        vec4 color2 = fetchMeta(nexBase + 1.0);
+
+        // Neighbor RECORD indices (system.js convention: neighborIdxP0 on the
+        // pair-cur meta, neighborIdxP3 on the pair-nex meta; boundary
+        // sentinel = the pair's cur record index).
+        vec4 mNp0 = fetchMeta(curBase + 2.0);
+        vec4 mNp3 = fetchMeta(nexBase + 3.0);
+        float np0 = byteOf(mNp0.r) + byteOf(mNp0.g) * 256.0 + byteOf(mNp0.b) * 65536.0;
+        float np3 = byteOf(mNp3.r) + byteOf(mNp3.g) * 256.0 + byteOf(mNp3.b) * 65536.0;
+        float selfPairCurRecord = curBase * 0.25;
+
+        vec3 p0 = (abs(np0 - selfPairCurRecord) < 0.5)
+            ? p1
+            : fetchData(np0 * 4.0).gba;
+        vec3 p3 = (abs(np3 - selfPairCurRecord) < 0.5)
+            ? p2
+            : fetchData(np3 * 4.0).gba;
+
+        // Segment frame: Faced (rotationType 0/2) = screen-space NDC frame;
+        // Free (rotationType 1) = full world-space 3D frame. Mirror of the
+        // ES 3.00 shader / preview3 DataTextureRenderer3.
+        mat4 mvpMatrix = uViewProjMatrix * uModelMatrix;
+        bool isFreeRotation = (rotationType > 0.5 && rotationType < 1.5);
+
+        // Anchor projections — both branches use them for gl_Position.
+        vec4 sp1 = mvpMatrix * vec4(p1, 1.0);
+        vec4 sp2 = mvpMatrix * vec4(p2, 1.0);
+
+        // Near-plane guard (Faced only; the world-space Free frame is
+        // unaffected by the sign of w).
+        bool nearPlaneClipped = (sp1.w < 1e-3) || (sp2.w < 1e-3);
+
+        // Aspect correction for the 2D Faced ortho on non-square viewports.
+        vec2 aspectMul = vec2(1.0, 1.0 / max(uViewportAspect, 1e-6));
+
+        vec4 ts2 = fetchData(siblingTexel + 2.0);
+        vec4 q1 = isCur ? t2 : ts2;
+        vec4 q2 = isCur ? ts2 : t2;
+
+        // Frame outputs: Faced fills the 2D (k/b/IK), Free the 3D
+        // (worldK/B/IK); the vertex ladder picks by isFreeRotation.
+        vec3 worldK1, worldB1, worldIK1, worldK2, worldB2, worldIK2;
+        vec2 k1, b1, IK1, k2, b2, IK2;
+        float Bmul1, Bmul2, kb1, kb2;
+        bool noKnee1, noKnee2;
+        float pathLen12; // len12 in the active frame's units
+
+        // Initialize both frames (ES 1.00 warns on possibly-uninitialized
+        // locals across the branch below on some compilers).
+        worldK1 = vec3(0.0); worldB1 = vec3(0.0); worldIK1 = vec3(0.0);
+        worldK2 = vec3(0.0); worldB2 = vec3(0.0); worldIK2 = vec3(0.0);
+        k1 = vec2(0.0); b1 = vec2(0.0); IK1 = vec2(0.0);
+        k2 = vec2(0.0); b2 = vec2(0.0); IK2 = vec2(0.0);
+
+        if (isFreeRotation) {
+            // World-space frame (mirror of GPU33 make3DStrip). Section normal
+            // n = quat z-axis; B = cross(dir12, n).
+            float xz1 = 2.0 * q1.x * q1.z;
+            float wy1 = 2.0 * q1.w * q1.y;
+            float yz1 = 2.0 * q1.y * q1.z;
+            float wx1 = 2.0 * q1.w * q1.x;
+            vec3 n1 = vec3(xz1 + wy1, yz1 - wx1, 1.0 - 2.0 * (q1.x * q1.x + q1.y * q1.y));
+            float xz2 = 2.0 * q2.x * q2.z;
+            float wy2 = 2.0 * q2.w * q2.y;
+            float yz2 = 2.0 * q2.y * q2.z;
+            float wx2 = 2.0 * q2.w * q2.x;
+            vec3 n2 = vec3(xz2 + wy2, yz2 - wx2, 1.0 - 2.0 * (q2.x * q2.x + q2.y * q2.y));
+
+            vec3 wp01 = p1 - p0;
+            vec3 wp12 = p2 - p1;
+            vec3 wp23 = p3 - p2;
+            float wlen01 = length(wp01);
+            float wlen12 = length(wp12);
+            float wlen23 = length(wp23);
+            vec3 wdir12 = (wlen12 > 1e-6) ? (wp12 / wlen12) : vec3(1.0, 0.0, 0.0);
+            vec3 wdir01 = (wlen01 > 1e-6) ? (wp01 / wlen01) : wdir12;
+            vec3 wdir23 = (wlen23 > 1e-6) ? (wp23 / wlen23) : wdir12;
+            noKnee1 = dot(wdir01, wdir12) > 0.999;
+            noKnee2 = dot(wdir12, wdir23) > 0.999;
+            pathLen12 = wlen12;
+
+            if (!noKnee1) {
+                vec3 B1raw = normalize(cross(wdir12, n1));
+                vec3 c1 = normalize(cross(wdir01, wdir12));
+                float Kmul1 = sign(dot(c1, n1));
+                vec3 K1 = Kmul1 * normalize(cross(wdir01 + wdir12, n1));
+                Bmul1 = sign(dot(B1raw, K1));
+                vec3 B1 = B1raw * Bmul1;
+                float ik1 = halfSize1 / max(dot(B1, K1), 1e-6);
+                if (dot(-wdir01, ik1 * -K1) > wlen01) ik1 = wlen01;
+                if (dot( wdir12, ik1 * -K1) > wlen12) ik1 = wlen12;
+                worldK1 = p1 + K1 * halfSize1;
+                worldB1 = p1 + B1 * halfSize1;
+                worldIK1 = p1 - K1 * ik1;
+                kb1 = distance(worldK1, worldB1);
+            } else {
+                Bmul1 = 1.0;
+                vec3 B1 = normalize(cross(wdir01 + wdir12, n1));
+                worldK1 = p1 + B1 * halfSize1;
+                worldB1 = worldK1;
+                worldIK1 = p1 - B1 * halfSize1;
+                kb1 = 0.0;
+            }
+
+            if (!noKnee2) {
+                vec3 B2raw = normalize(cross(wdir12, n2));
+                vec3 c2 = normalize(cross(wdir12, wdir23));
+                float Kmul2 = sign(dot(c2, n2));
+                vec3 K2 = Kmul2 * normalize(cross(wdir12 + wdir23, n2));
+                Bmul2 = sign(dot(B2raw, K2));
+                vec3 B2 = B2raw * Bmul2;
+                float ik2 = halfSize2 / max(dot(B2, K2), 1e-6);
+                if (dot(-wdir12, ik2 * -K2) > wlen12) ik2 = wlen12;
+                if (dot( wdir23, ik2 * -K2) > wlen23) ik2 = wlen23;
+                worldK2 = p2 + K2 * halfSize2;
+                worldB2 = p2 + B2 * halfSize2;
+                worldIK2 = p2 - K2 * ik2;
+                kb2 = distance(worldK2, worldB2);
+            } else {
+                Bmul2 = 1.0;
+                vec3 B2 = normalize(cross(wdir12 + wdir23, n2));
+                worldK2 = p2 + B2 * halfSize2;
+                worldB2 = worldK2;
+                worldIK2 = p2 - B2 * halfSize2;
+                kb2 = 0.0;
+            }
+        } else {
+            // Faced: screen-space NDC frame around dir12.
+            vec4 sp0 = mvpMatrix * vec4(p0, 1.0);
+            vec4 sp3 = mvpMatrix * vec4(p3, 1.0);
+            vec2 ndc1 = (sp1.xy / sp1.w) * aspectMul;
+            vec2 ndc2 = (sp2.xy / sp2.w) * aspectMul;
+            // Neighbor anchors behind the near plane produce garbage NDC after
+            // the perspective divide (possible only with Projection3D, where w
+            // varies); collapse them onto their segment anchor so the existing
+            // zero-length degeneracy path (dir01 = dir12 / dir23 = dir12)
+            // handles the knee instead of a poisoned miter. spU1/spU2 need no
+            // guard: uCameraUp has zero Z, so their w equals sp1.w / sp2.w.
+            vec2 ndc0 = (sp0.w < 1e-3) ? ndc1 : (sp0.xy / sp0.w) * aspectMul;
+            vec2 ndc3 = (sp3.w < 1e-3) ? ndc2 : (sp3.xy / sp3.w) * aspectMul;
+
+            vec2 d01 = ndc1 - ndc0;
+            vec2 d12 = ndc2 - ndc1;
+            vec2 d23 = ndc3 - ndc2;
+            float len01 = length(d01);
+            float len12 = length(d12);
+            float len23 = length(d23);
+            vec2 dir12 = (len12 > 1e-6) ? (d12 / len12) : vec2(1.0, 0.0);
+            vec2 dir01 = (len01 > 1e-6) ? (d01 / len01) : dir12;
+            vec2 dir23 = (len23 > 1e-6) ? (d23 / len23) : dir12;
+            noKnee1 = dot(dir01, dir12) > 0.999;
+            noKnee2 = dot(dir12, dir23) > 0.999;
+            pathLen12 = len12;
+
+            // Section magnitude: project camera_up*halfSize per anchor into NDC.
+            vec4 spU1 = mvpMatrix * vec4(p1 + uCameraUp * halfSize1, 1.0);
+            vec4 spU2 = mvpMatrix * vec4(p2 + uCameraUp * halfSize2, 1.0);
+            float ndcHalfSize1 = length((spU1.xy / spU1.w) * aspectMul - ndc1);
+            float ndcHalfSize2 = length((spU2.xy / spU2.w) * aspectMul - ndc2);
+
+            vec2 B = stripOrtho(dir12);
+            if (!noKnee1) {
+                float Kmul1 = -sign(dot(stripOrtho(dir01), dir12));
+                vec2 K1 = Kmul1 * normalize(stripOrtho(dir01 + dir12));
+                Bmul1 = sign(dot(B, K1));
+                vec2 B1 = B * Bmul1;
+                float ik1 = ndcHalfSize1 / max(dot(B1, K1), 1e-6);
+                if (dot(-dir01, ik1 * -K1) > len01) ik1 = len01;
+                if (dot(dir12, ik1 * -K1) > len12) ik1 = len12;
+                k1 = ndc1 + K1 * ndcHalfSize1;
+                b1 = ndc1 + B1 * ndcHalfSize1;
+                IK1 = ndc1 - K1 * ik1;
+                kb1 = distance(k1, b1);
+            } else {
+                vec2 B1 = normalize(stripOrtho(dir01 + dir12));
+                Bmul1 = 1.0;
+                k1 = ndc1 + B1 * ndcHalfSize1;
+                b1 = k1;
+                IK1 = ndc1 - B1 * ndcHalfSize1;
+                kb1 = 0.0;
+            }
+            if (!noKnee2) {
+                float Kmul2 = -sign(dot(stripOrtho(dir12), dir23));
+                vec2 K2 = Kmul2 * normalize(stripOrtho(dir12 + dir23));
+                Bmul2 = sign(dot(B, K2));
+                vec2 B2 = B * Bmul2;
+                float ik2 = ndcHalfSize2 / max(dot(B2, K2), 1e-6);
+                if (dot(-dir12, ik2 * -K2) > len12) ik2 = len12;
+                if (dot(dir23, ik2 * -K2) > len23) ik2 = len23;
+                k2 = ndc2 + K2 * ndcHalfSize2;
+                b2 = ndc2 + B2 * ndcHalfSize2;
+                IK2 = ndc2 - K2 * ik2;
+                kb2 = distance(k2, b2);
+            } else {
+                vec2 B2 = normalize(stripOrtho(dir12 + dir23));
+                Bmul2 = 1.0;
+                k2 = ndc2 + B2 * ndcHalfSize2;
+                b2 = k2;
+                IK2 = ndc2 - B2 * ndcHalfSize2;
+                kb2 = 0.0;
+            }
+        }
+
+        // V coords: V at outer knee (k) = (Bmul + 1) * 0.5; inner = 1 - outer.
+        float Vtop1 = (Bmul1 + 1.0) * 0.5;
+        float Vbot1 = 1.0 - Vtop1;
+        float Vtop2 = (Bmul2 + 1.0) * 0.5;
+        float Vbot2 = 1.0 - Vtop2;
+
+        // Vertex layout per meta over the IBO [0,1,2, 0,2,3] — same ladder as
+        // the ES 3.00 shader (see its comment block for the geometry).
+        bool sameSide = (Bmul1 * Bmul2 >= 0.0);
+        float dPath = max(sameSide ? (kb1 + pathLen12 + kb2) : (kb1 + pathLen12), 1e-6);
+        float dPathNex = max(sameSide ? dPath : (kb2 + pathLen12), 1e-6);
+
+        float bUcur = kb1 / dPath;
+        float bUnex = sameSide ? (kb2 / dPath) : (kb2 / dPathNex);
+        vec4 colorB1 = mix(color1, color2, bUcur);
+        vec4 colorB2 = mix(color2, color1, bUnex);
+
+        vec2 vertPos;
+        vec3 vertPos3D = vec3(0.0);
+        vec2 vertUV;
+        vec4 vertColor;
+        if (isCur) {
+            // meta_cur vertices
+            if (corner < 0.5) {
+                vertPos = b1; vertPos3D = worldB1;
+                vertUV = vec2(mix(texU1, texU2, kb1 / dPath), Vtop1);
+                vertColor = colorB1;
+            } else if (corner < 1.5) {
+                vertPos = k1; vertPos3D = worldK1;
+                vertUV = vec2(texU1, Vtop1);
+                vertColor = color1;
+            } else if (corner < 2.5) {
+                vertPos = IK1; vertPos3D = worldIK1;
+                vertUV = vec2(texU1, Vbot1);
+                vertColor = color1;
+            } else {
+                // v3 = b2 (sameSide) or IK2 (different side)
+                if (sameSide) {
+                    vertPos = b2; vertPos3D = worldB2;
+                    vertUV = vec2(mix(texU2, texU1, kb2 / dPath), Vtop2);
+                    vertColor = colorB2;
+                } else {
+                    vertPos = IK2; vertPos3D = worldIK2;
+                    vertUV = vec2(texU2, Vbot2);
+                    vertColor = color2;
+                }
+            }
+            // noKnee fallback: collapse to k1/IK1 to produce degenerate segments.
+            if (noKnee1) {
+                if (corner < 0.5) { vertPos = k1; vertPos3D = worldK1; vertUV = vec2(texU1, Vtop1); vertColor = color1; }
+            }
+        } else {
+            // meta_nex vertices
+            if (sameSide) {
+                if (corner < 0.5)      { vertPos = b2;  vertPos3D = worldB2;  vertUV = vec2(mix(texU2, texU1, kb2 / dPath), Vtop2); vertColor = colorB2; }
+                else if (corner < 1.5) { vertPos = IK1; vertPos3D = worldIK1; vertUV = vec2(texU1, Vbot1); vertColor = color1; }
+                else if (corner < 2.5) { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+                else                   { vertPos = k2;  vertPos3D = worldK2;  vertUV = vec2(texU2, Vtop2); vertColor = color2; }
+            } else {
+                if (corner < 0.5)      { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+                else if (corner < 1.5) { vertPos = IK1; vertPos3D = worldIK1; vertUV = vec2(texU1, Vbot1); vertColor = color1; }
+                else if (corner < 2.5) { vertPos = b2;  vertPos3D = worldB2;  vertUV = vec2(mix(texU2, texU1, kb2 / dPathNex), Vtop2); vertColor = colorB2; }
+                else                   { vertPos = k2;  vertPos3D = worldK2;  vertUV = vec2(texU2, Vtop2); vertColor = color2; }
+            }
+            if (noKnee2) {
+                if (corner > 2.5) { vertPos = IK2; vertPos3D = worldIK2; vertUV = vec2(texU2, Vbot2); vertColor = color2; }
+            }
+        }
+
+        // Free projects the world-space vertex through MVP directly; Faced
+        // reconstructs clip space from aspect-corrected NDC.
+        if (isFreeRotation) {
+            gl_Position = mvpMatrix * vec4(vertPos3D, 1.0);
+        } else if (nearPlaneClipped) {
+            gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+        } else {
+            vec4 anchorProj = isCur ? sp1 : sp2;
+            vec2 vertPosClip = vertPos / aspectMul;
+            gl_Position = vec4(vertPosClip * anchorProj.w, anchorProj.zw);
+        }
+        vColor = vertColor;
+
+        // Strip emits raw (U, V) — fragment wraps U into the atlas slot.
+        vTexCoord = vertUV;
+        vAtlasRemap = uTexRemaps[int(batchTexIdx)];
+        vStripPath = 1.0;
+        return;
+    }
+    // ─── End strip path ─────────────────────────────────────────────────────
+
+    // Texel 1: originX, originY, sizeX, sizeY
+    vec2 origin = t1.rg;
+    vec2 size = t1.ba;
+
+    // Meta M1: the packedColor u32 LE bytes ARE the normalized RGBA sample.
+    vColor = fetchMeta(baseTexel + 1.0);
+
+    // Meta M2: gridConfig — [gridW lo, gridW hi, gridH lo, gridH hi].
+    vec4 m2 = fetchMeta(baseTexel + 2.0);
+    float gridWidth = max(byteOf(m2.r) + byteOf(m2.g) * 256.0, 1.0);
+    float gridHeight = max(byteOf(m2.b) + byteOf(m2.a) * 256.0, 1.0);
+    // gridIndex is a plain float — read from the float texture (mirror of the
+    // ES 3.00 shader: truncate so animated frames pick a single cell).
+    float gridIndex = floor(t3.b);
+
+    // Texel 2: rotation
+    vec3 xaxis, yaxis;
+
+    if (rotationType < 0.5) {
+        float angle = t2.r;
+        float rad = angle * 3.14159265 / 180.0;
+        float s = -sin(rad);
+        float c = cos(rad);
+        xaxis = uCameraRight * c + uCameraUp * s;
+        yaxis = -uCameraRight * s + uCameraUp * c;
+    } else if (rotationType < 1.5) {
+        vec4 q = t2;
+        float z2 = 2.0 * q.z * q.z;
+        float xy = 2.0 * q.x * q.y;
+        float wz = 2.0 * q.w * q.z;
+        xaxis = vec3(
+            1.0 - 2.0 * q.y * q.y - z2,
+            xy + wz,
+            2.0 * q.x * q.z - 2.0 * q.w * q.y);
+        yaxis = vec3(
+            xy - wz,
+            1.0 - 2.0 * q.x * q.x - z2,
+            2.0 * q.y * q.z + 2.0 * q.w * q.x);
+    } else {
+        xaxis = cross(uCameraUp, uCameraDir);
+        yaxis = uCameraUp;
+    }
+
+    xaxis *= size.x;
+    yaxis *= size.y;
+
+    vec2 vOrigin = originMul(corner) * origin
+        + invOriginMul(corner) * (vec2(1.0) - origin);
+    vec3 posDisp = vOrigin.x * xaxis + vOrigin.y * yaxis;
+
+    mat4 mvpMatrix = uViewProjMatrix * uModelMatrix;
+    vec3 worldPos = position + posDisp;
+    gl_Position = mvpMatrix * vec4(worldPos, 1.0);
+
+    // v1.0-parity near-plane culling for the perspective projection: the
+    // whole quad is discarded when ANY of its 4 corners is behind the near
+    // plane (w < 0.01 == pos.z > 0.99 * z_cam in PerspectiveProjection
+    // terms). w is linear in position, so the corner minimum comes from the
+    // w-row and the corner offsets (x in {-ox, 1-ox}, y in {-oy, 1-oy}).
+    // Without a projection every w is 1.0 and this is a no-op.
+    vec4 wRow = vec4(mvpMatrix[0].w, mvpMatrix[1].w, mvpMatrix[2].w, mvpMatrix[3].w);
+    float wx = dot(wRow.xyz, xaxis);
+    float wy = dot(wRow.xyz, yaxis);
+    float minW = dot(wRow.xyz, position) + wRow.w
+        - origin.x * wx + min(wx, 0.0)
+        - origin.y * wy + min(wy, 0.0);
+    if (minW < 0.01) {
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    }
+
+    // Texture coordinates with grid + atlas remap
+    vec2 baseTexCoord = texCoordOf(corner);
+
+    float gx = mod(gridIndex, gridWidth);
+    float gy = floor(gridIndex / gridWidth);
+    float cellW = 1.0 / gridWidth;
+    float cellH = 1.0 / gridHeight;
+
+    vec2 gridTexCoord = vec2(
+        (gx + baseTexCoord.x) * cellW,
+        1.0 - (gy + 1.0 - baseTexCoord.y) * cellH
+    );
+
+    // Dynamic indexing of a uniform array is legal in ES 1.00 VERTEX shaders
+    // (only fragment shaders are constant-index restricted).
+    vec4 remap = uTexRemaps[int(batchTexIdx)];
+    vTexCoord = remap.xy + gridTexCoord * remap.zw;
+    vAtlasRemap = remap; // unused by fragment when vStripPath == 0
+    vStripPath = 0.0;
+}
+`, fragmentShaderSourceGL1 = `// WebGL1 (GLSL ES 1.00) port of particle.frag. Fragment highp is a REQUIRED
+// capability of the GL1 path (probed at Context creation) — the strip U-wrap
+// does floor/fract on accumulated texU which mediump would corrupt; the
+// #else branch only keeps the shader compilable on probe-rejected devices.
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+uniform sampler2D uTextures[8];
+// Host scene-graph container/world alpha (same semantics as the ES 3.00
+// shader: scales the whole premultiplied RGBA).
+uniform float uWorldAlpha;
+
+varying vec2 vTexCoord;
+varying vec4 vColor;
+varying float vBatchTextureIndex; // constant across the quad; re-quantized below
+varying vec4 vAtlasRemap;
+varying float vStripPath;
+
+void main() {
+    // Quad path (vStripPath == 0): vTexCoord is the final atlas UV from the
+    // vertex stage. Strip path (vStripPath == 1): raw U wrapped per-pixel
+    // into the atlas slot; exact-[0;1] U is left alone (fract(1.0) == 0.0
+    // would collapse the strip end) — mirror of the ES 3.00 shader.
+    vec2 atlasUV;
+    if (vStripPath < 0.5) {
+        atlasUV = vTexCoord;
+    } else {
+        float u = vTexCoord.x;
+        float wrappedU = u - floor(u);
+        if (u >= 0.0 && u <= 1.0) wrappedU = u;
+        atlasUV = vec2(wrappedU, vTexCoord.y) * vAtlasRemap.zw + vAtlasRemap.xy;
+    }
+
+    // ES 1.00 fragment shaders require constant sampler indexing — the same
+    // if-ladder as WebGL2, driven by the re-quantized float varying.
+    float texIdx = floor(vBatchTextureIndex + 0.5);
+    vec4 texColor;
+    if (texIdx < 0.5) texColor = texture2D(uTextures[0], atlasUV);
+    else if (texIdx < 1.5) texColor = texture2D(uTextures[1], atlasUV);
+    else if (texIdx < 2.5) texColor = texture2D(uTextures[2], atlasUV);
+    else if (texIdx < 3.5) texColor = texture2D(uTextures[3], atlasUV);
+    else if (texIdx < 4.5) texColor = texture2D(uTextures[4], atlasUV);
+    else if (texIdx < 5.5) texColor = texture2D(uTextures[5], atlasUV);
+    else if (texIdx < 6.5) texColor = texture2D(uTextures[6], atlasUV);
+    else texColor = texture2D(uTextures[7], atlasUV);
+
+    // 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;
+}
+`, R = class R {
+  constructor(e, t) {
+    i(this, "neutrino");
+    i(this, "renderer");
+    // On a WebGL1 context this actually holds a WebGLRenderingContext; the
+    // GL2-only members are never touched on the GL1 path.
+    i(this, "gl");
+    i(this, "options");
+    i(this, "loadData");
+    i(this, "_shaderProgram", null);
+    i(this, "_indexBuffer", null);
+    i(this, "_dummyVB", null);
+    i(this, "_indexBufferCapacity", 0);
+    i(this, "_vao", null);
+    // WebGL1 render path state (TDD_js-v1.1-webgl1.md)
+    i(this, "_isWebGL1", !1);
+    i(this, "_maxBatchTextures", R.MAX_BATCH_TEXTURES);
+    i(this, "_hasElementIndexUint", !1);
+    i(this, "_vaoExt", null);
+    i(this, "_aIdBuffer", null);
+    i(this, "_aIdLocation", -1);
+    // Uniform locations
+    i(this, "_uDataTexture", null);
+    i(this, "_uDataTextureWidth", null);
+    i(this, "_uMetaTexture", null);
+    i(this, "_uDataTexSize", null);
+    i(this, "_uCameraRight", null);
+    i(this, "_uCameraUp", null);
+    i(this, "_uCameraDir", null);
+    i(this, "_uViewProjMatrix", null);
+    i(this, "_uModelMatrix", null);
+    i(this, "_uViewportAspect", null);
+    i(this, "_uWorldAlpha", null);
+    i(this, "_uTextures", []);
+    i(this, "_uTexRemaps", []);
+    i(this, "_noiseInitialized");
+    var n;
+    if (this.renderer = e, this.gl = e.gl, !this.gl)
+      throw new Error("NeutrinoParticles (js-v1.1): a WebGL renderer is required.");
+    this.options = Object.assign({
+      texturesBasePath: "",
+      trimmedExtensionsLookupFirst: !0
+    }, t), this.neutrino = new Neutrino.Context(), this.loadData = { __neutrinoContext__: this }, this._noiseInitialized = !1;
+    const r = ((n = e.context) == null ? void 0 : n.webGLVersion) ?? (typeof this.gl.createVertexArray == "function" ? 2 : 1);
+    this._isWebGL1 = r === 1, this._isWebGL1 && this._probeWebGL1Capabilities(), this._initShader(), this._isWebGL1 && this._smokeTestVertexTextureFetch();
+  }
+  initializeNoise(e, t, r) {
+    if (this._noiseInitialized) {
+      t && t();
+      return;
+    }
+    this.neutrino.initializeNoise(
+      e,
+      () => {
+        this._noiseInitialized = !0, t && t();
+      },
+      r
+    );
+  }
+  generateNoise() {
+    if (this._noiseInitialized) return;
+    const e = new this.neutrino.NoiseGenerator();
+    for (; !e.step(); )
+      ;
+    this._noiseInitialized = !0;
+  }
+  get shaderProgram() {
+    return this._shaderProgram;
+  }
+  get isWebGL1() {
+    return this._isWebGL1;
+  }
+  /**
+   * Textures usable in one batch. 8 on WebGL2; on WebGL1 reduced when the
+   * combined texture-unit budget is tight (the vertex stage takes 2 units).
+   * A lower cap only produces more batches, never wrong output.
+   */
+  get maxBatchTextures() {
+    return this._maxBatchTextures;
+  }
+  get uDataTexture() {
+    return this._uDataTexture;
+  }
+  get uDataTextureWidth() {
+    return this._uDataTextureWidth;
+  }
+  get uMetaTexture() {
+    return this._uMetaTexture;
+  }
+  get uDataTexSize() {
+    return this._uDataTexSize;
+  }
+  get uCameraRight() {
+    return this._uCameraRight;
+  }
+  get uCameraUp() {
+    return this._uCameraUp;
+  }
+  get uCameraDir() {
+    return this._uCameraDir;
+  }
+  get uViewProjMatrix() {
+    return this._uViewProjMatrix;
+  }
+  get uModelMatrix() {
+    return this._uModelMatrix;
+  }
+  get uViewportAspect() {
+    return this._uViewportAspect;
+  }
+  get uWorldAlpha() {
+    return this._uWorldAlpha;
+  }
+  get uTextures() {
+    return this._uTextures;
+  }
+  get uTexRemaps() {
+    return this._uTexRemaps;
+  }
+  ensureIndexBuffer(e) {
+    if (e <= this._indexBufferCapacity) return;
+    const t = this.gl;
+    this._indexBuffer && t.deleteBuffer(this._indexBuffer), this._dummyVB && (t.deleteBuffer(this._dummyVB), this._dummyVB = null), this._vao && t.deleteVertexArray(this._vao), this._aIdBuffer && (t.deleteBuffer(this._aIdBuffer), this._aIdBuffer = null);
+    const r = e > 16383;
+    if (r && this._isWebGL1 && !this._hasElementIndexUint)
+      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 n = r ? new Uint32Array(e * 6) : new Uint16Array(e * 6);
+    for (let o = 0; o < e; o++) {
+      const s = o * 4, a = o * 6;
+      n[a + 0] = s + 0, n[a + 1] = s + 1, n[a + 2] = s + 2, n[a + 3] = s + 0, n[a + 4] = s + 2, n[a + 5] = s + 3;
+    }
+    if (this._indexBuffer = t.createBuffer(), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this._indexBuffer), t.bufferData(t.ELEMENT_ARRAY_BUFFER, n, t.STATIC_DRAW), this._isWebGL1) {
+      const o = new Float32Array(e * 4);
+      for (let s = 0; s < o.length; s++) o[s] = s;
+      this._aIdBuffer = t.createBuffer(), t.bindBuffer(t.ARRAY_BUFFER, this._aIdBuffer), t.bufferData(t.ARRAY_BUFFER, o, t.STATIC_DRAW), t.bindBuffer(t.ARRAY_BUFFER, null), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, null);
+    } 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(null);
+    this._indexBufferCapacity = e;
+  }
+  get vao() {
+    return this._vao;
+  }
+  get indexBuffer() {
+    return this._indexBuffer;
+  }
+  get aIdBuffer() {
+    return this._aIdBuffer;
+  }
+  get aIdLocation() {
+    return this._aIdLocation;
+  }
+  get indexType() {
+    return this._indexBufferCapacity > 16383 ? this.gl.UNSIGNED_INT : this.gl.UNSIGNED_SHORT;
+  }
+  /** Unbind any VAO (incl. OES on WebGL1) before raw attribute setup. */
+  unbindVao() {
+    this._isWebGL1 ? this._vaoExt && this._vaoExt.bindVertexArrayOES(null) : this.gl.bindVertexArray(null);
+  }
+  destroy() {
+    const e = this.gl;
+    this._shaderProgram && e.deleteProgram(this._shaderProgram), this._indexBuffer && e.deleteBuffer(this._indexBuffer), this._dummyVB && e.deleteBuffer(this._dummyVB), this._vao && e.deleteVertexArray(this._vao), this._aIdBuffer && e.deleteBuffer(this._aIdBuffer);
+  }
+  // ── WebGL1 capability probe (TDD §4.2) ─────────────────────────────────
+  _probeWebGL1Capabilities() {
+    const e = this.gl;
+    if (!e.getExtension("OES_texture_float"))
+      throw new Error(
+        "NeutrinoParticles (js-v1.1): WebGL1 context lacks OES_texture_float; WebGL2 or WebGL1 with vertex float textures is required."
+      );
+    const t = e.getParameter(e.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+    if (t < 2)
+      throw new Error(
+        "NeutrinoParticles (js-v1.1): WebGL1 context has " + t + " vertex texture units (2 required); WebGL2 or WebGL1 with vertex float textures is required."
+      );
+    const r = e.getShaderPrecisionFormat(e.FRAGMENT_SHADER, e.HIGH_FLOAT);
+    if (!r || r.precision === 0)
+      throw new Error(
+        "NeutrinoParticles (js-v1.1): WebGL1 context lacks highp float in fragment shaders; WebGL2 or WebGL1 with fragment highp is required."
+      );
+    this._hasElementIndexUint = !!e.getExtension("OES_element_index_uint"), this._vaoExt = e.getExtension("OES_vertex_array_object");
+    const n = e.getParameter(e.MAX_COMBINED_TEXTURE_IMAGE_UNITS), o = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS);
+    this._maxBatchTextures = Math.max(
+      1,
+      Math.min(R.MAX_BATCH_TEXTURES, n - 2, o)
+    );
+  }
+  /**
+   * Compile/link alone does not prove vertex texture fetch works on a
+   * driver — some fail only at draw time. One-time 1×1 smoke draw: a point
+   * whose color is produced by sampling a float and a byte texture in the
+   * vertex shader, rendered into a 1×1 RGBA8 FBO and read back.
+   */
+  _smokeTestVertexTextureFetch() {
+    const e = this.gl, t = `precision highp float;
+attribute float aId;
+uniform sampler2D uF;
+uniform sampler2D uB;
+varying vec4 vC;
+void main() {
+    vec4 f = texture2DLod(uF, vec2(0.5, 0.5), 0.0);
+    vec4 b = texture2DLod(uB, vec2(0.5, 0.5), 0.0);
+    vC = vec4(f.r * b.r, f.g * b.g, f.b * b.b, 1.0);
+    gl_Position = vec4(aId, 0.0, 0.0, 1.0);
+    gl_PointSize = 1.0;
+}
+`, r = `precision mediump float;
+varying vec4 vC;
+void main() { gl_FragColor = vC; }
+`, n = e.getParameter(e.VIEWPORT), o = e.getParameter(e.CURRENT_PROGRAM), s = e.getParameter(e.ARRAY_BUFFER_BINDING), a = e.getParameter(e.FRAMEBUFFER_BINDING), c = e.getParameter(e.ACTIVE_TEXTURE);
+    e.activeTexture(e.TEXTURE0);
+    const U = e.getParameter(e.TEXTURE_BINDING_2D);
+    e.activeTexture(e.TEXTURE1);
+    const S = e.getParameter(e.TEXTURE_BINDING_2D), C = e.isEnabled(e.BLEND), I = e.isEnabled(e.DEPTH_TEST), D = e.isEnabled(e.SCISSOR_TEST);
+    let v = null, b = null, w = null, m = null, T = null, _ = null, x = -1, B = !1, P = null, y = 4, d = 0, f = 0, g = 0, E = !1, u = !1;
+    const h = new Uint8Array(4);
+    try {
+      v = e.createProgram(), e.attachShader(v, this._compileShader(e.VERTEX_SHADER, t)), e.attachShader(v, this._compileShader(e.FRAGMENT_SHADER, r)), e.linkProgram(v);
+      const p = (M, k) => {
+        const K = e.createTexture();
+        return e.bindTexture(e.TEXTURE_2D, K), 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, M, k), K;
+      };
+      e.activeTexture(e.TEXTURE0), b = p(e.FLOAT, new Float32Array([1, 0.5, 0.25, 1])), w = p(e.UNSIGNED_BYTE, new Uint8Array([51, 102, 153, 255])), m = e.createTexture(), e.bindTexture(e.TEXTURE_2D, m), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, e.UNSIGNED_BYTE, null), T = e.createFramebuffer(), e.bindFramebuffer(e.FRAMEBUFFER, T), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, m, 0), _ = e.createBuffer(), e.bindBuffer(e.ARRAY_BUFFER, _), e.bufferData(e.ARRAY_BUFFER, new Float32Array([0]), e.STATIC_DRAW), u = e.getProgramParameter(v, e.LINK_STATUS), u && (e.useProgram(v), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, b), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, w), e.uniform1i(e.getUniformLocation(v, "uF"), 0), e.uniform1i(e.getUniformLocation(v, "uB"), 1), x = e.getAttribLocation(v, "aId"), B = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_ENABLED), P = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING), y = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_SIZE), d = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_TYPE), E = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_NORMALIZED), f = e.getVertexAttrib(x, e.VERTEX_ATTRIB_ARRAY_STRIDE), g = e.getVertexAttribOffset(x, e.VERTEX_ATTRIB_ARRAY_POINTER), e.enableVertexAttribArray(x), e.vertexAttribPointer(x, 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, h), u = Math.abs(h[0] - 51) <= 2 && Math.abs(h[1] - 51) <= 2 && Math.abs(h[2] - 38) <= 2);
+    } finally {
+      x >= 0 && (P && (e.bindBuffer(e.ARRAY_BUFFER, P), e.vertexAttribPointer(
+        x,
+        y,
+        d,
+        E,
+        f,
+        g
+      )), B ? e.enableVertexAttribArray(x) : e.disableVertexAttribArray(x)), T && e.deleteFramebuffer(T), m && e.deleteTexture(m), b && e.deleteTexture(b), w && e.deleteTexture(w), _ && e.deleteBuffer(_), v && e.deleteProgram(v), e.bindFramebuffer(e.FRAMEBUFFER, a), e.bindBuffer(e.ARRAY_BUFFER, s), e.useProgram(o), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, U), e.activeTexture(e.TEXTURE1), e.bindTexture(e.TEXTURE_2D, S), e.activeTexture(c), C && e.enable(e.BLEND), I && e.enable(e.DEPTH_TEST), D && e.enable(e.SCISSOR_TEST), e.viewport(n[0], n[1], n[2], n[3]);
+    }
+    if (!u)
+      throw new Error(
+        `NeutrinoParticles (js-v1.1): WebGL1 vertex texture fetch smoke test failed (got ${h[0]},${h[1]},${h[2]}); WebGL2 or WebGL1 with working vertex float textures is required.`
+      );
+  }
+  _initShader() {
+    const e = this.gl, t = this._isWebGL1 ? vertexShaderSourceGL1 : vertexShaderSource, r = this._isWebGL1 ? fragmentShaderSourceGL1 : fragmentShaderSource, n = this._compileShader(e.VERTEX_SHADER, t), o = this._compileShader(e.FRAGMENT_SHADER, r);
+    if (this._shaderProgram = e.createProgram(), e.attachShader(this._shaderProgram, n), 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(n), 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 s = 0; s < R.MAX_BATCH_TEXTURES; s++)
+      this._uTextures.push(e.getUniformLocation(this._shaderProgram, `uTextures[${s}]`)), this._uTexRemaps.push(e.getUniformLocation(this._shaderProgram, `uTexRemaps[${s}]`));
+  }
+  _compileShader(e, t) {
+    const r = this.gl, n = r.createShader(e);
+    if (r.shaderSource(n, t), r.compileShader(n), !r.getShaderParameter(n, r.COMPILE_STATUS)) {
+      const o = r.getShaderInfoLog(n);
+      throw r.deleteShader(n), new Error("Shader compile error: " + o);
+    }
+    return n;
+  }
+};
+i(R, "MAX_BATCH_TEXTURES", 8);
+let Context = R;
+class ApplicationPlugin {
+  static get extension() {
+    return {
+      name: "neutrino",
+      type: ExtensionType.Application
+    };
+  }
+  static init(e) {
+    this.neutrino = new Context(this.renderer, e.neutrino);
+  }
+  static destroy() {
+    this.neutrino && (this.neutrino.destroy(), this.neutrino = void 0);
+  }
+}
+class EffectModel extends EventEmitter {
+  constructor(context, neutrinoModel, texturesLoader) {
+    super();
+    i(this, "ctx");
+    i(this, "effectModel");
+    i(this, "texturesRemap", []);
+    i(this, "textures", []);
+    i(this, "_numTexturesToLoadLeft");
+    if (this.ctx = context, typeof neutrinoModel == "string") {
+      const evalScript = `(function(ctx) {
+` + neutrinoModel + `
+return new NeutrinoEffect(ctx);
+})(context.neutrino);`;
+      this.effectModel = eval(evalScript);
+    } else
+      this.effectModel = neutrinoModel;
+    const numTextures = this.effectModel.textures.length;
+    this._numTexturesToLoadLeft = numTextures;
+    for (let e = 0; e < numTextures; ++e) {
+      const t = this.effectModel.textures[e];
+      let r = null;
+      if (this.ctx.options.trimmedExtensionsLookupFirst) {
+        const n = t.replace(/\.[^/.]+$/, "");
+        Cache.has(n) && (r = Cache.get(n));
+      }
+      !r && Cache.has(t) && (r = Cache.get(t)), r ? this._onTextureLoaded(e, r, !0) : texturesLoader.load(this.ctx.options.texturesBasePath + t).then(
+        /* @__PURE__ */ ((n, o) => (s) => {
+          n._onTextureLoaded(o, s, !1);
+        })(this, e)
+      );
+    }
+  }
+  ready() {
+    return this._numTexturesToLoadLeft === 0;
+  }
+  _onTextureLoaded(e, t, r) {
+    this.textures[e] = t, this._numTexturesToLoadLeft--, this._numTexturesToLoadLeft === 0 && (this._initTexturesRemapIfNeeded(), r ? setTimeout(() => {
+      this.emit("ready", this);
+    }, 0) : this.emit("ready", this));
+  }
+  _initTexturesRemapIfNeeded() {
+    let e = !1;
+    for (let t = 0; t < this.textures.length; ++t) {
+      const r = this.textures[t];
+      if (r.frame.x != 0 || r.frame.y != 0 || r.frame.width != r.source.pixelWidth || r.frame.height != r.source.pixelHeight) {
+        e = !0;
+        break;
+      }
+    }
+    if (e)
+      for (let t = 0; t < this.textures.length; ++t) {
+        const r = this.textures[t];
+        this.texturesRemap[t] = {
+          x: r.frame.x / r.source.pixelWidth,
+          y: 1 - (r.frame.y + r.frame.height) / r.source.pixelHeight,
+          width: r.frame.width / r.source.pixelWidth,
+          height: r.frame.height / r.source.pixelHeight
+        };
+      }
+  }
+}
+class AbstractTexturesLoader {
+  constructor() {
+  }
+}
+class AssetsTexturesLoader extends AbstractTexturesLoader {
+  constructor(t) {
+    super();
+    i(this, "loader");
+    this.loader = t;
+  }
+  async load(t) {
+    return await this.loader.load(t);
+  }
+}
+const A = class A extends AssetsTexturesLoader {
+  constructor() {
+    super(Assets.loader);
+  }
+};
+i(A, "instance", new A());
+let DefaultAssetsTexturesLoader = A;
+const effectModelLoader = {
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Normal
+  },
+  test(l, e, t) {
+    return e.data && e.data.__neutrinoContext__ && e.data.__neutrinoContext__ instanceof Context;
+  },
+  async load(l, e, t) {
+    return await (await DOMAdapter.get().fetch(l)).text();
+  },
+  async testParse(l, e) {
+    return e.data && e.data.__neutrinoContext__ && e.data.__neutrinoContext__ instanceof Context;
+  },
+  async parse(l, e, t) {
+    return new Promise((r) => {
+      const n = e.data.__neutrinoContext__, o = new EffectModel(n, l, new AssetsTexturesLoader(t));
+      o.ready() ? r(o) : o.once("ready", () => {
+        r(o);
+      });
+    });
+  },
+  unload(l) {
+  }
+}, DATA_TEXTURE_UNIT = 0, META_TEXTURE_UNIT = 1, PARTICLE_TEXTURE_START_UNIT = 1, PARTICLE_TEXTURE_START_UNIT_GL1 = 2, FLOATS_PER_PARTICLE = 16, BYTES_PER_PARTICLE = FLOATS_PER_PARTICLE * 4, MAX_BATCHES = 64;
+class DrawBatch {
+  constructor() {
+    i(this, "blendMode", 0);
+    i(this, "startParticle", 0);
+    i(this, "numParticles", 0);
+    i(this, "numTextures", 0);
+    i(this, "glTextures", new Array(Context.MAX_BATCH_TEXTURES).fill(null));
+    i(this, "remaps", new Array(Context.MAX_BATCH_TEXTURES).fill(null));
+  }
+  reset() {
+    this.blendMode = 0, this.startParticle = 0, this.numParticles = 0, this.numTextures = 0;
+  }
+}
+class NeutrinoRenderer {
+  constructor() {
+    i(this, "_orthoMatrix", new Float32Array(16));
+    i(this, "_perspMatrix", new Float32Array(16));
+    i(this, "_vpMatrix", new Float32Array(16));
+    i(this, "_modelMatrix", new Float32Array(16));
+    i(this, "_projFrame", new Rectangle());
+    i(this, "_texSlotMap", /* @__PURE__ */ new Map());
+    i(this, "_batchPool");
+    i(this, "_batchCount", 0);
+    this._batchPool = [];
+    for (let e = 0; e < MAX_BATCHES; e++)
+      this._batchPool.push(new DrawBatch());
+  }
+  renderEffect(e, t, r, n, o, s) {
+    if (s === 0) return;
+    const a = t.gl, c = t.isWebGL1, U = e.texture, S = t.maxBatchTextures, C = r.effect.model.renderStyles, I = r.effect.model.materials, D = r.effectModel.textures, v = r.effectModel.texturesRemap, b = r.effect.particleDataView, w = c ? n.meta : null;
+    w && w.build(r.effect.particleDataUint32, s), this._batchCount = 0;
+    const m = this._texSlotMap;
+    for (; this._batchPool.length < o.length; )
+      this._batchPool.push(new DrawBatch());
+    let T = 0;
+    for (; T < o.length; ) {
+      const d = this._batchPool[this._batchCount];
+      d.reset(), d.blendMode = this._resolveBlend(o[T].blendMode, I), d.startParticle = o[T].startParticleIndex, m.clear();
+      let f = T;
+      for (; f < o.length && this._resolveBlend(o[f].blendMode, I) === d.blendMode; ) {
+        const g = C[o[f].renderStyleIndex].textureIndices[0];
+        if (!m.has(g)) {
+          if (m.size >= S) break;
+          const h = m.size;
+          m.set(g, h);
+          const p = D[g];
+          d.glTextures[h] = p ? U.getGlSource(p.source).texture : null, d.remaps[h] = v[g] || null, d.numTextures = h + 1;
+        }
+        const E = m.get(g), u = o[f];
+        if (w)
+          w.patchSlot(u.startParticleIndex, u.numParticles, E);
+        else
+          for (let h = 0; h < u.numParticles; h++) {
+            const p = (u.startParticleIndex + h) * BYTES_PER_PARTICLE, M = b.getUint32(p, !0);
+            b.setUint32(p, M & 4294967040 | E, !0);
+          }
+        d.numParticles += u.numParticles, f++;
+      }
+      this._batchCount++, T = f;
+    }
+    if (e.shader.resetState(), e.geometry.resetState(), e.state.resetState(), a.disable(a.DEPTH_TEST), a.disable(a.STENCIL_TEST), a.disable(a.SCISSOR_TEST), a.disable(a.CULL_FACE), a.depthMask(!1), a.colorMask(!0, !0, !0, !0), a.useProgram(t.shaderProgram), c) {
+      const d = n;
+      d.upload(s, DATA_TEXTURE_UNIT, META_TEXTURE_UNIT), a.uniform1i(t.uDataTexture, DATA_TEXTURE_UNIT), a.uniform1i(t.uMetaTexture, META_TEXTURE_UNIT), a.uniform2f(t.uDataTexSize, d.textureWidth, d.textureHeight);
+    } else
+      n.uploadAndBind(DATA_TEXTURE_UNIT), a.uniform1i(t.uDataTexture, DATA_TEXTURE_UNIT), a.uniform1i(t.uDataTextureWidth, n.textureWidth);
+    a.uniform3f(t.uCameraRight, 1, 0, 0), a.uniform3f(t.uCameraUp, 0, -1, 0), a.uniform3f(t.uCameraDir, 0, 0, -1);
+    const _ = e.renderTarget.viewport, x = e.renderTarget.renderTarget.resolution;
+    if (this._fillProjMatrix(this._orthoMatrix, e), r.projection) {
+      const d = this._projFrame;
+      d.x = 0, d.y = 0, d.width = _.width / x, d.height = _.height / x, r.projection.setScreenFrame(d), r.projection.writeMatrix(this._perspMatrix), this._mulMatrix(this._vpMatrix, this._orthoMatrix, this._perspMatrix), a.uniformMatrix4fv(t.uViewProjMatrix, !1, this._vpMatrix);
+    } else
+      a.uniformMatrix4fv(t.uViewProjMatrix, !1, this._orthoMatrix);
+    const B = _.height > 0 ? _.width / _.height : 1;
+    t.uViewportAspect && a.uniform1f(t.uViewportAspect, B), t.uWorldAlpha && a.uniform1f(t.uWorldAlpha, r.worldAlpha), this._fillModelMatrix(this._modelMatrix, r), a.uniformMatrix4fv(t.uModelMatrix, !1, this._modelMatrix), c ? (t.unbindVao(), a.bindBuffer(a.ARRAY_BUFFER, t.aIdBuffer), a.enableVertexAttribArray(t.aIdLocation), a.vertexAttribPointer(t.aIdLocation, 1, a.FLOAT, !1, 0, 0), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, t.indexBuffer)) : a.bindVertexArray(t.vao);
+    const P = c ? PARTICLE_TEXTURE_START_UNIT_GL1 : PARTICLE_TEXTURE_START_UNIT;
+    a.enable(a.BLEND);
+    for (let d = 0; d < this._batchCount; d++) {
+      const f = this._batchPool[d];
+      this._applyBlendMode(a, f.blendMode);
+      for (let u = 0; u < f.numTextures; u++) {
+        const h = P + u;
+        a.activeTexture(a.TEXTURE0 + h), a.bindTexture(a.TEXTURE_2D, f.glTextures[u]), a.uniform1i(t.uTextures[u], h);
+        const p = f.remaps[u];
+        p ? a.uniform4f(t.uTexRemaps[u], p.x, p.y, p.width, p.height) : a.uniform4f(t.uTexRemaps[u], 0, 0, 1, 1);
+      }
+      const g = f.startParticle * 6, E = f.numParticles * 6;
+      a.drawElements(
+        a.TRIANGLES,
+        E,
+        t.indexType,
+        g * (t.indexType === a.UNSIGNED_INT ? 4 : 2)
+      );
+    }
+    c ? (a.disableVertexAttribArray(t.aIdLocation), a.bindBuffer(a.ARRAY_BUFFER, null), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, null)) : a.bindVertexArray(null), a.useProgram(null);
+    const y = U._boundTextures;
+    if (y)
+      for (let d = 0; d < P + Context.MAX_BATCH_TEXTURES; d++)
+        y[d] = null;
+    e.shader.resetState(), e.geometry.resetState(), e.state.resetState();
+  }
+  // Resolve a renderStyle's compacted material INDEX to the real blend enum (0=Normal/
+  // 1=Add/2=Multiply) via materials[]. The runtime sets instruction.blendMode =
+  // renderStyles[rsi].materialIndex (system.js _renderStyleBlendModes), an INDEX into
+  // materials[], NOT the blend itself — without this deref a single-material effect
+  // (materialIndex 0) would always render as materials[0]'s slot 0 (Normal). Falls back to
+  // the raw value if materials is missing/out of range (mirror of cocos _resolveBlendMode).
+  _resolveBlend(e, t) {
+    return t && e >= 0 && e < t.length ? t[e] : e;
+  }
+  _applyBlendMode(e, t) {
+    switch (t) {
+      default:
+      case 0:
+        e.blendFuncSeparate(e.ONE, e.ONE_MINUS_SRC_ALPHA, e.ONE, e.ONE_MINUS_SRC_ALPHA);
+        break;
+      case 1:
+        e.blendFunc(e.ONE, e.ONE);
+        break;
+      case 2:
+        e.blendFunc(e.DST_COLOR, e.ONE_MINUS_SRC_ALPHA);
+        break;
+    }
+  }
+  _fillProjMatrix(e, t) {
+    const r = t.renderTarget.projectionMatrix;
+    e[0] = r.a, e[1] = r.b, e[2] = 0, e[3] = 0, e[4] = r.c, e[5] = r.d, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 0, e[11] = 0, e[12] = r.tx, e[13] = r.ty, e[14] = 0, e[15] = 1;
+  }
+  // Column-major 4x4 multiply: out = a * b. Preallocated outputs only.
+  _mulMatrix(e, t, r) {
+    for (let n = 0; n < 16; n += 4) {
+      const o = r[n], s = r[n + 1], a = r[n + 2], c = r[n + 3];
+      e[n] = t[0] * o + t[4] * s + t[8] * a + t[12] * c, e[n + 1] = t[1] * o + t[5] * s + t[9] * a + t[13] * c, e[n + 2] = t[2] * o + t[6] * s + t[10] * a + t[14] * c, e[n + 3] = t[3] * o + t[7] * s + t[11] * a + t[15] * c;
+    }
+  }
+  _fillModelMatrix(e, t) {
+    const r = t.worldRenderMatrix;
+    e[0] = r.a, e[1] = r.b, e[4] = r.c, e[5] = r.d, e[12] = r.tx, e[13] = r.ty, e[2] = 0, e[3] = 0, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 1, e[11] = 0, e[14] = 0, e[15] = 1;
+  }
+}
+class EffectPipe {
+  constructor(e) {
+    i(this, "renderer");
+    i(this, "_neutrinoRenderer", new NeutrinoRenderer());
+    this.renderer = e;
+  }
+  validateRenderable(e) {
+    return !0;
+  }
+  addRenderable(e, t) {
+    t.add(e);
+  }
+  updateRenderable(e) {
+  }
+  destroyRenderable(e) {
+  }
+  execute(e) {
+    if (!e.ready() || e._isInvisible()) return;
+    const t = e.ctx, r = e._dtm();
+    if (!t || !r) return;
+    e._prepareRender(), e.effect.construct([0, 0, -1]);
+    const n = e.effect.renderInstructions, o = n._totalParticles;
+    o !== 0 && (this._neutrinoRenderer.renderEffect(
+      this.renderer,
+      t,
+      e,
+      r,
+      n,
+      o
+    ), r.advance());
+  }
+  destroy() {
+  }
+}
+i(EffectPipe, "extension", {
+  type: [ExtensionType.WebGLPipes],
+  name: "neutrino"
+});
+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 textureWidth - from runtime (system.dataTextureWidth)
+   * @param textureHeight - from runtime (system.dataTextureHeight)
+   */
+  constructor(e, t, r, n) {
+    i(this, "textureWidth");
+    i(this, "textureHeight");
+    i(this, "_gl");
+    i(this, "_floatView");
+    i(this, "_textures", []);
+    i(this, "_currentIndex", 0);
+    const o = e.getParameter(e.MAX_TEXTURE_SIZE);
+    if (r > o || n > o)
+      throw new Error(
+        `NeutrinoParticles: data texture ${r}x${n} exceeds GL MAX_TEXTURE_SIZE (${o}). Reduce effect particle capacity.`
+      );
+    this._gl = e, this.textureWidth = r, this.textureHeight = n, this._floatView = new Float32Array(t.buffer, t.byteOffset, t.length);
+    for (let s = 0; s < RING_BUFFER_SIZE$1; s++) {
+      const a = e.createTexture();
+      e.bindTexture(e.TEXTURE_2D, a), 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,
+        r,
+        n,
+        0,
+        e.RGBA,
+        e.FLOAT,
+        null
+      ), this._textures.push(a);
+    }
+    e.bindTexture(e.TEXTURE_2D, null);
+  }
+  get currentTexture() {
+    return this._textures[this._currentIndex];
+  }
+  /** Bind the current texture to a unit and upload the latest particle data. */
+  uploadAndBind(e) {
+    const t = this._gl;
+    t.activeTexture(t.TEXTURE0 + e), t.bindTexture(t.TEXTURE_2D, this._textures[this._currentIndex]), t.pixelStorei(t.UNPACK_ALIGNMENT, 4), t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, !1), t.texSubImage2D(
+      t.TEXTURE_2D,
+      0,
+      0,
+      0,
+      this.textureWidth,
+      this.textureHeight,
+      t.RGBA,
+      t.FLOAT,
+      this._floatView
+    );
+  }
+  advance() {
+    this._currentIndex = (this._currentIndex + 1) % RING_BUFFER_SIZE$1;
+  }
+  destroy() {
+    const e = this._gl;
+    for (const t of this._textures)
+      t && e.deleteTexture(t);
+    this._textures = [];
+  }
+}
+class MetaTextureManager {
+  constructor(e, t) {
+    i(this, "bytes");
+    i(this, "_u32");
+    this.bytes = new Uint8Array(e * t * 4), this._u32 = new Uint32Array(this.bytes.buffer);
+  }
+  /** Repack the packed-u32 record fields for the first `numParticles` records. */
+  build(e, t) {
+    const r = this._u32;
+    for (let n = 0; n < t; n++) {
+      const o = n * 16, s = n * 4;
+      r[s] = e[o], r[s + 1] = e[o + 12], r[s + 2] = e[o + 13], r[s + 3] = e[o + 14];
+    }
+  }
+  /** Write the batch texture slot into byte0 of M0 (flags) per particle. */
+  patchSlot(e, t, r) {
+    const n = this.bytes;
+    let o = e * 16;
+    for (let s = 0; s < t; s++)
+      n[o] = r, o += 16;
+  }
+}
+const RING_BUFFER_SIZE = 3;
+class DataTextureManagerGL1 {
+  constructor(e, t, r, n) {
+    i(this, "textureWidth");
+    i(this, "textureHeight");
+    i(this, "meta");
+    i(this, "_gl");
+    i(this, "_floatView");
+    i(this, "_dataTextures", []);
+    i(this, "_metaTextures", []);
+    i(this, "_currentIndex", 0);
+    const o = e.getParameter(e.MAX_TEXTURE_SIZE);
+    if (r > o || n > o)
+      throw new Error(
+        `NeutrinoParticles: data texture ${r}x${n} exceeds GL MAX_TEXTURE_SIZE (${o}). Reduce effect particle capacity.`
+      );
+    if (r * n > 16777216)
+      throw new Error(
+        `NeutrinoParticles: data texture ${r}x${n} exceeds the WebGL1 render path texel cap (2^24). Reduce effect particle capacity.`
+      );
+    this._gl = e, this.textureWidth = r, this.textureHeight = n, this._floatView = new Float32Array(t.buffer, t.byteOffset, t.length), this.meta = new MetaTextureManager(r, n);
+    const s = e.getParameter(e.ACTIVE_TEXTURE);
+    e.activeTexture(e.TEXTURE0);
+    const a = e.getParameter(e.TEXTURE_BINDING_2D);
+    for (let c = 0; c < RING_BUFFER_SIZE; c++)
+      this._dataTextures.push(this._createTexture(e.FLOAT)), this._metaTextures.push(this._createTexture(e.UNSIGNED_BYTE));
+    e.bindTexture(e.TEXTURE_2D, a), e.activeTexture(s);
+  }
+  get currentDataTexture() {
+    return this._dataTextures[this._currentIndex];
+  }
+  get currentMetaTexture() {
+    return this._metaTextures[this._currentIndex];
+  }
+  /**
+   * Upload the rows covering `numParticles` into the current ring textures,
+   * leaving them bound to `dataUnit` / `metaUnit`. The caller invalidates
+   * PIXI's bound-texture bookkeeping for those units.
+   */
+  upload(e, t, r) {
+    const n = this._gl, o = this.textureWidth, s = Math.min(this.textureHeight, Math.ceil(e * 4 / o));
+    if (s === 0) return;
+    const a = s * o * 4;
+    n.pixelStorei(n.UNPACK_FLIP_Y_WEBGL, !1), n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), n.pixelStorei(n.UNPACK_ALIGNMENT, 4), n.activeTexture(n.TEXTURE0 + t), n.bindTexture(n.TEXTURE_2D, this.currentDataTexture), n.texSubImage2D(
+      n.TEXTURE_2D,
+      0,
+      0,
+      0,
+      o,
+      s,
+      n.RGBA,
+      n.FLOAT,
+      this._floatView.subarray(0, a)
+    ), n.activeTexture(n.TEXTURE0 + r), n.bindTexture(n.TEXTURE_2D, this.currentMetaTexture), n.texSubImage2D(
+      n.TEXTURE_2D,
+      0,
+      0,
+      0,
+      o,
+      s,
+      n.RGBA,
+      n.UNSIGNED_BYTE,
+      this.meta.bytes.subarray(0, a)
+    );
+  }
+  advance() {
+    this._currentIndex = (this._currentIndex + 1) % RING_BUFFER_SIZE;
+  }
+  destroy() {
+    const e = this._gl;
+    for (const t of this._dataTextures) e.deleteTexture(t);
+    for (const t of this._metaTextures) e.deleteTexture(t);
+    this._dataTextures = [], this._metaTextures = [];
+  }
+  _createTexture(e) {
+    const t = this._gl, r = t.createTexture();
+    return t.bindTexture(t.TEXTURE_2D, r), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.RGBA,
+      this.textureWidth,
+      this.textureHeight,
+      0,
+      t.RGBA,
+      e,
+      null
+    ), r;
+  }
+}
+var Pause = /* @__PURE__ */ ((l) => (l[l.NO = 0] = "NO", l[l.BEFORE_UPDATE_OR_RENDER = 1] = "BEFORE_UPDATE_OR_RENDER", l[l.YES = 2] = "YES", l))(Pause || {});
+const emptyBounds = new Bounds(0, 0, 0, 0);
+class Effect extends ViewContainer {
+  constructor(t, r) {
+    super({});
+    i(this, "renderPipeId", "neutrino");
+    i(this, "batched", !1);
+    i(this, "ctx");
+    i(this, "effectModel");
+    i(this, "effect");
+    i(this, "baseParent");
+    i(this, "projection");
+    i(this, "positionZ");
+    i(this, "scaleZ");
+    /** World transform actually fed to the renderer's model matrix (2x3). */
+    i(this, "worldRenderMatrix", { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 });
+    i(this, "_worldPosition", new Point(0, 0));
+    i(this, "_worldRotationDegree", 0);
+    i(this, "_worldScale", new Point(1, 1));
+    i(this, "_dataTextureManager");
+    i(this, "_unpauseOnUpdateRender");
+    i(this, "_startupOptions");
+    i(this, "_inited", !1);
+    i(this, "_ready", !1);
+    const n = Object.assign({
+      position: [0, 0, 0],
+      rotation: 0,
+      scale: [1, 1, 1],
+      pause: 1,
+      generatorsPaused: !1,
+      baseParent: void 0,
+      projection: void 0,
+      autoInit: !0
+    }, r);
+    this.ctx = t.ctx, this.effectModel = t, this.baseParent = n.baseParent, this.projection = n.projection, this.position.set(n.position[0], n.position[1]), this.positionZ = n.position[2], this.rotation = n.rotation, this.scale.x = n.scale[0], this.scale.y = n.scale[1], this.scaleZ = n.scale[2], this._startupOptions = {
+      paused: n.pause !== 0,
+      generatorsPaused: n.generatorsPaused
+    }, this._unpauseOnUpdateRender = n.pause === 1, n.autoInit && this.init(), this._updateWorldTransform();
+  }
+  get bounds() {
+    return emptyBounds;
+  }
+  updateBounds() {
+  }
+  init() {
+    this._inited || (this._inited = !0, this.effectModel.ready() ? this._onEffectReady() : this.effectModel.once("ready", this._onEffectReady, this));
+  }
+  ready() {
+    return this._ready;
+  }
+  update(t) {
+    this.ready() && (this._checkUnpauseOnUpdateRender(), this._updateWorldTransform(), this.effect && (this.effect.update(
+      t,
+      this._scaledPosition(),
+      this.ctx.neutrino.axisangle2quat_([0, 0, 1], this._worldRotationDegree)
+    ), this.onViewUpdate()));
+  }
+  restart(t, r) {
+    t && (this.position.x = t[0], this.position.y = t[1], this.positionZ = t[2]), r && (this.rotation = r), this._updateWorldTransform(), this.effect.restart(
+      this._scaledPosition(),
+      r ? this.ctx.neutrino.axisangle2quat_([0, 0, 1], this._worldRotationDegree) : void 0
+    ), this.onViewUpdate();
+  }
+  resetPosition(t, r) {
+    t && (this.position.x = t[0], this.position.y = t[1], this.positionZ = t[2]), r && (this.rotation = r), this._updateWorldTransform(), this.effect.resetPosition(
+      this._scaledPosition(),
+      r ? this.ctx.neutrino.axisangle2quat_([0, 0, 1], this._worldRotationDegree) : void 0
+    ), this.onViewUpdate();
+  }
+  pause() {
+    this.ready() ? this.effect.pauseAllEmitters() : this._startupOptions.paused = !0;
+  }
+  unpause() {
+    this.ready() ? this.effect.unpauseAllEmitters() : this._startupOptions.paused = !1;
+  }
+  pauseGenerators() {
+    this.ready() ? this.effect.pauseGeneratorsInAllEmitters() : this._startupOptions.generatorsPaused = !0;
+  }
+  unpauseGenerators() {
+    this.ready() ? this.effect.unpauseGeneratorsInAllEmitters() : this._startupOptions.generatorsPaused = !1;
+  }
+  setPropertyInAllEmitters(t, r) {
+    this.effect.setPropertyInAllEmitters(t, r), this.onViewUpdate();
+  }
+  getNumParticles() {
+    return this.effect ? this.effect.getNumParticles() : 0;
+  }
+  /** @internal — called by EffectPipe during the render pass. */
+  _dtm() {
+    return this._dataTextureManager;
+  }
+  /**
+   * @internal — called by EffectPipe before constructing the frame.
+   * Auto-unpauses an effect whose first interaction is a render rather than an
+   * update (Pause.BEFORE_UPDATE_OR_RENDER), then refreshes the world transform
+   * from the live scene graph so a parent transform change since the last
+   * update() is reflected this frame (mirrors pixi7, which reads
+   * baseParent.worldTransform live in its render plugin).
+   */
+  _prepareRender() {
+    this._checkUnpauseOnUpdateRender(), this._updateWorldTransform();
+  }
+  /**
+   * @internal — resolved world alpha fed to the renderer (uWorldAlpha).
+   * groupAlpha only accumulates alpha WITHIN the effect's render group; the
+   * cross-group factor lives on parentRenderGroup.worldAlpha, so multiply both
+   * to honour transparency set on a render-group ancestor.
+   */
+  get worldAlpha() {
+    var t;
+    return this.groupAlpha * (((t = this.parentRenderGroup) == null ? void 0 : t.worldAlpha) ?? 1);
+  }
+  /**
+   * @internal — called by EffectPipe. True when the effect is fully
+   * transparent, in which case the draw is skipped entirely (mirrors the phaser
+   * adapter and PIXI's scene-graph cull of a zero-alpha container). Partial
+   * alpha is applied in the shader via uWorldAlpha (see {@link worldAlpha}).
+   */
+  _isInvisible() {
+    return this.worldAlpha <= 0;
+  }
+  destroy(t) {
+    this.effect || this.effectModel.removeListener("ready", this._onEffectReady, this), this._dataTextureManager && (this._dataTextureManager.destroy(), this._dataTextureManager = void 0), super.destroy(t);
+  }
+  _onEffectReady() {
+    this._updateWorldTransform(), this.effect = this.effectModel.effectModel.createInstance(
+      this._scaledPosition(),
+      this.ctx.neutrino.axisangle2quat_([0, 0, 1], this._worldRotationDegree),
+      this._startupOptions
+    ), this._dataTextureManager = this.ctx.isWebGL1 ? new DataTextureManagerGL1(
+      this.ctx.gl,
+      this.effect.particleDataUint32,
+      this.effect.dataTextureWidth,
+      this.effect.dataTextureHeight
+    ) : new DataTextureManager(
+      this.ctx.gl,
+      this.effect.particleDataUint32,
+      this.effect.dataTextureWidth,
+      this.effect.dataTextureHeight
+    ), this.ctx.ensureIndexBuffer(this.effectModel.effectModel.totalParticles), this._ready = !0, this.emit("ready", this);
+  }
+  _scaledPosition() {
+    return [
+      this._worldScale.x !== 0 ? this._worldPosition.x / this._worldScale.x : 0,
+      this._worldScale.y !== 0 ? this._worldPosition.y / this._worldScale.y : 0,
+      this.scaleZ !== 0 ? this.positionZ / this.scaleZ : 0
+    ];
+  }
+  _getRenderGroupContainer(t) {
+    return t.renderGroup || !t.parent ? t : this._getRenderGroupContainer(t.parent);
+  }
+  _updateWorldTransform() {
+    const t = new Point(0, 0), r = new Point(1, 0), n = new Point(0, 1), o = this.baseParent || this._getRenderGroupContainer(this);
+    this._worldPosition = o.toLocal(t, this);
+    const s = o.toLocal(r, this), a = o.toLocal(n, this);
+    if (s.x -= this._worldPosition.x, s.y -= this._worldPosition.y, a.x -= this._worldPosition.x, a.y -= this._worldPosition.y, this._worldScale = new Point(
+      Math.sqrt(s.x * s.x + s.y * s.y),
+      Math.sqrt(a.x * a.x + a.y * a.y)
+    ), this._worldRotationDegree = this._calcWorldRotation(this) / Math.PI * 180 % 360, this.baseParent) {
+      const c = this.baseParent.worldTransform;
+      this.worldRenderMatrix = { a: c.a, b: c.b, c: c.c, d: c.d, tx: c.tx, ty: c.ty };
+    } else
+      this.worldRenderMatrix = {
+        a: this._worldScale.x,
+        b: 0,
+        c: 0,
+        d: this._worldScale.y,
+        tx: 0,
+        ty: 0
+      };
+  }
+  _calcWorldRotation(t) {
+    return t.parent && t.parent != this.baseParent ? t.rotation + this._calcWorldRotation(t.parent) : t.rotation;
+  }
+  _checkUnpauseOnUpdateRender() {
+    this._unpauseOnUpdateRender && (this.resetPosition(), this.unpause(), this._unpauseOnUpdateRender = !1);
+  }
+}
+class PerspectiveProjection {
+  constructor(e) {
+    i(this, "_angleTan", 0);
+    i(this, "_screenWidth", 0);
+    i(this, "_screenPosX", 0);
+    i(this, "_screenPosY", 0);
+    i(this, "_z", 0);
+    i(this, "_near", 0);
+    this.horizontalAngle = e;
+  }
+  set horizontalAngle(e) {
+    this._angleTan = Math.tan(e * 0.5 / 180 * Math.PI);
+  }
+  /**
+  * Changes horizontal angle of the projection.
+  * 
+  * @param {number} value Angle in degrees.
+  */
+  /**
+   * Sets rendering frame for the projection.
+   * 
+   * This method shouldn't be called manually when the class is used with effects. It is called
+   * on every render call for each effect automatically.
+   * @param {PIXI.Rectangle} frame Rendering frame.
+   */
+  setScreenFrame(e) {
+    this._screenWidth = e.width, this._screenPosX = e.x + e.width * 0.5, this._screenPosY = e.y + e.height * 0.5, this._z = this._screenWidth * 0.5 / this._angleTan, this._near = this._z * 0.99;
+  }
+  /**
+   * Transforms 3D point accordingly to the projection.
+   * 
+   * Basically, point's position X and Y components are simply scaled dependently on Z position. The method
+   * is used in WebGL and Canvas rendering.
+   * 
+   * @param {Array} out [x, y] Transformed position.
+   * @param {Array} pos [x, y, z] Untransformed input vertex position.
+   * @returns false, if a particle is on the back side of the camera and should be discarded. Otherwise - true.
+   */
+  transformPosition(e, t) {
+    if (t[2] > this._near)
+      return !1;
+    const r = this._getScale(t);
+    return e[0] = (t[0] - this._screenPosX) * r + this._screenPosX, e[1] = (t[1] - this._screenPosY) * r + this._screenPosY, !0;
+  }
+  /**
+   * Transforms 2D size of a particle accordingly to the projection.
+   * 
+   * Basically, size is simply scaled dependently on Z position of a particle. The method is used
+   * only in Canvas rendering.
+   * 
+   * @param {Array} outSize [width, height] Transformed size.
+   * @param {Array} pos [x, y, z] Untransformed particle position.
+   * @param {Array} size [width, height] Untransformed size.
+   */
+  transformSize(e, t, r) {
+    const n = this._getScale(t);
+    e[0] = r[0] * n, e[1] = r[1] * n;
+  }
+  _getScale(e) {
+    return this._z / (this._z - e[2]);
+  }
+  /**
+   * Writes the projection as a 4x4 column-major matrix operating in screen
+   * space, for the GPU render path. Homogeneous equivalent of
+   * transformPosition(): clip.xy = p.xy - center * (p.z / z),
+   * clip.w = 1 - p.z / z; the z row is zeroed (no depth on this path).
+   * setScreenFrame() must have been called before.
+   *
+   * @param {Float32Array} out 16-element column-major output matrix.
+   */
+  writeMatrix(e) {
+    const t = this._z, r = Number.isFinite(t) && t > 0 ? 1 / t : 0;
+    e.fill(0), e[0] = 1, e[5] = 1, e[8] = -this._screenPosX * r, e[9] = -this._screenPosY * r, e[11] = -r, e[15] = 1;
+  }
+}
+function registerPlugins() {
+  extensions.add(ApplicationPlugin), extensions.add(effectModelLoader), extensions.add(EffectPipe);
+}
+function unregisterPlugins() {
+  extensions.remove(ApplicationPlugin), extensions.remove(effectModelLoader), extensions.remove(EffectPipe);
+}
+registerPlugins();
+export {
+  AbstractTexturesLoader,
+  ApplicationPlugin,
+  AssetsTexturesLoader,
+  Context,
+  DataTextureManager,
+  DefaultAssetsTexturesLoader,
+  Effect,
+  EffectModel,
+  EffectPipe,
+  NeutrinoRenderer,
+  Pause,
+  PerspectiveProjection,
+  effectModelLoader,
+  registerPlugins,
+  unregisterPlugins
+};
+//# sourceMappingURL=neutrinoparticles.js-v1.1-pixi8.es.js.map