@neutrinoparticles/js-v1.1-phaser 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## CurrentVersion
+
+- Initial Phaser 3 integration for the JS v1.1 export format (GPU geometry construction, data-texture renderer). Works on WebGL2 and, automatically, on WebGL1 contexts with float vertex textures — Phaser's default WebGL1 context works out of the box.
+- Fixed strip texture seams: a ribbon whose atlas texture repeats along its length no longer shows a muddy "chewed" column at tile junctions when the texture has mipmaps (WebGL2).

package/README.md

@@ -0,0 +1,212 @@
+# @neutrinoparticles/js-v1.1-phaser
+
+Phaser 3 integration for [NeutrinoParticles](https://neutrinoparticles.com/) real-time particle effects (format **v1.1**).
+
+## Installation
+
+```bash
+npm install @neutrinoparticles/js-v1.1-phaser
+```
+
+The core runtime (`@neutrinoparticles/js-v1.1`) is installed automatically as a dependency.
+
+**Peer dependency:** Phaser 3.60+
+
+## Requirements
+
+The v1.1 renderer reconstructs particle geometry on the GPU. It works on:
+
+- **WebGL2** — the primary path;
+- **WebGL1** (the Phaser 3 default) — supported automatically on contexts
+  that provide `OES_texture_float`, at least 2 vertex texture image units,
+  `highp` float in fragment shaders, and pass a one-time
+  vertex-float-texture smoke test at startup. The renderer detects the
+  context version and picks the path by itself — no configuration needed,
+  a plain `new Phaser.Game({ type: Phaser.WEBGL })` works out of the box.
+
+On a WebGL1 context missing those capabilities, the plugin's `init` throws an
+`Error` naming the missing capability (for example
+`NeutrinoParticles (js-v1.1): WebGL1 context lacks OES_texture_float; WebGL2
+or WebGL1 with vertex float textures is required.`).
+
+### WebGL2 vs WebGL1: which to use
+
+**Prefer WebGL2 whenever it is available** — it is the faster and leaner
+path. WebGL1 is a compatibility fallback for devices and embeds that cannot
+create a WebGL2 context. Rough comparison of the same effect on the two
+paths:
+
+- **Rendering speed:** identical at typical particle counts (up to ~20k
+  live particles the difference is not measurable); on very heavy effects
+  (~100k live particles) WebGL1 costs roughly 10% more render time per
+  frame — the vertex shader does almost twice as many texture reads and
+  extra math to unpack data that WebGL2 reads directly.
+- **GPU memory:** WebGL1 uses about 25% more per effect (an extra byte
+  texture carries the data WebGL1 shaders cannot decode from the float
+  texture).
+- **Features/visuals:** identical — both paths render the same effects with
+  full parity (quads and ribbons).
+
+Phaser 3 creates a **WebGL1** context by default. To run on the faster
+WebGL2 path, create a WebGL2 context yourself and hand it to the game via
+the `context` option — WebGL2 is a superset of WebGL1, so Phaser's own
+rendering keeps working:
+
+```javascript
+const canvas = document.createElement('canvas');
+canvas.width = 800;
+canvas.height = 600;
+document.body.appendChild(canvas);
+const gl2 = canvas.getContext('webgl2');
+
+new Phaser.Game({
+  type: Phaser.WEBGL,
+  canvas: canvas,
+  context: gl2, // hand the WebGL2 context to Phaser
+  width: 800,
+  height: 600,
+  // ...
+});
+```
+
+## Export Target in Editor
+
+In the NeutrinoParticles Editor, set the export target to **JavaScript v1.1**.
+
+Export the effect with **"For XHR Request"** format. After export you get a `.js`
+file (e.g. `my_effect.js`) containing the effect model.
+
+## Quick Start
+
+```javascript
+import Phaser from 'phaser'
+import { GamePlugin } from '@neutrinoparticles/js-v1.1-phaser'
+
+class GameScene extends Phaser.Scene {
+  constructor() {
+    super({ key: 'GameScene' });
+  }
+
+  preload() {
+    // Load exported effect (must be exported "For XHR Request")
+    this.load.neutrino('myEffect', 'export_js/my_effect.js');
+  }
+
+  create() {
+    // Get effect model from cache (created by the loader)
+    const effectModel = this.cache.binary.get('myEffect');
+
+    // Create effect instance
+    this.effect = this.add.neutrino(effectModel, {
+      position: [this.cameras.main.centerX, this.cameras.main.centerY, 0]
+    });
+  }
+}
+
+new Phaser.Game({
+  type: Phaser.WEBGL, // Phaser's default WebGL1 context works out of the box;
+                      // see "WebGL2 vs WebGL1" above for the faster WebGL2 setup
+  width: 800,
+  height: 600,
+  scene: GameScene,
+  plugins: {
+    global: [{
+      key: 'neutrino',
+      plugin: GamePlugin,
+      start: true,
+      data: {
+        texturesBasePath: 'textures/',
+        generateNoise: true
+      }
+    }]
+  }
+});
+```
+
+For plain `<script>` tags (no bundler), reference the plugin as
+`PhaserNeutrino.GamePlugin` and include the UMD builds of both
+`@neutrinoparticles/js-v1.1` and `@neutrinoparticles/js-v1.1-phaser`.
+
+## How It Works
+
+`scene.load.neutrino(key, url)` fetches the exported `.js` file via XHR and
+creates an effect model internally. The model is then available via
+`this.cache.binary.get(key)`. Use `this.add.neutrino(model, options)` to create
+an effect instance that auto-updates and renders as part of the Phaser scene.
+
+## Instant Position Change (Teleporting)
+
+Moving the effect via position creates a smooth trail of particles. To instantly teleport the effect without a trail:
+
+```javascript
+effect.resetPosition({ position: [newX, newY, 0] });
+
+// With new angle
+effect.resetPosition({ position: [newX, newY, 0], angle: 45 }); // degrees
+```
+
+## Restart
+
+Restart destroys all existing particles and starts the effect from scratch:
+
+```javascript
+effect.restart({ position: [newX, newY, 0] });
+```
+
+## Pause
+
+**Full pause** — all particles freeze, nothing is generated:
+
+```javascript
+effect.pause();
+effect.unpause();
+```
+
+**Generators pause** — existing particles continue to live, but no new particles are created:
+
+```javascript
+effect.pauseGenerators();
+effect.unpauseGenerators();
+```
+
+Set the initial pause state in the constructor:
+
+```javascript
+import { Pause } from '@neutrinoparticles/js-v1.1-phaser'
+
+const effect = this.add.neutrino(effectModel, {
+  position: [400, 300, 0],
+  pause: Pause.YES // starts paused
+});
+// ...later:
+effect.unpause();
+```
+
+## Emitter Properties
+
+Control exposed emitter properties at runtime. Properties are defined in Emitter Guide or Emitter Scheme in the Editor.
+
+```javascript
+effect.setPropertyInAllEmitters('MyParticlesPerSecond', 100);
+effect.setPropertyInAllEmitters('MyColor', [1.0, 0.5, 0.2]);
+```
+
+## Number of Particles
+
+```javascript
+const numParticles = effect.getNumParticles();
+```
+
+## Common Issues
+
+- **`Error: ... WebGL1 context lacks <capability>` at startup:** the (rare) WebGL1 context does not support the render technique — see [Requirements](#requirements). Running on a WebGL2 context (the `context` game option) lifts the requirement.
+- **No particles visible:** Make sure the export target in the editor is set to JavaScript v1.1. Verify `texturesBasePath` points to the correct textures directory.
+- **Turbulence not working:** Set `generateNoise: true` in the plugin config, or call the plugin's `generateNoise()` before creating effects that use noise.
+
+## Documentation
+
+Full documentation at [neutrinoparticles.com](https://neutrinoparticles.com/en/docs/199).
+
+## License
+
+Copyright (c) Yurii Miroshnyk. All rights reserved.

package/dist/DataTextureManager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Manages a small ring of RGBA32F WebGL textures that hold the runtime's flat
+ * particle data buffer. Each frame the current texture is re-uploaded (zero-copy
+ * from the runtime-owned Uint32Array via a Float32 view) and the ring advances,
+ * which avoids GPU pipeline stalls from re-uploading into a texture still in use.
+ *
+ * Unlike the pixi7 adapter this owns raw GL textures directly (no PIXI texture
+ * system), so the exact same class works for both the PIXI v8 and Phaser
+ * integrations, which both do their own raw WebGL2 draw.
+ */
+export declare class DataTextureManager {
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    private readonly _gl;
+    private readonly _floatView;
+    private _textures;
+    private _currentIndex;
+    /**
+     * @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(gl: WebGL2RenderingContext, data: Uint32Array, textureWidth: number, textureHeight: number);
+    get currentTexture(): WebGLTexture;
+    /** Bind the current texture to a unit and upload the latest particle data. */
+    uploadAndBind(unit: number): void;
+    advance(): void;
+    destroy(): void;
+}

package/dist/Effect.d.ts

@@ -0,0 +1,76 @@
+import Phaser from 'phaser';
+import { Pause, Vec2, Vec3 } from './types';
+import { GamePlugin } from './GamePlugin';
+import { EffectModel } from './EffectModel';
+import { NeutrinoSystem } from './types';
+export interface EffectOptions {
+    position?: Vec3;
+    angle?: number;
+    scale?: number;
+    pause?: Pause;
+    generatorsPaused?: boolean;
+}
+/**
+ * A NeutrinoParticles effect on a Phaser scene (JS v1.1 runtime).
+ *
+ * Simulation runs in preUpdate(); rendering happens in renderWebGL() via a raw
+ * WebGL data-texture draw (WebGL2 or the WebGL1 variant, chosen by the shared
+ * NeutrinoContext). Phaser's active pipeline is flushed before and rebound
+ * after the draw so its state machine stays consistent.
+ */
+export declare class Effect extends Phaser.GameObjects.GameObject {
+    gamePlugin: GamePlugin;
+    effectModel: EffectModel;
+    effect: NeutrinoSystem | null;
+    x: number;
+    y: number;
+    z: number;
+    angle: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    scrollFactorX: number;
+    scrollFactorY: number;
+    alpha: number;
+    depth: number;
+    blendMode: number;
+    private _dataTextureManager;
+    private _worldPosition;
+    private _worldScaledPosition;
+    private _worldRotation;
+    private _worldScale;
+    private _tempMatrix1;
+    private _tempMatrix2;
+    private _unpauseOnUpdateRender;
+    private _glTexturesScratch;
+    constructor(effectModel: EffectModel, scene: Phaser.Scene, options?: EffectOptions);
+    get ready(): boolean;
+    preUpdate(_time: number, ms: number): void;
+    renderWebGL(renderer: Phaser.Renderer.WebGL.WebGLRenderer, _src: Effect, camera: Phaser.Cameras.Scene2D.Camera): void;
+    restart(options?: {
+        position?: Vec3;
+        angle?: number;
+        rotation?: number;
+    }): void;
+    resetPosition(options?: {
+        position?: Vec3;
+        angle?: number;
+        rotation?: number;
+    }): void;
+    pause(): void;
+    unpause(): void;
+    get paused(): boolean;
+    pauseGenerators(): void;
+    unpauseGenerators(): void;
+    get generatorsPaused(): boolean;
+    setPropertyInAllEmitters(name: string, value: Vec3 | Vec2 | number): void;
+    getNumParticles(): number;
+    setScrollFactor(x: number, y?: number): this;
+    setAlpha(topLeft?: number, _topRight?: number, _bottomLeft?: number, _bottomRight?: number): this;
+    destroy(fromScene?: boolean): void;
+    private _applyTransformOptions;
+    private _updateWorldTransform;
+    private _renderPosition;
+    private _renderRotation;
+    private _checkUnpauseOnUpdateRender;
+}

package/dist/EffectModel.d.ts

@@ -0,0 +1,27 @@
+import Phaser from 'phaser';
+import { GamePlugin } from './GamePlugin';
+import { NeutrinoEffectModel, NeutrinoSubRect } from './types';
+/**
+ * Wraps a neutrinoparticles.js v1.1 effect model for Phaser. Loads textures from
+ * standalone files or atlases via Phaser's loader, and computes atlas UV remaps
+ * as plain {x,y,width,height} objects (the v1.1 renderer reads them directly).
+ */
+export declare class EffectModel {
+    readonly gamePlugin: GamePlugin;
+    readonly scene: Phaser.Scene;
+    readonly effectModel: NeutrinoEffectModel;
+    textureFrames: Array<Phaser.Textures.Frame | null>;
+    texturesRemap: Array<NeutrinoSubRect | null>;
+    private _numTexturesToLoadLeft;
+    constructor(scene: Phaser.Scene, scriptText: string, options?: {
+        atlases?: string[];
+    });
+    get ready(): boolean;
+    /** Raw WebGL texture handle for a given texture index (or null). */
+    glTexture(index: number): WebGLTexture | null;
+    private _startLoadTextures;
+    private _findFrameInAtlases;
+    private _onTextureLoaded;
+    private _fullCover;
+    private _initTexturesRemapIfNeeded;
+}

package/dist/File.d.ts

@@ -0,0 +1,18 @@
+import Phaser from 'phaser';
+export interface NeutrinoFileConfig {
+    key: string;
+    url: string;
+    options?: {
+        atlases?: string[];
+    };
+    xhrSettings?: Phaser.Types.Loader.XHRSettingsObject;
+}
+/**
+ * Custom Phaser loader file type for NeutrinoParticles effects (.js export).
+ * Parses the exported source into an {@link EffectModel} stored in the binary cache.
+ */
+export declare class NeutrinoFile extends Phaser.Loader.File {
+    private _options?;
+    constructor(loader: Phaser.Loader.LoaderPlugin, config: NeutrinoFileConfig);
+    onProcess(): void;
+}

package/dist/GamePlugin.d.ts

@@ -0,0 +1,27 @@
+import Phaser from 'phaser';
+import { NeutrinoContext } from './NeutrinoContext';
+export interface GamePluginOptions {
+    texturesBasePath?: string;
+    generateNoise?: boolean;
+}
+/**
+ * Main NeutrinoParticles plugin for Phaser (JS v1.1 runtime).
+ *
+ * Owns the shared {@link NeutrinoContext} (shader/index-buffer GL state) and
+ * the neutrino simulation context, and manages noise generation. A WebGL
+ * renderer is required — the v1.1 data-texture renderer has no Canvas
+ * fallback. Both WebGL2 and WebGL1 contexts are supported; the render path is
+ * selected automatically by {@link NeutrinoContext}.
+ */
+export declare class GamePlugin extends Phaser.Plugins.BasePlugin {
+    game: Phaser.Game;
+    neutrino: any;
+    ctx: NeutrinoContext;
+    texturesBasePath: string;
+    init(options?: GamePluginOptions): void;
+    start(): void;
+    stop(): void;
+    destroy(): void;
+    loadNoise(path: string, success?: () => void, fail?: () => void): void;
+    generateNoise(): void;
+}

package/dist/NeutrinoContext.d.ts

@@ -0,0 +1,88 @@
+import { NeutrinoRuntimeContext as INeutrinoContext } from './types';
+/**
+ * Engine-agnostic WebGL state for the NeutrinoParticles data-texture renderer:
+ * the shader program, a static quad index buffer + VAO (WebGL2) or aId vertex
+ * stream (WebGL1), and uniform locations.
+ *
+ * This is the Phaser counterpart of the pixi adapters' Context, but it holds no
+ * reference to a host renderer — it works purely off a WebGL context. Owned by
+ * {@link GamePlugin} and shared by every effect in the game.
+ *
+ * The render path is selected automatically (TDD_js-v1.1-webgl1.md): a WebGL2
+ * context uses the texelFetch/gl_VertexID renderer unchanged; a WebGL1 context
+ * with the required capabilities (probed here, §4.2) uses the two-texture +
+ * static-aId variant; anything else throws a capability-specific Error.
+ */
+export declare class NeutrinoContext {
+    readonly neutrino: INeutrinoContext;
+    readonly gl: WebGL2RenderingContext;
+    private _shaderProgram;
+    private _indexBuffer;
+    private _dummyVB;
+    private _indexBufferCapacity;
+    private _vao;
+    private _isWebGL1;
+    private _maxBatchTextures;
+    private _hasElementIndexUint;
+    private _vaoExt;
+    private _aIdBuffer;
+    private _aIdLocation;
+    static readonly MAX_BATCH_TEXTURES = 8;
+    private _uDataTexture;
+    private _uDataTextureWidth;
+    private _uMetaTexture;
+    private _uDataTexSize;
+    private _uCameraRight;
+    private _uCameraUp;
+    private _uCameraDir;
+    private _uViewProjMatrix;
+    private _uModelMatrix;
+    private _uViewportAspect;
+    private _uWorldAlpha;
+    private _uTextures;
+    private _uTexRemaps;
+    private _noiseInitialized;
+    constructor(gl: WebGL2RenderingContext, neutrino: INeutrinoContext);
+    initializeNoise(path: string, success: () => void, fail: () => void): void;
+    generateNoise(): void;
+    get shaderProgram(): WebGLProgram;
+    get isWebGL1(): boolean;
+    /**
+     * 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(): number;
+    get uDataTexture(): WebGLUniformLocation | null;
+    get uDataTextureWidth(): WebGLUniformLocation | null;
+    get uMetaTexture(): WebGLUniformLocation | null;
+    get uDataTexSize(): WebGLUniformLocation | null;
+    get uCameraRight(): WebGLUniformLocation | null;
+    get uCameraUp(): WebGLUniformLocation | null;
+    get uCameraDir(): WebGLUniformLocation | null;
+    get uViewProjMatrix(): WebGLUniformLocation | null;
+    get uModelMatrix(): WebGLUniformLocation | null;
+    get uViewportAspect(): WebGLUniformLocation | null;
+    get uWorldAlpha(): WebGLUniformLocation | null;
+    get uTextures(): (WebGLUniformLocation | null)[];
+    get uTexRemaps(): (WebGLUniformLocation | null)[];
+    ensureIndexBuffer(maxParticles: number): void;
+    get vao(): WebGLVertexArrayObject;
+    get indexBuffer(): WebGLBuffer;
+    get aIdBuffer(): WebGLBuffer;
+    get aIdLocation(): number;
+    get indexType(): number;
+    /** Unbind any VAO (incl. OES on WebGL1) before raw attribute setup. */
+    unbindVao(): void;
+    destroy(): void;
+    private _probeWebGL1Capabilities;
+    /**
+     * 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.
+     */
+    private _smokeTestVertexTextureFetch;
+    private _initShader;
+    private _compileShader;
+}

package/dist/NeutrinoRenderer.d.ts

@@ -0,0 +1,54 @@
+import { NeutrinoContext } from "./NeutrinoContext";
+import { DataTextureManager } from "./DataTextureManager";
+import { DataTextureManagerGL1 } from "./gl1/DataTextureManagerGL1";
+import { NeutrinoSubRect } from "./types";
+export interface RenderParams {
+    /** Effect world transform (2x3) already including world scale. */
+    model: {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        tx: number;
+        ty: number;
+    };
+    /** Canvas pixel dimensions, for the ortho projection. */
+    viewportWidth: number;
+    viewportHeight: number;
+    /** Camera scroll (subtracted in pixel space) and zoom. */
+    scrollX: number;
+    scrollY: number;
+    zoom: number;
+    /** Host scene-graph world alpha, multiplied into each particle's alpha. */
+    worldAlpha: number;
+    /** Per-particle GL textures (one per render-style texture index). */
+    glTextures: (WebGLTexture | null)[];
+    remaps: Array<NeutrinoSubRect | null>;
+    renderStyles: Array<{
+        materialIndex: number;
+        textureIndices: number[];
+    }>;
+    materials: number[];
+}
+/**
+ * Raw WebGL data-texture renderer for the Phaser integration.
+ *
+ * Mirrors the pixi adapters: builds blend-mode batches (≤maxBatchTextures each),
+ * patches the per-particle texture-slot byte, uploads the data texture and draws
+ * each batch with gl.drawElements. On WebGL1 the u32-packed fields travel via an
+ * RGBA8 meta texture and the slot patch goes there instead of the float buffer
+ * (TDD_js-v1.1-webgl1.md §4.3/§4.6). Because Phaser owns the GL state machine,
+ * the caller is responsible for flushing Phaser's batch and restoring pipeline
+ * state around a render() call (see Effect.renderWebGL).
+ */
+export declare class NeutrinoRenderer {
+    private _orthoMatrix;
+    private _modelMatrix;
+    private _texSlotMap;
+    private _batchPool;
+    private _batchCount;
+    constructor();
+    render(ctx: NeutrinoContext, dtm: DataTextureManager | DataTextureManagerGL1, dataView: DataView, dataUint32: Uint32Array, instructions: any[], numParticles: number, params: RenderParams): void;
+    private _resolveBlend;
+    private _applyBlendMode;
+}

package/dist/PerspectiveProjection.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The class implements perspective projection transformation.
+ *
+ * @example
+ * // Create effect instance using loaded model
+ * let effect = new PIXINeutrino.Effect(resources.effectModel, {
+ *   position: [400, 300, 0],
+ *   projection: new PIXINeutrino.PerspectiveProjection(60.0)
+ * });
+ *
+ * @param {number} [horizontalAngle] Horizontal angle of the perspective projection in degrees.
+ */
+import { Vec2, Vec3 } from "./types";
+export interface ScreenFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class PerspectiveProjection {
+    private _angleTan;
+    private _screenWidth;
+    private _screenPosX;
+    private _screenPosY;
+    private _z;
+    private _near;
+    set horizontalAngle(value: number);
+    constructor(horizontalAngle: number);
+    /**
+     * 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 {ScreenFrame} frame Rendering frame.
+     */
+    setScreenFrame(frame: ScreenFrame): void;
+    /**
+     * 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(out: Vec2, pos: Vec3): boolean;
+    /**
+     * 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(outSize: Vec2, pos: Vec3, size: Vec2): void;
+    _getScale(pos: Vec3): number;
+}

package/dist/gl1/DataTextureManagerGL1.d.ts

@@ -0,0 +1,23 @@
+import { MetaTextureManager } from "./MetaTextureManager";
+export declare class DataTextureManagerGL1 {
+    readonly textureWidth: number;
+    readonly textureHeight: number;
+    readonly meta: MetaTextureManager;
+    private readonly _gl;
+    private readonly _floatView;
+    private _dataTextures;
+    private _metaTextures;
+    private _currentIndex;
+    constructor(gl: WebGLRenderingContext, data: Uint32Array, textureWidth: number, textureHeight: number);
+    get currentDataTexture(): WebGLTexture;
+    get currentMetaTexture(): WebGLTexture;
+    /**
+     * 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(numParticles: number, dataUnit: number, metaUnit: number): void;
+    advance(): void;
+    destroy(): void;
+    private _createTexture;
+}

package/dist/gl1/MetaTextureManager.d.ts

@@ -0,0 +1,9 @@
+export declare class MetaTextureManager {
+    readonly bytes: Uint8Array;
+    private readonly _u32;
+    constructor(textureWidth: number, textureHeight: number);
+    /** Repack the packed-u32 record fields for the first `numParticles` records. */
+    build(dataUint32: Uint32Array, numParticles: number): void;
+    /** Write the batch texture slot into byte0 of M0 (flags) per particle. */
+    patchSlot(startParticle: number, count: number, slot: number): void;
+}