@woosh/meep-engine 3.11.2 → 3.12.0

package/src/engine/graphics3/FogOfWarSystem.js

@@ -0,0 +1,265 @@
+import { assert } from "../../core/assert.js";
+import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
+import { GPUFogOfWarRenderer } from "../../shade/renderer/fow/GPUFogOfWarRenderer.js";
+import { HighlightExtension } from "./HighlightSystem.js";
+import { ParticleExtension } from "./ParticleEmitterSystem.js";
+import { PathDisplayExtension } from "./PathDisplaySystem.js";
+import { TrailExtension } from "./Trail3DSystem.js";
+import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
+import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
+import { SceneColor } from "../../shade/renderer/extension/SceneColor.js";
+import { ViewTextures } from "../../shade/renderer/extension/ViewTextures.js";
+import { FogOfWar } from "../ecs/fow/FogOfWar.js";
+import { FogOfWarEdgeMode } from "../ecs/fow/FogOfWarEdgeMode.js";
+import { computeUvTransformFromFogOfWar } from "../ecs/fow/fog_of_war_uv_transform.js";
+import Terrain from "../ecs/terrain/ecs/Terrain.js";
+import { System } from "../ecs/System.js";
+
+/**
+ * Draws the level's fog of war under Shade.
+ *
+ * **The mask stays where it was.** `FogOfWar` owns a CPU `Sampler2D` and a distance field, and every
+ * gameplay query — what a unit can see, what the AI may know, whether an entity is drawn at all —
+ * reads them. None of that moves to the GPU; the renderer is handed the same array, as a texture.
+ *
+ * **The composite is a pass at {@link FramePhase.AfterTransparency}.** That is the last phase where
+ * the frame's colour and its depth are the same size — after it the image is upscaled to the output
+ * resolution while the depth buffer stays at the internal one — and the fog is a screen-space read
+ * of depth, so the two have to agree texel for texel. It also puts the fog inside the tonemapper
+ * rather than over it, which is what the phase is for.
+ */
+export class FogOfWarSystem extends System {
+    dependencies = [FogOfWar, Terrain];
+
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {GPUFogOfWarRenderer}
+     */
+    #renderer = new GPUFogOfWarRenderer();
+
+    /**
+     * What the pass draws. A level has one fog field; the array is what makes "none" a state rather
+     * than a special case.
+     *
+     * @type {FogField[]}
+     */
+    #fields = [];
+
+    /**
+     * @type {Map<number, FogField>}
+     */
+    #entries = new Map();
+
+    /**
+     * @type {RenderExtension|null}
+     */
+    #extension = null;
+
+    /**
+     * What the pass draws. Read-only — the fields follow the entities.
+     *
+     * @returns {FogField[]}
+     */
+    get fields() {
+        return this.#fields;
+    }
+
+    /**
+     * @param {GraphicsEngine} graphics
+     */
+    constructor(graphics) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+
+        this.#graphics = graphics;
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        this.#extension = this.#graphics.add_extension(new FogOfWarExtension(this));
+    }
+
+    async shutdown(entityManager) {
+        if (this.#extension !== null) {
+            this.#graphics.remove_extension(this.#extension);
+
+            this.#extension = null;
+        }
+
+        for (const field of this.#entries.values()) {
+            field.binding.unlink();
+        }
+
+        this.#fields.length = 0;
+        this.#entries.clear();
+
+        this.#renderer.destroy();
+    }
+
+    /**
+     * @param {FrameContext} frame
+     */
+    record(frame) {
+        const fields = this.#fields;
+
+        if (fields.length === 0) {
+            // nothing to conceal, and the frame's colour is left exactly as it was
+            return;
+        }
+
+        const scene = frame.get(SceneColor);
+        const depth = frame.get(ViewTextures).depth;
+
+        let color = scene.color;
+
+        for (let i = 0; i < fields.length; i++) {
+            color = this.#renderer.graph_draw({
+                graph: frame.graph,
+                color,
+                depth,
+                camera: frame.view.camera.buffer,
+                field: fields[i]
+            });
+        }
+
+        scene.color = color;
+    }
+
+    /**
+     * @param {FogOfWar} fow
+     * @param {Terrain} terrain
+     * @param {number} entity
+     */
+    link(fow, terrain, entity) {
+        // the fog covers the terrain, cell for cell — the same sizing the legacy system does
+        fow.resize(terrain.size.x, terrain.size.y, terrain.gridScale);
+
+        const field = {
+            sampler: fow.sampler,
+            uv_transform: new Float32Array(4),
+            color: new Float32Array(4),
+            edge_extend: 0,
+            // nothing has been uploaded yet, so the first frame is a change by definition
+            dirty: true,
+            component: fow,
+            binding: null
+        };
+
+        /*
+         The component announces a changed mask rather than the mask being polled for one: it writes
+         into its sampler's array in place — a fill for a conceal, a cell at a time for a fade — so
+         there is nothing about the array itself that moves when the field does.
+        */
+        field.binding = SignalBinding.bind(fow.on.textureChanged, () => {
+            field.dirty = true;
+        });
+
+        this.#refresh(field, fow);
+
+        this.#entries.set(entity, field);
+        this.#fields.push(field);
+    }
+
+    /**
+     * @param {FogOfWar} fow
+     * @param {Terrain} terrain
+     * @param {number} entity
+     */
+    unlink(fow, terrain, entity) {
+        const field = this.#entries.get(entity);
+
+        if (field === undefined) {
+            return;
+        }
+
+        field.binding.unlink();
+
+        const index = this.#fields.indexOf(field);
+
+        if (index !== -1) {
+            this.#fields.splice(index, 1);
+        }
+
+        this.#entries.delete(entity);
+    }
+
+    update(timeDelta) {
+        for (const field of this.#entries.values()) {
+            const fow = field.component;
+
+            // advances the reveal fades and rebuilds the mask when one moved
+            fow.update(timeDelta);
+
+            this.#refresh(field, fow);
+        }
+    }
+
+    /**
+     * Copy the component's authored values across.
+     *
+     * @param {FogField} field
+     * @param {FogOfWar} fow
+     */
+    #refresh(field, fow) {
+        // the sampler is reallocated by `resize`, so the field follows it rather than holding one
+        field.sampler = fow.sampler;
+
+        computeUvTransformFromFogOfWar(fow, (offset_x, offset_y, scale_x, scale_y) => {
+            field.uv_transform[0] = offset_x;
+            field.uv_transform[1] = offset_y;
+            field.uv_transform[2] = scale_x;
+            field.uv_transform[3] = scale_y;
+        });
+
+        const color = fow.color;
+
+        field.color[0] = color.x;
+        field.color[1] = color.y;
+        field.color[2] = color.z;
+        field.color[3] = color.w;
+
+        field.edge_extend = fow.edge_mode === FogOfWarEdgeMode.Extend ? 1 : 0;
+    }
+}
+
+/**
+ * **Last among the content extensions**, because the fog conceals and therefore belongs over
+ * everything it is meant to conceal — particles, trails, the path display and the selection
+ * highlight all draw before it and are all subject to it. Written down here rather than being a
+ * property of where a registration call happened to sit, which is how it came to be wrong.
+ *
+ * The declaration is stated from this side, over the content extensions, so that adding another one
+ * is a change to that extension and not to this list. {@link DebugDrawExtension} is the one thing
+ * that goes after the fog, and it says so itself.
+ */
+export class FogOfWarExtension extends RenderExtension {
+    name = "fog of war";
+
+    phase = FramePhase.AfterTransparency;
+
+    after = [ParticleExtension, PathDisplayExtension, TrailExtension, HighlightExtension];
+
+    /**
+     * @type {FogOfWarSystem}
+     */
+    #system;
+
+    /**
+     * @param {FogOfWarSystem} system
+     */
+    constructor(system) {
+        super();
+
+        this.#system = system;
+    }
+
+    record(frame) {
+        this.#system.record(frame);
+    }
+}

package/src/engine/graphics3/FogOfWarSystem3.d.ts

@@ -1,74 +1,10 @@
 /**
- * Draws the level's fog of war under Shade.
+ * @deprecated Renamed to {@link FogOfWarSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * **The mask stays where it was.** `FogOfWar` owns a CPU `Sampler2D` and a distance field, and every
- * gameplay query — what a unit can see, what the AI may know, whether an entity is drawn at all —
- * reads them. None of that moves to the GPU; the renderer is handed the same array, as a texture.
- *
- * **The composite is a pass at {@link FramePhase.AfterTransparency}.** That is the last phase where
- * the frame's colour and its depth are the same size — after it the image is upscaled to the output
- * resolution while the depth buffer stays at the internal one — and the fog is a screen-space read
- * of depth, so the two have to agree texel for texel. It also puts the fog inside the tonemapper
- * rather than over it, which is what the phase is for.
- */
-export class FogOfWarSystem3 extends System<any> {
-    /**
-     * @param {GraphicsEngine3} graphics
-     */
-    constructor(graphics: GraphicsEngine3);
-    dependencies: (typeof Terrain | typeof FogOfWar)[];
-    /**
-     * What the pass draws. Read-only — the fields follow the entities.
-     *
-     * @returns {FogField[]}
-     */
-    get fields(): FogField[];
-    startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame: FrameContext): void;
-    /**
-     * @param {FogOfWar} fow
-     * @param {Terrain} terrain
-     * @param {number} entity
-     */
-    link(fow: FogOfWar, terrain: Terrain, entity: number): void;
-    /**
-     * @param {FogOfWar} fow
-     * @param {Terrain} terrain
-     * @param {number} entity
-     */
-    unlink(fow: FogOfWar, terrain: Terrain, entity: number): void;
-    update(timeDelta: any): void;
-    #private;
-}
-/**
- * **Last among the content extensions**, because the fog conceals and therefore belongs over
- * everything it is meant to conceal — particles, trails, the path display and the selection
- * highlight all draw before it and are all subject to it. Written down here rather than being a
- * property of where a registration call happened to sit, which is how it came to be wrong.
- *
- * The declaration is stated from this side, over the content extensions, so that adding another one
- * is a change to that extension and not to this list. {@link DebugDrawExtension} is the one thing
- * that goes after the fog, and it says so itself.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class FogOfWarExtension extends RenderExtension {
-    /**
-     * @param {FogOfWarSystem3} system
-     */
-    constructor(system: FogOfWarSystem3);
-    after: (typeof HighlightExtension | typeof ParticleExtension | typeof PathDisplayExtension | typeof TrailExtension)[];
-    record(frame: any): void;
-    #private;
-}
-import { System } from "../ecs/System.js";
-import Terrain from "../ecs/terrain/ecs/Terrain.js";
-import { FogOfWar } from "../ecs/fow/FogOfWar.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { HighlightExtension } from "./HighlightSystem3.js";
-import { ParticleExtension } from "./ParticleEmitterSystem3.js";
-import { PathDisplayExtension } from "./PathDisplaySystem3.js";
-import { TrailExtension } from "./Trail3DSystem3.js";
+export const FogOfWarSystem3: typeof FogOfWarSystem;
+import { FogOfWarSystem } from "./FogOfWarSystem.js";
 //# sourceMappingURL=FogOfWarSystem3.d.ts.map

package/src/engine/graphics3/FogOfWarSystem3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/FogOfWarSystem3.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH;IAwCI;;OAEG;IACH,uCAMC;IAhDD,mDAAmC;IA8BnC;;;;OAIG;IACH,yBAEC;IAaD,2CAIC;IAED,4CAeC;IAED;;OAEG;IACH,kCAwBC;IAED;;;;OAIG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QA8BhB;IAED;;;;OAIG;IACH,YAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAkBhB;IAED,6BASC;;CA4BJ;AAED;;;;;;;;;GASG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAdD,sHAAsF;IAgBtF,yBAEC;;CACJ;uBAzPsB,kBAAkB;oBADrB,+BAA+B;yBAH1B,wBAAwB;gCAHjB,mDAAmD;mCALhD,uBAAuB;kCACxB,6BAA6B;qCAC1B,yBAAyB;+BAC/B,qBAAqB"}
+{"version":3,"file":"FogOfWarSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/FogOfWarSystem3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,oDAA8C;+BATf,qBAAqB"}

package/src/engine/graphics3/FogOfWarSystem3.js

@@ -1,265 +1,10 @@
-import { assert } from "../../core/assert.js";
-import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
-import { GPUFogOfWarRenderer } from "../../shade/renderer/fow/GPUFogOfWarRenderer.js";
-import { HighlightExtension } from "./HighlightSystem3.js";
-import { ParticleExtension } from "./ParticleEmitterSystem3.js";
-import { PathDisplayExtension } from "./PathDisplaySystem3.js";
-import { TrailExtension } from "./Trail3DSystem3.js";
-import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { SceneColor } from "../../shade/renderer/extension/SceneColor.js";
-import { ViewTextures } from "../../shade/renderer/extension/ViewTextures.js";
-import { FogOfWar } from "../ecs/fow/FogOfWar.js";
-import { FogOfWarEdgeMode } from "../ecs/fow/FogOfWarEdgeMode.js";
-import { computeUvTransformFromFogOfWar } from "../ecs/fow/fog_of_war_uv_transform.js";
-import Terrain from "../ecs/terrain/ecs/Terrain.js";
-import { System } from "../ecs/System.js";
+import { FogOfWarSystem } from "./FogOfWarSystem.js";
 
 /**
- * Draws the level's fog of war under Shade.
+ * @deprecated Renamed to {@link FogOfWarSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * **The mask stays where it was.** `FogOfWar` owns a CPU `Sampler2D` and a distance field, and every
- * gameplay query — what a unit can see, what the AI may know, whether an entity is drawn at all —
- * reads them. None of that moves to the GPU; the renderer is handed the same array, as a texture.
- *
- * **The composite is a pass at {@link FramePhase.AfterTransparency}.** That is the last phase where
- * the frame's colour and its depth are the same size — after it the image is upscaled to the output
- * resolution while the depth buffer stays at the internal one — and the fog is a screen-space read
- * of depth, so the two have to agree texel for texel. It also puts the fog inside the tonemapper
- * rather than over it, which is what the phase is for.
- */
-export class FogOfWarSystem3 extends System {
-    dependencies = [FogOfWar, Terrain];
-
-    /**
-     * @type {GraphicsEngine3}
-     */
-    #graphics;
-
-    /**
-     * @type {GPUFogOfWarRenderer}
-     */
-    #renderer = new GPUFogOfWarRenderer();
-
-    /**
-     * What the pass draws. A level has one fog field; the array is what makes "none" a state rather
-     * than a special case.
-     *
-     * @type {FogField[]}
-     */
-    #fields = [];
-
-    /**
-     * @type {Map<number, FogField>}
-     */
-    #entries = new Map();
-
-    /**
-     * @type {RenderExtension|null}
-     */
-    #extension = null;
-
-    /**
-     * What the pass draws. Read-only — the fields follow the entities.
-     *
-     * @returns {FogField[]}
-     */
-    get fields() {
-        return this.#fields;
-    }
-
-    /**
-     * @param {GraphicsEngine3} graphics
-     */
-    constructor(graphics) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-
-        this.#graphics = graphics;
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#extension = this.#graphics.add_extension(new FogOfWarExtension(this));
-    }
-
-    async shutdown(entityManager) {
-        if (this.#extension !== null) {
-            this.#graphics.remove_extension(this.#extension);
-
-            this.#extension = null;
-        }
-
-        for (const field of this.#entries.values()) {
-            field.binding.unlink();
-        }
-
-        this.#fields.length = 0;
-        this.#entries.clear();
-
-        this.#renderer.destroy();
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame) {
-        const fields = this.#fields;
-
-        if (fields.length === 0) {
-            // nothing to conceal, and the frame's colour is left exactly as it was
-            return;
-        }
-
-        const scene = frame.get(SceneColor);
-        const depth = frame.get(ViewTextures).depth;
-
-        let color = scene.color;
-
-        for (let i = 0; i < fields.length; i++) {
-            color = this.#renderer.graph_draw({
-                graph: frame.graph,
-                color,
-                depth,
-                camera: frame.view.camera.buffer,
-                field: fields[i]
-            });
-        }
-
-        scene.color = color;
-    }
-
-    /**
-     * @param {FogOfWar} fow
-     * @param {Terrain} terrain
-     * @param {number} entity
-     */
-    link(fow, terrain, entity) {
-        // the fog covers the terrain, cell for cell — the same sizing the legacy system does
-        fow.resize(terrain.size.x, terrain.size.y, terrain.gridScale);
-
-        const field = {
-            sampler: fow.sampler,
-            uv_transform: new Float32Array(4),
-            color: new Float32Array(4),
-            edge_extend: 0,
-            // nothing has been uploaded yet, so the first frame is a change by definition
-            dirty: true,
-            component: fow,
-            binding: null
-        };
-
-        /*
-         The component announces a changed mask rather than the mask being polled for one: it writes
-         into its sampler's array in place — a fill for a conceal, a cell at a time for a fade — so
-         there is nothing about the array itself that moves when the field does.
-        */
-        field.binding = SignalBinding.bind(fow.on.textureChanged, () => {
-            field.dirty = true;
-        });
-
-        this.#refresh(field, fow);
-
-        this.#entries.set(entity, field);
-        this.#fields.push(field);
-    }
-
-    /**
-     * @param {FogOfWar} fow
-     * @param {Terrain} terrain
-     * @param {number} entity
-     */
-    unlink(fow, terrain, entity) {
-        const field = this.#entries.get(entity);
-
-        if (field === undefined) {
-            return;
-        }
-
-        field.binding.unlink();
-
-        const index = this.#fields.indexOf(field);
-
-        if (index !== -1) {
-            this.#fields.splice(index, 1);
-        }
-
-        this.#entries.delete(entity);
-    }
-
-    update(timeDelta) {
-        for (const field of this.#entries.values()) {
-            const fow = field.component;
-
-            // advances the reveal fades and rebuilds the mask when one moved
-            fow.update(timeDelta);
-
-            this.#refresh(field, fow);
-        }
-    }
-
-    /**
-     * Copy the component's authored values across.
-     *
-     * @param {FogField} field
-     * @param {FogOfWar} fow
-     */
-    #refresh(field, fow) {
-        // the sampler is reallocated by `resize`, so the field follows it rather than holding one
-        field.sampler = fow.sampler;
-
-        computeUvTransformFromFogOfWar(fow, (offset_x, offset_y, scale_x, scale_y) => {
-            field.uv_transform[0] = offset_x;
-            field.uv_transform[1] = offset_y;
-            field.uv_transform[2] = scale_x;
-            field.uv_transform[3] = scale_y;
-        });
-
-        const color = fow.color;
-
-        field.color[0] = color.x;
-        field.color[1] = color.y;
-        field.color[2] = color.z;
-        field.color[3] = color.w;
-
-        field.edge_extend = fow.edge_mode === FogOfWarEdgeMode.Extend ? 1 : 0;
-    }
-}
-
-/**
- * **Last among the content extensions**, because the fog conceals and therefore belongs over
- * everything it is meant to conceal — particles, trails, the path display and the selection
- * highlight all draw before it and are all subject to it. Written down here rather than being a
- * property of where a registration call happened to sit, which is how it came to be wrong.
- *
- * The declaration is stated from this side, over the content extensions, so that adding another one
- * is a change to that extension and not to this list. {@link DebugDrawExtension} is the one thing
- * that goes after the fog, and it says so itself.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class FogOfWarExtension extends RenderExtension {
-    name = "fog of war";
-
-    phase = FramePhase.AfterTransparency;
-
-    after = [ParticleExtension, PathDisplayExtension, TrailExtension, HighlightExtension];
-
-    /**
-     * @type {FogOfWarSystem3}
-     */
-    #system;
-
-    /**
-     * @param {FogOfWarSystem3} system
-     */
-    constructor(system) {
-        super();
-
-        this.#system = system;
-    }
-
-    record(frame) {
-        this.#system.record(frame);
-    }
-}
+export const FogOfWarSystem3 = FogOfWarSystem;