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

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## CurrentVersion
+## [1.1.0] - 2026-08-03
+
+- Emitter properties can now be **read** as well as written: `getEmitterPropertyValue()`, `hasEmitterProperty()` and `getEmitterProperties()` (which lists every property an effect exposes, with its live value). `setPropertyInEmitter()`, for addressing a single emitter by name, is now available on the effect too
+
+- 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.
+- Added perspective projection (Projection3D) support, matching the PIXI and Phaser 4 integrations: pass `projection: new PhaserNeutrino.PerspectiveProjection(angle)` in the effect options and particles scale with their distance from the camera. Particles that cross the near plane are discarded as whole quads.
+- 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).
+- Emitter-anchored strips no longer show a brief mis-oriented sliver at the emitter end right after a new particle spawns.
+- Fixed broken ribbon (Strip) geometry on sharp bends: a dark wedge was cut out of the ribbon wherever the path bent sharper than the ribbon's own width, and the segments next to the ribbon's ends (near the emitter and at the tail) could render as a twisted, mostly-invisible band or a stray misoriented quad — most visible right where the ribbon is being created when the head particle sits close to the emitter (issue #236).
+
+## [1.0.1] - 2026-07-25
 
 - 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).
+- Emitter-anchored strips no longer show a brief mis-oriented sliver at the emitter end right after a new particle spawns.
+- Fixed broken ribbon (Strip) geometry on sharp bends: a dark wedge was cut out of the ribbon wherever the path bent sharper than the ribbon's own width, and the segments next to the ribbon's ends (near the emitter and at the tail) could render as a twisted, mostly-invisible band or a stray misoriented quad — most visible right where the ribbon is being created when the head particle sits close to the emitter (issue #236).

package/README.md

@@ -187,10 +187,41 @@ effect.unpause();
 Control exposed emitter properties at runtime. Properties are defined in Emitter Guide or Emitter Scheme in the Editor.
 
 ```javascript
+// Write to every emitter that declares the property...
 effect.setPropertyInAllEmitters('MyParticlesPerSecond', 100);
 effect.setPropertyInAllEmitters('MyColor', [1.0, 0.5, 0.2]);
+
+// ...or address a single emitter by name.
+effect.setPropertyInEmitter('Sparks', 'MyColor', [1.0, 0.5, 0.2]);
+```
+
+Read the current values back. A scalar property returns a `number`, a vector
+property returns a `number[]`, and an unknown property returns `undefined`:
+
+```javascript
+effect.getEmitterPropertyValue('Sparks', 'MyColor');  // [1.0, 0.5, 0.2]
+effect.getEmitterPropertyValue('MyParticlesPerSecond');  // 100 — first emitter with it
+
+effect.hasEmitterProperty('Sparks', 'MyColor');  // true
+effect.hasEmitterProperty('NoSuchProperty');     // false
 ```
 
+Discover what an effect exposes without knowing the names up front:
+
+```javascript
+for (const p of effect.getEmitterProperties()) {
+    // { emitterName: 'Sparks', name: 'MyColor', arity: 3, value: [1, 0.5, 0.2] }
+    console.log(p.emitterName, p.name, p.arity, p.value);
+}
+```
+
+Values are read live from the simulation buffer at call time.
+
+> **Use only the documented methods above.** Exported effects are minified, and
+> the internal property names/objects they contain (`_globParamMeta`, or whatever
+> short name it was mangled to) are not a stable API — they change between editor
+> versions and differ between commercial and non-commercial exports.
+
 ## Number of Particles
 
 ```javascript
@@ -203,6 +234,12 @@ const numParticles = effect.getNumParticles();
 - **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.
 
+## HDR Bloom (optional add-on)
+
+The scene-preserving HDR glow that matches the editor preview is currently available for
+**PIXI.js** ([`bloom-v1.1-pixi7`](../bloom-pixi7) / [`bloom-v1.1-pixi8`](../bloom-pixi8)) and
+**MonoGame**. A Phaser bloom add-on is not available yet.
+
 ## Documentation
 
 Full documentation at [neutrinoparticles.com](https://neutrinoparticles.com/en/docs/199).

package/dist/Effect.d.ts

@@ -2,13 +2,15 @@ import Phaser from 'phaser';
 import { Pause, Vec2, Vec3 } from './types';
 import { GamePlugin } from './GamePlugin';
 import { EffectModel } from './EffectModel';
-import { NeutrinoSystem } from './types';
+import { NeutrinoEmitterProperty, NeutrinoSystem } from './types';
+import { PerspectiveProjection } from './PerspectiveProjection';
 export interface EffectOptions {
     position?: Vec3;
     angle?: number;
     scale?: number;
     pause?: Pause;
     generatorsPaused?: boolean;
+    projection?: PerspectiveProjection;
 }
 /**
  * A NeutrinoParticles effect on a Phaser scene (JS v1.1 runtime).
@@ -34,6 +36,8 @@ export declare class Effect extends Phaser.GameObjects.GameObject {
     alpha: number;
     depth: number;
     blendMode: number;
+    /** Optional v1.0-parity perspective projection (Projection3D). */
+    projection?: PerspectiveProjection;
     private _dataTextureManager;
     private _worldPosition;
     private _worldScaledPosition;
@@ -64,6 +68,12 @@ export declare class Effect extends Phaser.GameObjects.GameObject {
     unpauseGenerators(): void;
     get generatorsPaused(): boolean;
     setPropertyInAllEmitters(name: string, value: Vec3 | Vec2 | number): void;
+    setPropertyInEmitter(emitterName: string, name: string, value: Vec3 | Vec2 | number): void;
+    getEmitterPropertyValue(name: string): number | number[] | undefined;
+    getEmitterPropertyValue(emitterName: string, name: string): number | number[] | undefined;
+    hasEmitterProperty(name: string): boolean;
+    hasEmitterProperty(emitterName: string, name: string): boolean;
+    getEmitterProperties(): NeutrinoEmitterProperty[];
     getNumParticles(): number;
     setScrollFactor(x: number, y?: number): this;
     setAlpha(topLeft?: number, _topRight?: number, _bottomLeft?: number, _bottomRight?: number): this;

package/dist/NeutrinoRenderer.d.ts

@@ -2,6 +2,7 @@ import { NeutrinoContext } from "./NeutrinoContext";
 import { DataTextureManager } from "./DataTextureManager";
 import { DataTextureManagerGL1 } from "./gl1/DataTextureManagerGL1";
 import { NeutrinoSubRect } from "./types";
+import { PerspectiveProjection } from "./PerspectiveProjection";
 export interface RenderParams {
     /** Effect world transform (2x3) already including world scale. */
     model: {
@@ -21,6 +22,9 @@ export interface RenderParams {
     zoom: number;
     /** Host scene-graph world alpha, multiplied into each particle's alpha. */
     worldAlpha: number;
+    /** Optional v1.0-parity perspective projection (Projection3D); when set,
+     *  uViewProjMatrix = ortho * perspective (both in screen space). */
+    projection?: PerspectiveProjection;
     /** Per-particle GL textures (one per render-style texture index). */
     glTextures: (WebGLTexture | null)[];
     remaps: Array<NeutrinoSubRect | null>;
@@ -43,12 +47,16 @@ export interface RenderParams {
  */
 export declare class NeutrinoRenderer {
     private _orthoMatrix;
+    private _perspMatrix;
+    private _vpMatrix;
+    private _projFrame;
     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 _mulMatrix;
     private _resolveBlend;
     private _applyBlendMode;
 }

package/dist/PerspectiveProjection.d.ts

@@ -62,4 +62,14 @@ export declare class PerspectiveProjection {
      */
     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;
 }