@neutrinoparticles/js-v1.1-pixi8 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## CurrentVersion
+
+- Initial PIXI v8 integration for the JS v1.1 export format (GPU geometry construction, data-texture renderer).
+- Added 3D perspective projection support (`PerspectiveProjection` passed via the `projection` effect option) with the same behavior and API as the JS v1.0 runtimes: particles with 3D motion scale with depth toward the screen center and are discarded behind the camera.
+- Added automatic WebGL1 rendering support on compatible devices. WebGL2 remains the primary path.
+- Auto-unpause an effect on its first render when it is rendered before its first update (`Pause.BEFORE_UPDATE_OR_RENDER`), matching the pixi7/phaser adapters; previously such an effect stayed paused and produced an empty first frame.
+- 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,231 @@
+# @neutrinoparticles/js-v1.1-pixi8
+
+PIXI.js v8 integration for [NeutrinoParticles](https://neutrinoparticles.com/) real-time particle effects (format **v1.1**).
+
+## Installation
+
+```bash
+npm install @neutrinoparticles/js-v1.1-pixi8
+```
+
+The core runtime (`@neutrinoparticles/js-v1.1`) is installed automatically as a dependency.
+
+**Peer dependency:** PIXI.js v8
+
+## Requirements
+
+The v1.1 renderer reconstructs particle geometry on the GPU. It works on:
+
+- **WebGL2** (the PIXI v8 default) — the primary path;
+- **WebGL1** — 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.
+
+On a WebGL1 context missing those capabilities, creating the plugin context
+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).
+
+In practice: keep PIXI's default (`preferWebGLVersion: 2`) so WebGL1
+engages automatically only where WebGL2 truly is not available — set
+`preferWebGLVersion: 1` in `app.init` only when you deliberately need to
+test or target the legacy path.
+
+## Export Target in Editor
+
+In the NeutrinoParticles Editor, set the export target to **JavaScript v1.1**.
+
+After export you get a `.js` file (e.g. `my_effect.js`) containing the effect model.
+
+## Quick Start
+
+### HTML + Dynamic loading
+
+In the editor's project settings, select **For XHR Request** export format, then
+load the effect at runtime via `PIXI.Assets`. Pass `app.neutrino.loadData` so the
+loader parses the file as a NeutrinoParticles effect.
+
+```html
+<script src="path/to/pixi.js"></script>
+<script src="path/to/@neutrinoparticles/js-v1.1/dist/neutrinoparticles.js-v1.1.umd.js"></script>
+<script src="path/to/@neutrinoparticles/js-v1.1-pixi8/dist/neutrinoparticles.js-v1.1-pixi8.umd.js"></script>
+<script>
+
+(async () => {
+  const app = new PIXI.Application();
+
+  await app.init({
+    width: 800,
+    height: 600,
+    neutrino: { // options for PIXINeutrino.Context
+      texturesBasePath: 'textures/' // Prefix for loading textures. Slash at the end!
+    }
+  });
+
+  document.body.appendChild(app.canvas);
+
+  // Generate turbulence if your effects use it
+  // app.neutrino.generateNoise();
+
+  PIXI.Assets.add({
+    alias: 'effectModel',
+    src: 'export_js/my_effect.js',
+    data: app.neutrino.loadData
+  });
+  const effectModel = await PIXI.Assets.load('effectModel');
+
+  const effect = new PIXINeutrino.Effect(effectModel, {
+    position: [400, 300, 0]
+  });
+  app.stage.addChild(effect);
+
+  app.ticker.add((time) => {
+    const sec = time.deltaMS / 1000;
+    effect.update(sec > 1.0 ? 1.0 : sec);
+  });
+})();
+
+</script>
+```
+
+### ES6 + Bundler
+
+```javascript
+import * as PIXI from 'pixi.js'
+import * as PIXINeutrino from '@neutrinoparticles/js-v1.1-pixi8'
+
+const app = new PIXI.Application();
+await app.init({
+  width: 800,
+  height: 600,
+  neutrino: { texturesBasePath: 'textures/' }
+});
+document.body.appendChild(app.canvas);
+
+PIXI.Assets.add({ alias: 'effectModel', src: 'export_js/my_effect.js', data: app.neutrino.loadData });
+const effectModel = await PIXI.Assets.load('effectModel');
+
+const effect = new PIXINeutrino.Effect(effectModel, { position: [400, 300, 0] });
+app.stage.addChild(effect);
+
+app.ticker.add((time) => {
+  const sec = time.deltaMS / 1000;
+  effect.update(sec > 1.0 ? 1.0 : sec);
+});
+```
+
+## 3D Perspective Projection
+
+Effects can place particles in 3D (Z position/velocity set up in the editor). By
+default the renderer is orthographic: Z is ignored. Pass a `PerspectiveProjection`
+to make particles scale with depth (same behavior and API as the JS v1.0 runtimes):
+particles farther away shrink toward the screen center, particles behind the
+camera are discarded.
+
+```javascript
+const projection = new PIXINeutrino.PerspectiveProjection(60.0); // horizontal FOV, degrees
+
+const effect = new PIXINeutrino.Effect(effectModel, {
+  position: [400, 300, 0],
+  projection // can be shared between effects
+});
+```
+
+For the angle use the same value as in the NeutrinoParticles Editor project
+(Project Settings > Preview > Perspective) to match the editor preview. The
+projection has no camera rotation — only depth scaling around the screen center.
+
+## 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([newX, newY, 0]);
+
+// With new rotation (radians)
+effect.resetPosition([newX, newY, 0], newRotationRadians);
+```
+
+## Restart
+
+Restart destroys all existing particles and starts the effect from scratch:
+
+```javascript
+effect.restart([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
+const effect = new PIXINeutrino.Effect(effectModel, {
+  position: [400, 300, 0],
+  pause: PIXINeutrino.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
+
+- **`a WebGL2 renderer is required` error:** The v1.1 renderer needs WebGL2. PIXI v8 uses WebGL2 by default; make sure you are not forcing a WebGL1 renderer.
+- **No particles visible:** Check that the export target in the editor is set to JavaScript v1.1. Verify `texturesBasePath` points to the correct textures directory.
+- **Turbulence not working:** Call `app.neutrino.generateNoise()` before creating effects that use noise/turbulence.
+
+## Documentation
+
+Full documentation at [neutrinoparticles.com](https://neutrinoparticles.com/en/docs/199).
+
+## License
+
+Copyright (c) Yurii Miroshnyk. All rights reserved.

package/dist/AplicationPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Application } from "pixi.js";
+/**
+ * Creates the shared {@link Context} and assigns it to app.neutrino on init.
+ */
+export declare class ApplicationPlugin {
+    static get extension(): any;
+    static init(this: Application, options: any): void;
+    static destroy(this: Application): void;
+}

package/dist/Context.d.ts

@@ -0,0 +1,92 @@
+import { Renderer } from 'pixi.js';
+import { NeutrinoContext } from './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 declare class Context {
+    readonly neutrino: NeutrinoContext;
+    readonly renderer: Renderer;
+    readonly gl: WebGL2RenderingContext;
+    readonly options: ContextOptions;
+    readonly loadData: ContextLoadData;
+    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;
+    constructor(renderer: Renderer, options?: ContextOptions);
+    private _noiseInitialized;
+    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/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,104 @@
+import { Bounds, Container, Instruction, ViewContainer } from 'pixi.js';
+import { EffectModel } from './EffectModel';
+import { Context } from './Context';
+import { DataTextureManager } from './DataTextureManager';
+import { DataTextureManagerGL1 } from './gl1/DataTextureManagerGL1';
+import { PerspectiveProjection } from './PerspectiveProjection';
+import { NeutrinoSystem, Vec2, Vec3 } from './types';
+export declare 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 declare 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;
+    private _worldPosition;
+    private _worldRotationDegree;
+    private _worldScale;
+    private _dataTextureManager?;
+    private _unpauseOnUpdateRender;
+    private _startupOptions;
+    private _inited;
+    private _ready;
+    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;
+    private _onEffectReady;
+    private _scaledPosition;
+    private _getRenderGroupContainer;
+    private _updateWorldTransform;
+    private _calcWorldRotation;
+    private _checkUnpauseOnUpdateRender;
+}

package/dist/EffectModel.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter, Texture } from "pixi.js";
+import { Context } from "./Context";
+import { AbstractTexturesLoader } from "./TexturesLoader";
+import { NeutrinoEffectModel, NeutrinoSubRect } from "./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 declare class EffectModel extends EventEmitter {
+    readonly ctx: Context;
+    readonly effectModel: NeutrinoEffectModel;
+    texturesRemap: Array<NeutrinoSubRect | null>;
+    readonly textures: Array<Texture>;
+    private _numTexturesToLoadLeft;
+    constructor(context: Context, neutrinoModel: string | NeutrinoEffectModel, texturesLoader: AbstractTexturesLoader);
+    ready(): boolean;
+    private _onTextureLoaded;
+    private _initTexturesRemapIfNeeded;
+}

package/dist/EffectModelLoader.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionType, Loader, LoaderParserPriority, ResolvedAsset } from 'pixi.js';
+import { EffectModel } from './EffectModel';
+export declare 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;
+};

package/dist/EffectPipe.d.ts

@@ -0,0 +1,25 @@
+import { ExtensionType, InstructionSet, RenderPipe, WebGLRenderer } from "pixi.js";
+import { Effect } from "./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 declare class EffectPipe implements RenderPipe<Effect> {
+    static extension: {
+        readonly type: readonly [ExtensionType.WebGLPipes];
+        readonly name: "neutrino";
+    };
+    readonly renderer: WebGLRenderer;
+    private readonly _neutrinoRenderer;
+    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;
+}

package/dist/NeutrinoRenderer.d.ts

@@ -0,0 +1,31 @@
+import { WebGLRenderer } from "pixi.js";
+import { Context } from "./Context";
+import { Effect } from "./Effect";
+import { DataTextureManager } from "./DataTextureManager";
+import { DataTextureManagerGL1 } from "./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 declare class NeutrinoRenderer {
+    private _orthoMatrix;
+    private _perspMatrix;
+    private _vpMatrix;
+    private _modelMatrix;
+    private _projFrame;
+    private _texSlotMap;
+    private _batchPool;
+    private _batchCount;
+    constructor();
+    renderEffect(renderer: WebGLRenderer, ctx: Context, effect: Effect, dtm: DataTextureManager | DataTextureManagerGL1, instructions: any[], numParticles: number): void;
+    private _resolveBlend;
+    private _applyBlendMode;
+    private _fillProjMatrix;
+    private _mulMatrix;
+    private _fillModelMatrix;
+}

package/dist/PerspectiveProjection.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 "./types";
+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 {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;
+}

package/dist/TexturesLoader.d.ts

@@ -0,0 +1,17 @@
+import { Loader, Texture } from 'pixi.js';
+/**
+ * Texture loader interface used by {@link EffectModel} to load required textures.
+ */
+export declare abstract class AbstractTexturesLoader {
+    constructor();
+    abstract load(texturePath: string): Promise<Texture>;
+}
+export declare class AssetsTexturesLoader extends AbstractTexturesLoader {
+    private loader;
+    constructor(loader: Loader);
+    load(texturePath: string): Promise<Texture>;
+}
+export declare class DefaultAssetsTexturesLoader extends AssetsTexturesLoader {
+    static readonly instance: DefaultAssetsTexturesLoader;
+    private constructor();
+}