@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/two-d/render/Capabilities.d.ts

@@ -1,84 +0,0 @@
-export type GraphicsWorkload = 'sprites' | 'ui' | 'custom-shaders' | 'particles' | 'instanced-terrain' | 'voxels' | 'animated-models' | 'large-3d-worlds';
-export interface GraphicsCapabilities {
-    webgl1: boolean;
-    webgl2: boolean;
-    webgpu: boolean;
-    /** WGSL is usable only through a WebGPU-capable browser runtime. */
-    wgsl: boolean;
-}
-export interface GraphicsProbe {
-    createCanvas?(): {
-        getContext(kind: string): unknown;
-    } | null;
-    webgpu?: boolean;
-    /** whether a real WGSL shader actually compiled; see `detectWebGpu` for how to get one */
-    wgsl?: boolean;
-}
-export interface RenderingDecision {
-    workload: GraphicsWorkload;
-    preferred: string;
-    fallback: string;
-    reason: string;
-}
-/**
- * The framework's rendering choices by workload. This is data, not a global renderer switch:
- * each game imports only the module it uses and keeps 2D Pixi and optional 3D Babylon paths
- * independent.
- *
- * @example
- * ```ts
- * import { RENDERING_DECISIONS } from '@datamoc/mw_games/two-d/render';
- *
- * const particles = RENDERING_DECISIONS.find((d) => d.workload === 'particles');
- * console.log(particles?.preferred); // 'PixiJS for 2D, Babylon.js for 3D'
- * ```
- */
-export declare const RENDERING_DECISIONS: readonly RenderingDecision[];
-/**
- * Reports browser graphics APIs without creating a renderer or selecting a fallback.
- * Pass a probe in tests or host integrations; omitting it reads the current browser safely.
- *
- * `wgsl` cannot be checked synchronously - the only way to genuinely know a WGSL shader
- * compiles is `detectWebGpu`, which requests a real device and compiles one, and every step
- * of that is asynchronous. Rather than assume WGSL works just because `navigator.gpu`
- * exists (a browser can expose WebGPU behind a still-broken or disabled implementation),
- * this stays `false` unless a caller supplies a real result through `probe.wgsl`.
- *
- * @example
- * ```ts
- * import { inspectGraphicsCapabilities } from '@datamoc/mw_games/two-d/render';
- *
- * // reads the real browser when no probe is given
- * const here = inspectGraphicsCapabilities();
- *
- * // a fake probe, for a test or a host integration with no DOM
- * const capabilities = inspectGraphicsCapabilities({
- * 	createCanvas: () => ({ getContext: (kind) => (kind === 'webgl2' ? {} : null) }),
- * 	webgpu: false,
- * });
- * console.log(capabilities.webgl2); // true
- * console.log(capabilities.webgpu); // false
- * ```
- */
-export declare function inspectGraphicsCapabilities(probe?: GraphicsProbe): GraphicsCapabilities;
-export interface WebGpuDetection {
-    webgpu: boolean;
-    wgsl: boolean;
-}
-/**
- * The real, asynchronous WebGPU/WGSL check `inspectGraphicsCapabilities` cannot do
- * synchronously: requests an actual adapter and device, then compiles an actual shader
- * module and reads back its compilation diagnostics. Feed the result to
- * `inspectGraphicsCapabilities` via `probe.webgpu`/`probe.wgsl` once resolved.
- *
- * @example
- * ```ts
- * import { detectWebGpu, inspectGraphicsCapabilities } from '@datamoc/mw_games/two-d/render';
- *
- * const detected = await detectWebGpu();
- * const capabilities = inspectGraphicsCapabilities({ webgpu: detected.webgpu, wgsl: detected.wgsl });
- * console.log(capabilities.wgsl); // true only if a real WGSL shader actually compiled
- * ```
- */
-export declare function detectWebGpu(): Promise<WebGpuDetection>;
-//# sourceMappingURL=Capabilities.d.ts.map

package/dist/two-d/render/Capabilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Capabilities.d.ts","sourceRoot":"","sources":["../../../src/two-d/render/Capabilities.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GACzB,SAAS,GACT,IAAI,GACJ,gBAAgB,GAChB,WAAW,GACX,mBAAmB,GACnB,QAAQ,GACR,iBAAiB,GACjB,iBAAiB,CAAC;AAErB,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,oEAAoE;IACpE,IAAI,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC7B,YAAY,CAAC,IAAI;QAAE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0FAA0F;IAC1F,IAAI,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IACjC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,iBAAiB,EAiD3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,GAAE,aAAkB,GAAG,oBAAoB,CAO3F;AAED,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,CAe7D"}

package/dist/two-d/render/Capabilities.js

@@ -1,129 +0,0 @@
-/**
- * The framework's rendering choices by workload. This is data, not a global renderer switch:
- * each game imports only the module it uses and keeps 2D Pixi and optional 3D Babylon paths
- * independent.
- *
- * @example
- * ```ts
- * import { RENDERING_DECISIONS } from '@datamoc/mw_games/two-d/render';
- *
- * const particles = RENDERING_DECISIONS.find((d) => d.workload === 'particles');
- * console.log(particles?.preferred); // 'PixiJS for 2D, Babylon.js for 3D'
- * ```
- */
-export const RENDERING_DECISIONS = [
-    {
-        workload: 'sprites',
-        preferred: 'PixiJS WebGL/WebGPU batcher',
-        fallback: 'PixiJS WebGL',
-        reason: 'high-volume textured 2D batches',
-    },
-    {
-        workload: 'ui',
-        preferred: 'PixiJS display tree',
-        fallback: 'PixiJS display tree',
-        reason: 'themeable 2D layout and text',
-    },
-    {
-        workload: 'custom-shaders',
-        preferred: 'backend-specific GLSL/WGSL only when profiled',
-        fallback: 'PixiJS filters',
-        reason: 'avoid maintaining paired shader sources without a measured gain',
-    },
-    {
-        workload: 'particles',
-        preferred: 'PixiJS for 2D, Babylon.js for 3D',
-        fallback: 'instanced sprites/meshes',
-        reason: 'match simulation and depth to the scene',
-    },
-    {
-        workload: 'instanced-terrain',
-        preferred: 'Babylon.js thin instances',
-        fallback: 'PixiJS TileMap for 2D',
-        reason: 'depth-tested repeated 3D geometry',
-    },
-    {
-        workload: 'voxels',
-        preferred: 'Babylon.js thin instances',
-        fallback: 'batched meshes',
-        reason: 'color-grouped 3D voxels',
-    },
-    {
-        workload: 'animated-models',
-        preferred: 'Babylon.js glTF animation groups',
-        fallback: 'billboard sprites',
-        reason: 'standard 3D interchange and animation support',
-    },
-    {
-        workload: 'large-3d-worlds',
-        preferred: 'Babylon.js with streaming/culling',
-        fallback: 'partitioned scenes',
-        reason: 'scene graph, depth, and instancing',
-    },
-];
-/**
- * Reports browser graphics APIs without creating a renderer or selecting a fallback.
- * Pass a probe in tests or host integrations; omitting it reads the current browser safely.
- *
- * `wgsl` cannot be checked synchronously - the only way to genuinely know a WGSL shader
- * compiles is `detectWebGpu`, which requests a real device and compiles one, and every step
- * of that is asynchronous. Rather than assume WGSL works just because `navigator.gpu`
- * exists (a browser can expose WebGPU behind a still-broken or disabled implementation),
- * this stays `false` unless a caller supplies a real result through `probe.wgsl`.
- *
- * @example
- * ```ts
- * import { inspectGraphicsCapabilities } from '@datamoc/mw_games/two-d/render';
- *
- * // reads the real browser when no probe is given
- * const here = inspectGraphicsCapabilities();
- *
- * // a fake probe, for a test or a host integration with no DOM
- * const capabilities = inspectGraphicsCapabilities({
- * 	createCanvas: () => ({ getContext: (kind) => (kind === 'webgl2' ? {} : null) }),
- * 	webgpu: false,
- * });
- * console.log(capabilities.webgl2); // true
- * console.log(capabilities.webgpu); // false
- * ```
- */
-export function inspectGraphicsCapabilities(probe = {}) {
-    const canvas = probe.createCanvas?.() ?? (typeof document === 'undefined' ? null : document.createElement('canvas'));
-    const webgl2 = Boolean(canvas?.getContext('webgl2'));
-    const webgl1 = webgl2 || Boolean(canvas?.getContext('webgl') ?? canvas?.getContext('experimental-webgl'));
-    const webgpu = probe.webgpu ?? Boolean(globalThis.navigator?.gpu);
-    return { webgl1, webgl2, webgpu, wgsl: probe.wgsl ?? false };
-}
-/**
- * The real, asynchronous WebGPU/WGSL check `inspectGraphicsCapabilities` cannot do
- * synchronously: requests an actual adapter and device, then compiles an actual shader
- * module and reads back its compilation diagnostics. Feed the result to
- * `inspectGraphicsCapabilities` via `probe.webgpu`/`probe.wgsl` once resolved.
- *
- * @example
- * ```ts
- * import { detectWebGpu, inspectGraphicsCapabilities } from '@datamoc/mw_games/two-d/render';
- *
- * const detected = await detectWebGpu();
- * const capabilities = inspectGraphicsCapabilities({ webgpu: detected.webgpu, wgsl: detected.wgsl });
- * console.log(capabilities.wgsl); // true only if a real WGSL shader actually compiled
- * ```
- */
-export async function detectWebGpu() {
-    const gpu = globalThis.navigator?.gpu;
-    if (!gpu)
-        return { webgpu: false, wgsl: false };
-    try {
-        const adapter = await gpu.requestAdapter();
-        const device = await adapter?.requestDevice();
-        if (!device)
-            return { webgpu: false, wgsl: false };
-        const shader = device.createShaderModule({ code: '@compute @workgroup_size(1) fn main() {}' });
-        const info = await shader.getCompilationInfo();
-        return { webgpu: true, wgsl: info.messages.length === 0 };
-    }
-    catch {
-        return { webgpu: false, wgsl: false };
-    }
-}
-//# sourceMappingURL=Capabilities.js.map

package/dist/two-d/render/Capabilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Capabilities.js","sourceRoot":"","sources":["../../../src/two-d/render/Capabilities.ts"],"names":[],"mappings":"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"}

package/dist/two-d/render/ClothSprite.d.ts

@@ -1,83 +0,0 @@
-import { MeshPlane } from 'pixi.js';
-import { type MotionIntent } from '../../core/Motion.ts';
-import type { Texture2D } from './Types2D.ts';
-/** Mesh density and simulation tuning for {@link ClothSprite}; the cloth spans the texture. */
-export interface ClothSpriteOptions {
-    /** quads across; an integer of at least 1, default 8 */
-    segmentsX?: number;
-    /** quads down; an integer of at least 1, default 8 */
-    segmentsY?: number;
-    /** how much of each constraint error one relaxation pass removes, 0 to 1; default 0.9 */
-    stiffness?: number;
-    /** share of velocity lost per update, 0 to 1; default 0.02 */
-    damping?: number;
-    /** acceleration in world units per second squared; default no gravity (a banner in still air) */
-    gravity?: {
-        x: number;
-        y: number;
-    };
-    /** acceleration in world units per second squared; default still air */
-    wind?: {
-        x: number;
-        y: number;
-    };
-    /** what the sway is for under reduced motion; default `decorative`, which holds the garment still */
-    intent?: MotionIntent;
-}
-/**
- * A garment that follows with a slight lag: a `Cloth` simulation driving a textured mesh
- * on the GPU path 414 ships (roadmap 423). The cloth spans the texture, the top edge
- * starts pinned (a waistband, a held scarf end), and `update(dt)` steps the simulation
- * and re-uploads the vertex buffer; UVs are never rewritten and the sprite itself is
- * never rotated, so a skirt bends while its print stays printed. Pin more points to hang
- * it, unpin to let it fall, and drive `setWind` from the weather or the run cycle.
- *
- * @example
- * ```ts
- * import { ClothSprite } from '@datamoc/mw_games/two-d/render';
- * import type { Texture2D } from '@datamoc/mw_games/two-d/render';
- *
- * declare const tunicTexture: Texture2D;
- *
- * const tunic = new ClothSprite(tunicTexture, { segmentsX: 6, segmentsY: 8, gravity: { x: 0, y: 900 } });
- * tunic.update(1 / 60); // the hem answers gravity, the waistband stays pinned
- * console.log(tunic.movedCount()); // > 0 - everything below the pinned edge travelled
- * ```
- */
-export declare class ClothSprite extends MeshPlane {
-    private readonly cloth;
-    private readonly intent;
-    constructor(texture: Texture2D, options?: ClothSpriteOptions);
-    /** quads across */
-    get segmentsX(): number;
-    /** quads down */
-    get segmentsY(): number;
-    /** how many simulated points the mesh holds */
-    get pointCount(): number;
-    /** the flat index of the point at `(column, row)` */
-    indexOf(column: number, row: number): number;
-    /** the current position of one mesh point */
-    pointPosition(index: number): {
-        x: number;
-        y: number;
-    };
-    /** whether a point is pinned */
-    isPinned(index: number): boolean;
-    /** how many points currently sit away from their rest positions */
-    movedCount(): number;
-    /** pin a point where it currently stands */
-    pinPoint(index: number): void;
-    /** release a pinned point; it keeps its current position and moves from there */
-    unpinPoint(index: number): void;
-    /** replace the wind acceleration */
-    setWind(x: number, y: number): void;
-    /** replace the gravity acceleration */
-    setGravity(x: number, y: number): void;
-    /**
-     * Step the cloth and re-upload the vertex buffer. Under reduced motion a decorative
-     * garment holds its shape instead of swaying.
-     */
-    update(dt: number): void;
-    private sync;
-}
-//# sourceMappingURL=ClothSprite.d.ts.map

package/dist/two-d/render/ClothSprite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClothSprite.d.ts","sourceRoot":"","sources":["../../../src/two-d/render/ClothSprite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,+FAA+F;AAC/F,MAAM,WAAW,kBAAkB;IAClC,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,OAAO,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,wEAAwE;IACxE,IAAI,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,qGAAqG;IACrG,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAEtC,YAAY,OAAO,EAAE,SAAS,EAAE,OAAO,GAAE,kBAAuB,EAmB/D;IAED,mBAAmB;IACnB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,iBAAiB;IACjB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,+CAA+C;IAC/C,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,qDAAqD;IACrD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;IAED,6CAA6C;IAC7C,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAErD;IAED,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED,mEAAmE;IACnE,UAAU,IAAI,MAAM,CAEnB;IAED,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE5B;IAED,iFAAiF;IACjF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,oCAAoC;IACpC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAElC;IAED,uCAAuC;IACvC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAErC;IAED;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIvB;IAED,OAAO,CAAC,IAAI;CAKZ"}

package/dist/two-d/render/ClothSprite.js

@@ -1,105 +0,0 @@
-import { MeshPlane } from 'pixi.js';
-import { Cloth } from '../../physics/cloth/index.js';
-import { reducedMotion } from '../../core/Motion.js';
-/**
- * A garment that follows with a slight lag: a `Cloth` simulation driving a textured mesh
- * on the GPU path 414 ships (roadmap 423). The cloth spans the texture, the top edge
- * starts pinned (a waistband, a held scarf end), and `update(dt)` steps the simulation
- * and re-uploads the vertex buffer; UVs are never rewritten and the sprite itself is
- * never rotated, so a skirt bends while its print stays printed. Pin more points to hang
- * it, unpin to let it fall, and drive `setWind` from the weather or the run cycle.
- *
- * @example
- * ```ts
- * import { ClothSprite } from '@datamoc/mw_games/two-d/render';
- * import type { Texture2D } from '@datamoc/mw_games/two-d/render';
- *
- * declare const tunicTexture: Texture2D;
- *
- * const tunic = new ClothSprite(tunicTexture, { segmentsX: 6, segmentsY: 8, gravity: { x: 0, y: 900 } });
- * tunic.update(1 / 60); // the hem answers gravity, the waistband stays pinned
- * console.log(tunic.movedCount()); // > 0 - everything below the pinned edge travelled
- * ```
- */
-export class ClothSprite extends MeshPlane {
-    constructor(texture, options = {}) {
-        const segmentsX = options.segmentsX ?? 8;
-        const segmentsY = options.segmentsY ?? 8;
-        const cloth = new Cloth({
-            width: texture.width,
-            height: texture.height,
-            segmentsX,
-            segmentsY,
-            stiffness: options.stiffness,
-            damping: options.damping,
-            gravity: options.gravity,
-            wind: options.wind,
-        });
-        super({ texture, verticesX: segmentsX + 1, verticesY: segmentsY + 1 });
-        this.cloth = cloth;
-        this.intent = options.intent ?? 'decorative';
-        //a later texture resize must not rebuild the plane under the simulation
-        this.autoResize = false;
-        this.sync();
-    }
-    /** quads across */
-    get segmentsX() {
-        return this.cloth.segmentsX;
-    }
-    /** quads down */
-    get segmentsY() {
-        return this.cloth.segmentsY;
-    }
-    /** how many simulated points the mesh holds */
-    get pointCount() {
-        return this.cloth.pointCount;
-    }
-    /** the flat index of the point at `(column, row)` */
-    indexOf(column, row) {
-        return this.cloth.indexOf(column, row);
-    }
-    /** the current position of one mesh point */
-    pointPosition(index) {
-        return this.cloth.pointPosition(index);
-    }
-    /** whether a point is pinned */
-    isPinned(index) {
-        return this.cloth.isPinned(index);
-    }
-    /** how many points currently sit away from their rest positions */
-    movedCount() {
-        return this.cloth.movedCount();
-    }
-    /** pin a point where it currently stands */
-    pinPoint(index) {
-        this.cloth.pinPoint(index);
-    }
-    /** release a pinned point; it keeps its current position and moves from there */
-    unpinPoint(index) {
-        this.cloth.unpinPoint(index);
-    }
-    /** replace the wind acceleration */
-    setWind(x, y) {
-        this.cloth.setWind(x, y);
-    }
-    /** replace the gravity acceleration */
-    setGravity(x, y) {
-        this.cloth.setGravity(x, y);
-    }
-    /**
-     * Step the cloth and re-upload the vertex buffer. Under reduced motion a decorative
-     * garment holds its shape instead of swaying.
-     */
-    update(dt) {
-        if (reducedMotion() && this.intent === 'decorative')
-            return;
-        this.cloth.update(dt);
-        this.sync();
-    }
-    sync() {
-        const attribute = this.geometry.getAttribute('aPosition');
-        this.cloth.writePositions(attribute.buffer.data);
-        attribute.buffer.update();
-    }
-}
-//# sourceMappingURL=ClothSprite.js.map

package/dist/two-d/render/ClothSprite.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClothSprite.js","sourceRoot":"","sources":["../../../src/two-d/render/ClothSprite.ts"],"names":[],"mappings":"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"}

package/dist/two-d/render/ColorBlindness.d.ts

@@ -1,39 +0,0 @@
-import { ColorMatrixFilter } from 'pixi.js';
-import type { ColorMatrix } from 'pixi.js';
-export type ColorBlindnessType = 'protanopia' | 'deuteranopia' | 'tritanopia';
-/**
- * Brettel/Viénot-derived simulation matrices, the same values widely used by colourblindness
- * simulators - a 5x4 (20-value) row-major RGBA matrix, Pixi's own `ColorMatrixFilter` format.
- * Exported so the matrix data itself can be tested without constructing a `ColorMatrixFilter`,
- * which (like `BitmapText`) needs a real WebGL context even to construct.
- *
- * @example
- * ```ts
- * import { COLOR_BLINDNESS_MATRICES } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(COLOR_BLINDNESS_MATRICES.deuteranopia.length); // 20
- * ```
- */
-export declare const COLOR_BLINDNESS_MATRICES: Record<ColorBlindnessType, ColorMatrix>;
-/**
- * A whole-scene filter simulating one of the three common types of colour vision deficiency.
- * Assign the result to a container's `.filters` (typically a game's whole stage), the same
- * way any Pixi filter is applied - nothing here is `mwg`-specific beyond the named matrices.
- *
- * This simulates, showing a sighted developer what a colourblind player sees - the standard
- * first step toward choosing a palette that reads clearly for them. It does not correct an
- * existing palette automatically; that would need the source colours' own intent (which one
- * is the "danger" colour, say), not just their RGB values.
- *
- * @example
- * ```ts
- * import { createColorBlindnessFilter } from '@datamoc/mw_games/two-d/render';
- * import type { Container2D } from '@datamoc/mw_games/two-d/render';
- *
- * declare const stage: Container2D;
- *
- * stage.filters = [createColorBlindnessFilter('deuteranopia')];
- * ```
- */
-export declare function createColorBlindnessFilter(type: ColorBlindnessType): ColorMatrixFilter;
-//# sourceMappingURL=ColorBlindness.d.ts.map

package/dist/two-d/render/ColorBlindness.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ColorBlindness.d.ts","sourceRoot":"","sources":["../../../src/two-d/render/ColorBlindness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,cAAc,GAAG,YAAY,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAI5E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,CAItF"}

package/dist/two-d/render/ColorBlindness.js

@@ -1,45 +0,0 @@
-import { ColorMatrixFilter } from 'pixi.js';
-/**
- * Brettel/Viénot-derived simulation matrices, the same values widely used by colourblindness
- * simulators - a 5x4 (20-value) row-major RGBA matrix, Pixi's own `ColorMatrixFilter` format.
- * Exported so the matrix data itself can be tested without constructing a `ColorMatrixFilter`,
- * which (like `BitmapText`) needs a real WebGL context even to construct.
- *
- * @example
- * ```ts
- * import { COLOR_BLINDNESS_MATRICES } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(COLOR_BLINDNESS_MATRICES.deuteranopia.length); // 20
- * ```
- */
-export const COLOR_BLINDNESS_MATRICES = {
-    protanopia: [0.567, 0.433, 0, 0, 0, 0.558, 0.442, 0, 0, 0, 0, 0.242, 0.758, 0, 0, 0, 0, 0, 1, 0],
-    deuteranopia: [0.625, 0.375, 0, 0, 0, 0.7, 0.3, 0, 0, 0, 0, 0.3, 0.7, 0, 0, 0, 0, 0, 1, 0],
-    tritanopia: [0.95, 0.05, 0, 0, 0, 0, 0.433, 0.567, 0, 0, 0, 0.475, 0.525, 0, 0, 0, 0, 0, 1, 0],
-};
-/**
- * A whole-scene filter simulating one of the three common types of colour vision deficiency.
- * Assign the result to a container's `.filters` (typically a game's whole stage), the same
- * way any Pixi filter is applied - nothing here is `mwg`-specific beyond the named matrices.
- *
- * This simulates, showing a sighted developer what a colourblind player sees - the standard
- * first step toward choosing a palette that reads clearly for them. It does not correct an
- * existing palette automatically; that would need the source colours' own intent (which one
- * is the "danger" colour, say), not just their RGB values.
- *
- * @example
- * ```ts
- * import { createColorBlindnessFilter } from '@datamoc/mw_games/two-d/render';
- * import type { Container2D } from '@datamoc/mw_games/two-d/render';
- *
- * declare const stage: Container2D;
- *
- * stage.filters = [createColorBlindnessFilter('deuteranopia')];
- * ```
- */
-export function createColorBlindnessFilter(type) {
-    const filter = new ColorMatrixFilter();
-    filter.matrix = COLOR_BLINDNESS_MATRICES[type];
-    return filter;
-}
-//# sourceMappingURL=ColorBlindness.js.map

package/dist/two-d/render/ColorBlindness.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ColorBlindness.js","sourceRoot":"","sources":["../../../src/two-d/render/ColorBlindness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAK5C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAA4C;IAChF,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAChG,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC1F,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAC9F,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,0BAA0B,CAAC,IAAwB;IAClE,MAAM,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;IACvC,MAAM,CAAC,MAAM,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAC/C,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/two-d/render/ColorTransformBatcher.d.ts

@@ -1,143 +0,0 @@
-import { Batcher, ExtensionType, Geometry, Shader } from 'pixi.js';
-import type { BatchableMeshElement, BatchableQuadElement, BatcherOptions, Matrix } from 'pixi.js';
-/**
- * The fields the runtime elements carry but the published types omit.
- *
- * Pixi's own DefaultBatcher is untyped JavaScript, so these never had to be declared. They
- * are read here exactly as DefaultBatcher reads them.
- */
-interface PackedElement {
-    transform: Matrix;
-    color: number;
-    roundPixels: number;
-    colorAdd?: number;
-}
-type MeshElement = BatchableMeshElement & PackedElement;
-type QuadElement = BatchableQuadElement & PackedElement;
-/**
- * Carries the additive colour for one renderable.
- *
- * Anything drawn through this batcher may set `colorAdd` on itself; anything that does not
- * is packed with zero and renders exactly as it would have with the default batcher.
- *
- * @example
- * ```ts
- * import type { HasColorAdd } from '@datamoc/mw_games/two-d/render';
- * import { packColorAdd } from '@datamoc/mw_games/two-d/render';
- *
- * function tintTowardsWhite(renderable: HasColorAdd, strength: number): void {
- * 	renderable.colorAdd = packColorAdd(strength, strength, strength);
- * }
- * ```
- */
-export interface HasColorAdd {
-    /** additive colour, packed as 0xAABBGGRR to match the attribute's byte order */
-    colorAdd?: number;
-}
-/**
- * The Pixi batcher extension `TintedSprite` (and everything built on it) renders through -
- * see the module doc comment above for what it adds and why.
- *
- * @example
- * ```ts
- * import { ColorTransformBatcher } from '@datamoc/mw_games/two-d/render';
- *
- * // registered automatically by TintedSprite.ts; naming the class directly is only ever
- * // needed to check which batcher an object ended up in, or in Pixi extension diagnostics
- * console.log(ColorTransformBatcher.extension.name); // 'mwg-color-transform'
- * ```
- */
-export declare class ColorTransformBatcher extends Batcher {
-    /** @internal */
-    static extension: {
-        readonly type: readonly [ExtensionType.Batcher];
-        readonly name: 'mwg-color-transform';
-    };
-    geometry: Geometry;
-    shader: Shader;
-    name: "mwg-color-transform";
-    vertexSize: number;
-    constructor(options: BatcherOptions);
-    packAttributes(element: MeshElement, float32View: Float32Array, uint32View: Uint32Array, index: number, textureId: number): void;
-    packQuadAttributes(element: QuadElement, float32View: Float32Array, uint32View: Uint32Array, index: number, textureId: number): void;
-    /** @internal - Pixi calls this when the device's texture limit is known */
-    _updateMaxTextures(maxTextures: number): void;
-    destroy(): void;
-}
-/**
- * Points a sprite at this batcher's pipe. Pixi chooses a sprite's batcher from its
- * `renderPipeId` field, a Pixi internal, so this write lives here rather than in
- * `TintedSprite` - every batchable and render-pipe detail stays in this one file, which is
- * what the confinement rule promises.
- */
-export declare function useColorTransformPipe(sprite: object): void;
-/**
- * Registers the colour-transform batcher and the `TintedSprite` pipe with Pixi.
- *
- * `TintedSprite.ts` calls this itself, at module scope, the moment anything imports it
- * (directly, or transitively through `AnimatedSprite`/`TileMap`/`DialogueStage`, all built on
- * it) - registration has to happen before the renderer is created, and an ES module's
- * top-level code always runs before whatever imports it goes on to call `new Game()`/
- * `Game.start()`, so a game never has to know this pipe exists, let alone pass it through
- * `GameOptions.extensions` itself. This stays exported, idempotent (`registered` guards a
- * second call from double-adding it), and public for the rare case of a game building its
- * own renderer setup outside `Game`.
- *
- * @example
- * ```ts
- * import { registerColorTransform } from '@datamoc/mw_games/two-d/render';
- *
- * // a game that assembles its own Pixi renderer extensions manually, instead of going
- * // through `Game`/`GameOptions.extensions`, registers the batcher itself before creating
- * // that renderer - importing `TintedSprite` (directly or transitively) already does this,
- * // so most games never call it
- * registerColorTransform();
- * ```
- */
-export declare function registerColorTransform(): void;
-/**
- * Packs an additive colour into the form the attribute expects.
- *
- * @param r red, 0 to 1
- * @param g green, 0 to 1
- * @param b blue, 0 to 1
- * @param a how much to add to the sprite's own alpha, 0 to 1; usually 0
- *
- * @example
- * ```ts
- * import { packColorAdd } from '@datamoc/mw_games/two-d/render';
- * import { TintedSprite } from '@datamoc/mw_games/two-d/render';
- *
- * declare const rat: TintedSprite;
- *
- * rat.colorAdd = packColorAdd(0, 1, 0); // pull the sprite towards pure green
- * ```
- */
-export declare function packColorAdd(r: number, g: number, b: number, a?: number): number;
-/** the additive half of `lerp(texel, colour, strength)`; pair with a tint of `1 - strength`
- *
- * @example
- * ```ts
- * import { packTintAdd, TintedSprite } from '@datamoc/mw_games/two-d/render';
- *
- * declare const rat: TintedSprite;
- *
- * rat.colorAdd = packTintAdd(0x00ff00, 0.5); // half-way to green, the additive half of lerpTint
- * rat.tint = 0x808080; // pair with 1 - strength (here 0.5) for the multiply half
- * ```
- */
-export declare function packTintAdd(color: number, strength: number): number;
-/** the packed value of no additive colour at all - what an untinted sprite carries.
- *
- * @example
- * ```ts
- * import { NO_COLOR_ADD, TintedSprite } from '@datamoc/mw_games/two-d/render';
- *
- * declare const rat: TintedSprite;
- *
- * console.log(rat.colorAdd === NO_COLOR_ADD); // true - fresh sprites start with no additive colour
- * ```
- */
-export declare const NO_COLOR_ADD = 0;
-export {};
-//# sourceMappingURL=ColorTransformBatcher.d.ts.map