@neutrinoparticles/js-v1.1-pixi8 1.0.0

package/dist/neutrinoparticles.js-v1.1-pixi8.d.ts

@@ -0,0 +1,482 @@
+// Generated by dts-bundle v0.7.3
+// Dependencies for this module:
+//   index.d.ts
+
+declare module '@neutrinoparticles/js-v1.1-pixi8' {
+    import { Context, ContextOptions } from '@neutrinoparticles/js-v1.1-pixi8/Context';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/types';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/AplicationPlugin';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/Context';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/Effect';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/EffectModel';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/DataTextureManager';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/NeutrinoRenderer';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/EffectPipe';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/TexturesLoader';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/PerspectiveProjection';
+    export * from '@neutrinoparticles/js-v1.1-pixi8/EffectModelLoader';
+    export function registerPlugins(): void;
+    export function unregisterPlugins(): void;
+    declare module '@neutrinoparticles/js-v1.1-pixi8/index//pixi.js' {
+        interface ApplicationOptions {
+            neutrino?: ContextOptions;
+        }
+        interface Application {
+            neutrino?: Context;
+        }
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/Context' {
+    import { Renderer } from 'pixi.js';
+    import { NeutrinoContext } from '@neutrinoparticles/js-v1.1-pixi8/types';
+    export interface ContextOptions {
+            texturesBasePath?: string;
+            trimmedExtensionsLookupFirst?: boolean;
+    }
+    export interface ContextLoadData {
+            __neutrinoContext__: Context;
+    }
+    /**
+        * Shared GL state for the PIXI v8 NeutrinoParticles integration: the shader
+        * program (WebGL2 data-texture path, or the WebGL1 meta-texture path — see
+        * docs/tdd/TDD_js-v1.1-webgl1.md), a static quad index buffer (+ VAO on
+        * WebGL2 / aId attribute stream on WebGL1), and all uniform locations.
+        * Created once per application and reused by every {@link Effect}.
+        */
+    export class Context {
+            readonly neutrino: NeutrinoContext;
+            readonly renderer: Renderer;
+            readonly gl: WebGL2RenderingContext;
+            readonly options: ContextOptions;
+            readonly loadData: ContextLoadData;
+            static readonly MAX_BATCH_TEXTURES = 8;
+            constructor(renderer: Renderer, options?: ContextOptions);
+            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;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/types' {
+    export type Vec2 = [number, number];
+    export type Vec3 = [number, number, number];
+    export type Vec4 = [number, number, number, number];
+    export type Quat = [number, number, number, number];
+    export type Mat3x2 = [number, number, number, number, number, number];
+    export interface RenderInstruction {
+        startParticleIndex: number;
+        numParticles: number;
+        renderStyleIndex: number;
+        blendMode: number;
+    }
+    export interface RenderStyle {
+        materialIndex: number;
+        textureIndices: number[];
+    }
+    export interface NeutrinoEffectModel {
+        textures: string[];
+        materials: number[];
+        renderStyles: RenderStyle[];
+        totalParticles: number;
+        createInstance(position: Vec3, rotation: Quat, options: object): NeutrinoSystem;
+    }
+    export interface NeutrinoSystem {
+        model: NeutrinoEffectModel;
+        particleDataUint32: Uint32Array;
+        particleDataBuffer: ArrayBuffer;
+        particleDataView: DataView;
+        dataTextureWidth: number;
+        dataTextureHeight: number;
+        renderInstructions: RenderInstruction[] & {
+            _totalParticles: number;
+        };
+        update(dt: number, position?: Vec3 | null, rotation?: Quat | null): void;
+        construct(cameraDir?: Vec3): void;
+        restart(position?: Vec3, rotation?: Quat, options?: object): void;
+        resetPosition(position?: Vec3, rotation?: Quat): void;
+        pauseAllEmitters(): void;
+        unpauseAllEmitters(): void;
+        areAllEmittersPaused(): boolean;
+        pauseGeneratorsInAllEmitters(): void;
+        unpauseGeneratorsInAllEmitters(): void;
+        areGeneratorsInAllEmittersPaused(): boolean;
+        getNumParticles(): number;
+        setPropertyInAllEmitters(name: string, value: number | Vec2 | Vec3): void;
+    }
+    export interface NeutrinoContext {
+        initializeNoise(path: string, success: () => void, fail: () => void): void;
+        NoiseGenerator: new () => {
+            step(): boolean;
+            progress: number;
+        };
+        axisangle2quat_(axis: Vec3, angleDeg: number): Quat;
+    }
+    export interface NeutrinoSubRect {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/AplicationPlugin' {
+    import { Application } from "pixi.js";
+    /**
+      * Creates the shared {@link Context} and assigns it to app.neutrino on init.
+      */
+    export class ApplicationPlugin {
+        static get extension(): any;
+        static init(this: Application, options: any): void;
+        static destroy(this: Application): void;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/Effect' {
+    import { Bounds, Container, Instruction, ViewContainer } from 'pixi.js';
+    import { EffectModel } from '@neutrinoparticles/js-v1.1-pixi8/EffectModel';
+    import { Context } from '@neutrinoparticles/js-v1.1-pixi8/Context';
+    import { DataTextureManager } from '@neutrinoparticles/js-v1.1-pixi8/DataTextureManager';
+    import { DataTextureManagerGL1 } from '@neutrinoparticles/js-v1.1-pixi8/gl1/DataTextureManagerGL1';
+    import { PerspectiveProjection } from '@neutrinoparticles/js-v1.1-pixi8/PerspectiveProjection';
+    import { NeutrinoSystem, Vec2, Vec3 } from '@neutrinoparticles/js-v1.1-pixi8/types';
+    export enum Pause {
+            NO = 0,
+            BEFORE_UPDATE_OR_RENDER = 1,
+            YES = 2
+    }
+    export interface EffectOptions {
+            position?: Vec3;
+            rotation?: number;
+            scale?: Vec3;
+            pause?: Pause;
+            generatorsPaused?: boolean;
+            baseParent?: Container;
+            projection?: PerspectiveProjection;
+            autoInit?: boolean;
+    }
+    export interface RenderMatrix {
+            a: number;
+            b: number;
+            c: number;
+            d: number;
+            tx: number;
+            ty: number;
+    }
+    /**
+        * A NeutrinoParticles effect instance on a PIXI v8 scene.
+        *
+        * Extends ViewContainer and plugs into the v8 render graph as a custom render
+        * pipe ('neutrino'). Simulation runs on the CPU (neutrinoparticles.js v1.1);
+        * geometry is constructed on the GPU from a data texture by {@link NeutrinoRenderer}.
+        */
+    export class Effect extends ViewContainer implements Instruction {
+            readonly renderPipeId: string;
+            batched: boolean;
+            readonly ctx: Context;
+            readonly effectModel: EffectModel;
+            effect?: NeutrinoSystem;
+            readonly baseParent?: Container;
+            readonly projection?: PerspectiveProjection;
+            positionZ: number;
+            scaleZ: number;
+            /** World transform actually fed to the renderer's model matrix (2x3). */
+            worldRenderMatrix: RenderMatrix;
+            constructor(effectModel: EffectModel, options?: EffectOptions);
+            get bounds(): Bounds;
+            protected updateBounds(): void;
+            init(): void;
+            ready(): boolean;
+            update(seconds: number): void;
+            restart(position?: Vec3, rotation?: number): void;
+            resetPosition(position?: Vec3, rotation?: number): void;
+            pause(): void;
+            unpause(): void;
+            pauseGenerators(): void;
+            unpauseGenerators(): void;
+            setPropertyInAllEmitters(name: string, value: Vec3 | Vec2 | number): void;
+            getNumParticles(): number;
+            /** @internal — called by EffectPipe during the render pass. */
+            _dtm(): DataTextureManager | DataTextureManagerGL1 | undefined;
+            /**
+                * @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(): void;
+            /**
+                * @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(): number;
+            /**
+                * @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(): boolean;
+            destroy(options?: any): void;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/EffectModel' {
+    import { EventEmitter, Texture } from "pixi.js";
+    import { Context } from "@neutrinoparticles/js-v1.1-pixi8/Context";
+    import { AbstractTexturesLoader } from "@neutrinoparticles/js-v1.1-pixi8/TexturesLoader";
+    import { NeutrinoEffectModel, NeutrinoSubRect } from "@neutrinoparticles/js-v1.1-pixi8/types";
+    /**
+      * Wraps a neutrinoparticles.js v1.1 effect model and loads its textures via the
+      * PIXI v8 asset cache. Computes atlas UV remaps (as plain {x,y,width,height}
+      * objects — the v1.1 renderer reads them directly, no SubRect wrapper).
+      */
+    export class EffectModel extends EventEmitter {
+        readonly ctx: Context;
+        readonly effectModel: NeutrinoEffectModel;
+        texturesRemap: Array<NeutrinoSubRect | null>;
+        readonly textures: Array<Texture>;
+        constructor(context: Context, neutrinoModel: string | NeutrinoEffectModel, texturesLoader: AbstractTexturesLoader);
+        ready(): boolean;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/DataTextureManager' {
+    /**
+        * 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 class DataTextureManager {
+            readonly textureWidth: number;
+            readonly textureHeight: number;
+            /**
+                * @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;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/NeutrinoRenderer' {
+    import { WebGLRenderer } from "pixi.js";
+    import { Context } from "@neutrinoparticles/js-v1.1-pixi8/Context";
+    import { Effect } from "@neutrinoparticles/js-v1.1-pixi8/Effect";
+    import { DataTextureManager } from "@neutrinoparticles/js-v1.1-pixi8/DataTextureManager";
+    import { DataTextureManagerGL1 } from "@neutrinoparticles/js-v1.1-pixi8/gl1/DataTextureManagerGL1";
+    /**
+      * Raw WebGL2 data-texture renderer for the PIXI v8 integration.
+      *
+      * Mirrors the pixi7 RendererPlugin: builds draw batches (grouped by blend mode,
+      * up to 8 textures each), patches the per-particle texture-slot byte into the
+      * runtime data buffer, uploads the data texture, sets camera/projection/model
+      * uniforms, and issues one drawElements per batch. Particle textures are bound
+      * by their raw WebGL handle (resolved from PIXI via the texture system).
+      */
+    export class NeutrinoRenderer {
+        constructor();
+        renderEffect(renderer: WebGLRenderer, ctx: Context, effect: Effect, dtm: DataTextureManager | DataTextureManagerGL1, instructions: any[], numParticles: number): void;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/EffectPipe' {
+    import { ExtensionType, InstructionSet, RenderPipe, WebGLRenderer } from "pixi.js";
+    import { Effect } from "@neutrinoparticles/js-v1.1-pixi8/Effect";
+    /**
+      * PIXI v8 render pipe for NeutrinoParticles effects.
+      *
+      * Each effect is its own instruction (Effect.batched = false). The actual draw
+      * happens in {@link execute}, which runs inside the v8 render pass where PIXI
+      * owns the GL state — there we construct the frame's geometry and issue the raw
+      * WebGL2 data-texture draw via {@link NeutrinoRenderer}.
+      */
+    export class EffectPipe implements RenderPipe<Effect> {
+        static extension: {
+            readonly type: readonly [ExtensionType.WebGLPipes];
+            readonly name: "neutrino";
+        };
+        readonly renderer: WebGLRenderer;
+        constructor(renderer: WebGLRenderer);
+        validateRenderable(_effect: Effect): boolean;
+        addRenderable(effect: Effect, instructionSet: InstructionSet): void;
+        updateRenderable(_effect: Effect): void;
+        destroyRenderable(_effect: Effect): void;
+        execute(effect: Effect): void;
+        destroy(): void;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/TexturesLoader' {
+    import { Loader, Texture } from 'pixi.js';
+    /**
+      * Texture loader interface used by {@link EffectModel} to load required textures.
+      */
+    export abstract class AbstractTexturesLoader {
+        constructor();
+        abstract load(texturePath: string): Promise<Texture>;
+    }
+    export class AssetsTexturesLoader extends AbstractTexturesLoader {
+        constructor(loader: Loader);
+        load(texturePath: string): Promise<Texture>;
+    }
+    export class DefaultAssetsTexturesLoader extends AssetsTexturesLoader {
+        static readonly instance: DefaultAssetsTexturesLoader;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/PerspectiveProjection' {
+    /**
+        * 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 { Rectangle } from "pixi.js";
+    import { Vec2, Vec3 } from "@neutrinoparticles/js-v1.1-pixi8/types";
+    export class PerspectiveProjection {
+            set horizontalAngle(value: number);
+            constructor(horizontalAngle: number);
+            /**
+                * 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(frame: Rectangle): 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;
+            /**
+                * 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(out: Float32Array): void;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/EffectModelLoader' {
+    import { ExtensionType, Loader, LoaderParserPriority, ResolvedAsset } from 'pixi.js';
+    import { EffectModel } from '@neutrinoparticles/js-v1.1-pixi8/EffectModel';
+    export const effectModelLoader: {
+        extension: {
+            type: ExtensionType;
+            priority: LoaderParserPriority;
+        };
+        test(_url: string, loadAsset: ResolvedAsset, _loader: Loader): any;
+        load(url: string, _loadAsset: ResolvedAsset, _loader: Loader): Promise<string>;
+        testParse(this: Loader, _asset: any, options: ResolvedAsset): Promise<any>;
+        parse(asset: string, options: ResolvedAsset, loader: Loader): Promise<unknown>;
+        unload(_effectModel: EffectModel): void;
+    };
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/gl1/DataTextureManagerGL1' {
+    import { MetaTextureManager } from "@neutrinoparticles/js-v1.1-pixi8/gl1/MetaTextureManager";
+    export class DataTextureManagerGL1 {
+        readonly textureWidth: number;
+        readonly textureHeight: number;
+        readonly meta: MetaTextureManager;
+        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;
+    }
+}
+
+declare module '@neutrinoparticles/js-v1.1-pixi8/gl1/MetaTextureManager' {
+    export class MetaTextureManager {
+        readonly bytes: Uint8Array;
+        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;
+    }
+}
+