@woosh/meep-engine 3.28.0 → 3.30.0

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_scale_down_linear.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_linear.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,uFAsEC"}
+{"version":3,"file":"sampler2d_scale_down_linear.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_linear.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,uFAoFC"}

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_linear.js

@@ -31,15 +31,26 @@ export function sampler2d_scale_down_linear(input, output) {
 
     const sample = new Float64Array(itemSize);
 
-    const sampleSize = sW * sH;
-    const sampleSizeInv = 1 / sampleSize;
-
     const input_data = input.data;
     const output_data = output.data;
 
     for (let y = 0; y < oH; y++) {
 
-        const sampleOffsetY = y * sH;
+        /**
+         * The source window is derived with integer arithmetic, and the divisor is the number of
+         * texels it actually covers.
+         *
+         * The ratios themselves used to serve as both loop bound and texel offset, which only works
+         * while they are whole: at 25 -> 12 `sampleOffsetX = x * 2.0833...` is fractional, the flat
+         * address is fractional, and every typed-array read comes back `undefined`, so the output is
+         * NaN. Silently — the one guard, `assert.ok(sW >= 1)`, rejects upscaling and nothing else,
+         * and the consumer strips asserts. An odd dimension above 2 is enough to reach it: both mip
+         * callers halve with a floor, so a 50x50 source goes 25 -> 12 and NaNs the rest of its chain.
+         *
+         * For a whole ratio the window is exactly the old one, texel for texel.
+         */
+        const y0 = Math.floor(y * sH);
+        const y1 = Math.max(y0 + 1, Math.min(iH, Math.floor((y + 1) * sH)));
 
         const row_address = y * oW * itemSize;
 
@@ -47,15 +58,18 @@ export function sampler2d_scale_down_linear(input, output) {
 
             const output_texel_address = row_address + x * itemSize;
 
-            const sampleOffsetX = x * sW;
+            const x0 = Math.floor(x * sW);
+            const x1 = Math.max(x0 + 1, Math.min(iW, Math.floor((x + 1) * sW)));
+
+            const sampleSizeInv = 1 / ((y1 - y0) * (x1 - x0));
 
             // accumulate sample
-            for (let j = 0; j < sH; j++) {
-                const row_index = (sampleOffsetY + j) * iW;
-                const texel_offset = row_index + sampleOffsetX;
-                let input_texel_address = texel_offset * itemSize;
+            for (let j = y0; j < y1; j++) {
+                const row_index = j * iW;
+
+                let input_texel_address = (row_index + x0) * itemSize;
 
-                for (let i = sW; i > 0; i--) {
+                for (let i = x0; i < x1; i++) {
 
                     for (let k = 0; k < itemSize; k++) {
                         sample[k] += input_data[k + input_texel_address];

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

@@ -52,21 +52,23 @@ export class DebugDrawSystem extends System<any> {
     #private;
 }
 /**
- * **The single deliberate exception to the fog of war.** Everything else drawn into the scene is
- * concealed by it; developer geometry that the fog can hide is a debugging tool that stops working
- * exactly where debugging is needed, so this says so rather than relying on where it was registered.
+ * **On top.** Developer geometry that a later effect can conceal is a debugging tool that stops
+ * working exactly where debugging is needed, so this asks to be last rather than relying on where it
+ * was registered.
+ *
+ * The number is far out of the way of the ordinary ones rather than one above the fog, so that a
+ * composite added later can push past the fog without having to know this exists. It is not a
+ * guarantee — nothing here can be — but out here it takes a deliberate act to land above it.
  */
 export class DebugDrawExtension extends RenderExtension {
     /**
      * @param {DebugDrawSystem} system
      */
     constructor(system: DebugDrawSystem);
-    after: (typeof FogOfWarExtension)[];
     record(frame: any): void;
     #private;
 }
 import { System } from "../ecs/System.js";
 import { DynamicMeshBatch } from "../../shade/renderer/scene/DynamicMeshBatch.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { FogOfWarExtension } from "./FogOfWarSystem.js";
 //# sourceMappingURL=DebugDrawSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAYC;IAhFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAmBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCAwBC;;CACJ;AAED;;;;GAIG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAdD,oCAA4B;IAgB5B,yBAEC;;CACJ;uBAhMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD;kCAFjD,qBAAqB"}
+{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAYC;IAhFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAmBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCAwBC;;CACJ;AAED;;;;;;;;GAQG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAED,yBAEC;;CACJ;uBApMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD"}

package/src/engine/graphics3/DebugDrawSystem.js

@@ -1,203 +1,206 @@
-import { assert } from "../../core/assert.js";
-import { GPUDynamicMeshRenderer } from "../../shade/renderer/dynamic/GPUDynamicMeshRenderer.js";
-import { Geometry } from "../../shade/renderer/geometry/Geometry.js";
-import { FogOfWarExtension } from "./FogOfWarSystem.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 { DynamicMesh } from "../../shade/renderer/scene/DynamicMesh.js";
-import { DynamicMeshBatch } from "../../shade/renderer/scene/DynamicMeshBatch.js";
-import { System } from "../ecs/System.js";
-import { Gizmo } from "../graphics/render/gizmo/Gizmo.js";
-import { gizmo_view_from_camera } from "./debug/gizmo_view_from_camera.js";
-import { gizmo_write_geometry } from "./debug/gizmo_write_geometry.js";
-
-/**
- * Draws what {@link Gizmo} recorded this frame, under Shade.
- *
- * **The Shade half of the pair `GizmoRenderingPlugin` is the three half of.** The immediate-mode API
- * a tool calls is renderer-neutral and records into buffers; this turns one frame of those buffers
- * into geometry and puts it on the dynamic-mesh path (D5/D11), which is where every piece of
- * generated content in this phase belongs.
- *
- * **One mesh, one geometry, rewritten every frame.** Debug drawing has no persistent objects to key
- * anything on — a shape is a call, not a thing — so there is nothing to cache and nothing to
- * release between frames. Colour rides the vertices rather than the mesh, which is what lets one
- * draw carry a whole frame's worth of differently coloured shapes.
- *
- * **Blended and depth-tested, never depth-writing.** Debug shapes are occluded by the scene and
- * occlude nothing, including each other: two overlapping solid shapes composite in the order they
- * were recorded rather than by depth. Whether a gizmo should instead sit on top of everything is
- * the gizmo's question and V6 answers it.
- *
- * **The recording is cleared once the frame that consumed it has been submitted**, on the same
- * signal the three backend clears on. An immediate-mode API that leaks its contents keeps drawing a
- * world that has moved on, so "what was drawn last frame is gone this frame" is a property of the
- * pass rather than a courtesy of its callers.
- */
-export class DebugDrawSystem extends System {
-    /**
-     * Width of a drawn line, in CSS pixels of the display — so it is the same thickness whatever
-     * the device pixel ratio is and wherever the resolution controller has the frame this instant.
-     *
-     * **A property of the pass, not of a draw.** The recording API has no width — it is an
-     * immediate-mode debug surface, and one that asked every caller for a line width would be
-     * asking about the display rather than about the thing being drawn.
-     *
-     * @type {number}
-     */
-    line_width = 2;
-
-    /**
-     * @type {GraphicsEngine}
-     */
-    #graphics;
-
-    /**
-     * @type {GPUDynamicMeshRenderer}
-     */
-    #renderer = new GPUDynamicMeshRenderer();
-
-    /**
-     * @type {DynamicMeshBatch}
-     */
-    #batch = new DynamicMeshBatch();
-
-    /**
-     * @type {DynamicMesh}
-     */
-    #mesh = DynamicMesh.from(new Geometry());
-
-    /**
-     * @type {RenderExtension|null}
-     */
-    #extension = null;
-
-    /**
-     * @type {function}
-     */
-    #clear;
-
-    /**
-     * Where the camera is and what it looks along, refilled per frame — the pass runs once and
-     * nothing else reads this.
-     *
-     * @type {GizmoView}
-     */
-    #view = {
-        eye: new Float32Array(3),
-        forward: new Float32Array(3),
-        projection_scale: 1,
-        viewport_height: 1,
-        line_width: 1
-    };
-
-    /**
-     * What the pass draws. Read-only — the geometry follows the recording.
-     *
-     * @returns {DynamicMeshBatch}
-     */
-    get batch() {
-        return this.#batch;
-    }
-
-    /**
-     * @param {GraphicsEngine} graphics
-     */
-    constructor(graphics) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-
-        this.#graphics = graphics;
-
-        // vertices are written in world space, and what the draw applies is the mesh's own
-        // transform, identity until moved
-        this.#batch.add(this.#mesh);
-
-        this.#clear = () => Gizmo.clear();
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#extension = this.#graphics.add_extension(new DebugDrawExtension(this));
-
-        this.#graphics.on.postRender.add(this.#clear);
-    }
-
-    async shutdown(entityManager) {
-        if (this.#extension !== null) {
-            this.#graphics.remove_extension(this.#extension);
-
-            this.#extension = null;
-        }
-
-        this.#graphics.on.postRender.remove(this.#clear);
-
-        this.#renderer.destroy();
-
-        Gizmo.clear();
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame) {
-        gizmo_view_from_camera(
-            this.#view,
-            frame.view.camera.camera,
-            this.#graphics.viewport.size.y,
-            this.line_width
-        );
-
-        gizmo_write_geometry(this.#mesh.geometry, Gizmo, this.#view);
-
-        if (Gizmo.empty) {
-            // nothing was recorded, and the frame's colour is left exactly as it was
-            return;
-        }
-
-        const scene = frame.get(SceneColor);
-
-        scene.color = this.#renderer.graph_draw({
-            graph: frame.graph,
-            batch: this.#batch,
-            color: scene.color,
-            depth: frame.get(ViewTextures).depth,
-            camera: frame.view.camera.buffer
-        });
-    }
-}
-
-/**
- * **The single deliberate exception to the fog of war.** Everything else drawn into the scene is
- * concealed by it; developer geometry that the fog can hide is a debugging tool that stops working
- * exactly where debugging is needed, so this says so rather than relying on where it was registered.
- */
-export class DebugDrawExtension extends RenderExtension {
-    name = "debug draw";
-
-    phase = FramePhase.AfterTransparency;
-
-    after = [FogOfWarExtension];
-
-    /**
-     * @type {DebugDrawSystem}
-     */
-    #system;
-
-    /**
-     * @param {DebugDrawSystem} system
-     */
-    constructor(system) {
-        super();
-
-        this.#system = system;
-    }
-
-    record(frame) {
-        this.#system.record(frame);
-    }
-}
+import { assert } from "../../core/assert.js";
+import { GPUDynamicMeshRenderer } from "../../shade/renderer/dynamic/GPUDynamicMeshRenderer.js";
+import { Geometry } from "../../shade/renderer/geometry/Geometry.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 { DynamicMesh } from "../../shade/renderer/scene/DynamicMesh.js";
+import { DynamicMeshBatch } from "../../shade/renderer/scene/DynamicMeshBatch.js";
+import { System } from "../ecs/System.js";
+import { Gizmo } from "../graphics/render/gizmo/Gizmo.js";
+import { gizmo_view_from_camera } from "./debug/gizmo_view_from_camera.js";
+import { gizmo_write_geometry } from "./debug/gizmo_write_geometry.js";
+
+/**
+ * Draws what {@link Gizmo} recorded this frame, under Shade.
+ *
+ * **The Shade half of the pair `GizmoRenderingPlugin` is the three half of.** The immediate-mode API
+ * a tool calls is renderer-neutral and records into buffers; this turns one frame of those buffers
+ * into geometry and puts it on the dynamic-mesh path (D5/D11), which is where every piece of
+ * generated content in this phase belongs.
+ *
+ * **One mesh, one geometry, rewritten every frame.** Debug drawing has no persistent objects to key
+ * anything on — a shape is a call, not a thing — so there is nothing to cache and nothing to
+ * release between frames. Colour rides the vertices rather than the mesh, which is what lets one
+ * draw carry a whole frame's worth of differently coloured shapes.
+ *
+ * **Blended and depth-tested, never depth-writing.** Debug shapes are occluded by the scene and
+ * occlude nothing, including each other: two overlapping solid shapes composite in the order they
+ * were recorded rather than by depth. Whether a gizmo should instead sit on top of everything is
+ * the gizmo's question and V6 answers it.
+ *
+ * **The recording is cleared once the frame that consumed it has been submitted**, on the same
+ * signal the three backend clears on. An immediate-mode API that leaks its contents keeps drawing a
+ * world that has moved on, so "what was drawn last frame is gone this frame" is a property of the
+ * pass rather than a courtesy of its callers.
+ */
+export class DebugDrawSystem extends System {
+    /**
+     * Width of a drawn line, in CSS pixels of the display — so it is the same thickness whatever
+     * the device pixel ratio is and wherever the resolution controller has the frame this instant.
+     *
+     * **A property of the pass, not of a draw.** The recording API has no width — it is an
+     * immediate-mode debug surface, and one that asked every caller for a line width would be
+     * asking about the display rather than about the thing being drawn.
+     *
+     * @type {number}
+     */
+    line_width = 2;
+
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {GPUDynamicMeshRenderer}
+     */
+    #renderer = new GPUDynamicMeshRenderer();
+
+    /**
+     * @type {DynamicMeshBatch}
+     */
+    #batch = new DynamicMeshBatch();
+
+    /**
+     * @type {DynamicMesh}
+     */
+    #mesh = DynamicMesh.from(new Geometry());
+
+    /**
+     * @type {RenderExtension|null}
+     */
+    #extension = null;
+
+    /**
+     * @type {function}
+     */
+    #clear;
+
+    /**
+     * Where the camera is and what it looks along, refilled per frame — the pass runs once and
+     * nothing else reads this.
+     *
+     * @type {GizmoView}
+     */
+    #view = {
+        eye: new Float32Array(3),
+        forward: new Float32Array(3),
+        projection_scale: 1,
+        viewport_height: 1,
+        line_width: 1
+    };
+
+    /**
+     * What the pass draws. Read-only — the geometry follows the recording.
+     *
+     * @returns {DynamicMeshBatch}
+     */
+    get batch() {
+        return this.#batch;
+    }
+
+    /**
+     * @param {GraphicsEngine} graphics
+     */
+    constructor(graphics) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+
+        this.#graphics = graphics;
+
+        // vertices are written in world space, and what the draw applies is the mesh's own
+        // transform, identity until moved
+        this.#batch.add(this.#mesh);
+
+        this.#clear = () => Gizmo.clear();
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        this.#extension = this.#graphics.add_extension(new DebugDrawExtension(this));
+
+        this.#graphics.on.postRender.add(this.#clear);
+    }
+
+    async shutdown(entityManager) {
+        if (this.#extension !== null) {
+            this.#graphics.remove_extension(this.#extension);
+
+            this.#extension = null;
+        }
+
+        this.#graphics.on.postRender.remove(this.#clear);
+
+        this.#renderer.destroy();
+
+        Gizmo.clear();
+    }
+
+    /**
+     * @param {FrameContext} frame
+     */
+    record(frame) {
+        gizmo_view_from_camera(
+            this.#view,
+            frame.view.camera.camera,
+            this.#graphics.viewport.size.y,
+            this.line_width
+        );
+
+        gizmo_write_geometry(this.#mesh.geometry, Gizmo, this.#view);
+
+        if (Gizmo.empty) {
+            // nothing was recorded, and the frame's colour is left exactly as it was
+            return;
+        }
+
+        const scene = frame.get(SceneColor);
+
+        scene.color = this.#renderer.graph_draw({
+            graph: frame.graph,
+            batch: this.#batch,
+            color: scene.color,
+            depth: frame.get(ViewTextures).depth,
+            camera: frame.view.camera.buffer
+        });
+    }
+}
+
+/**
+ * **On top.** Developer geometry that a later effect can conceal is a debugging tool that stops
+ * working exactly where debugging is needed, so this asks to be last rather than relying on where it
+ * was registered.
+ *
+ * The number is far out of the way of the ordinary ones rather than one above the fog, so that a
+ * composite added later can push past the fog without having to know this exists. It is not a
+ * guarantee — nothing here can be — but out here it takes a deliberate act to land above it.
+ */
+export class DebugDrawExtension extends RenderExtension {
+    name = "debug draw";
+
+    phase = FramePhase.AfterTransparency;
+
+    relative_order = 1000;
+
+    /**
+     * @type {DebugDrawSystem}
+     */
+    #system;
+
+    /**
+     * @param {DebugDrawSystem} system
+     */
+    constructor(system) {
+        super();
+
+        this.#system = system;
+    }
+
+    record(frame) {
+        this.#system.record(frame);
+    }
+}

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

@@ -68,16 +68,16 @@ export class DecalSystem extends System<any> {
     #private;
 }
 /**
- * **After the terrain**, because the decal composite has to see the textured ground rather than
- * precede it. That requirement used to be met by putting a registration call above an `await` and
- * writing a comment about it; here it is the declaration below.
+ * **Late on the phase**, because a decal composites over surfaces that are already written — the
+ * textured ground above all — rather than preceding them. That requirement used to be met by
+ * putting a registration call above an `await` and writing a comment about it; here it is the
+ * declaration below.
  */
 export class DecalExtension extends RenderExtension {
     /**
      * @param {DecalSystem} system
      */
     constructor(system: DecalSystem);
-    after: (typeof TerrainExtension)[];
     record(frame: any): void;
     #private;
 }
@@ -85,5 +85,4 @@ import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { Decal } from "../graphics/ecs/decal/v2/Decal.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { TerrainExtension } from "./TerrainSystem.js";
 //# sourceMappingURL=DecalSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH;IAwHI;;;OAGG;IACH,4DAeC;IA1ID,oDAAoC;IA8FpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAuBD,2CAUC;IAED,4CAYC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAiFD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;GAIG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAdD,mCAA2B;IAgB3B,yBAEC;;CACJ;uBAvbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD;iCADlD,oBAAoB"}
+{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAwHI;;;OAGG;IACH,4DAeC;IA1ID,oDAAoC;IA8FpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAuBD,2CAUC;IAED,4CAYC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAiFD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;GAKG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAxbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}

package/src/engine/graphics3/DecalSystem.js

@@ -3,7 +3,6 @@ import { LoadingCache } from "../../core/cache/LoadingCache.js";
 import { strictEquals } from "../../core/function/strictEquals.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
 import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
-import { TerrainExtension } from "./TerrainSystem.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 import { GameAssetType } from "../asset/GameAssetType.js";
 import { ImageRGBADataLoader } from "../asset/loaders/image/ImageRGBADataLoader.js";
@@ -418,16 +417,17 @@ export class DecalSystem extends System {
 }
 
 /**
- * **After the terrain**, because the decal composite has to see the textured ground rather than
- * precede it. That requirement used to be met by putting a registration call above an `await` and
- * writing a comment about it; here it is the declaration below.
+ * **Late on the phase**, because a decal composites over surfaces that are already written — the
+ * textured ground above all — rather than preceding them. That requirement used to be met by
+ * putting a registration call above an `await` and writing a comment about it; here it is the
+ * declaration below.
  */
 export class DecalExtension extends RenderExtension {
     name = "decals";
 
     phase = FramePhase.AfterGBuffer;
 
-    after = [TerrainExtension];
+    relative_order = 1;
 
     /**
      * @type {DecalSystem}

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

@@ -45,21 +45,20 @@ export class FogOfWarSystem extends System<any> {
     #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.
+ * **Late on the phase**, because the fog conceals and therefore belongs over everything it is meant
+ * to conceal — content drawn at the phase's default order is 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.
+ * Nothing is named: a content extension added later is concealed because it sits at the default,
+ * not because a list here was updated. Whatever must not be concealed asks for a later order of its
+ * own.
  */
 export class FogOfWarExtension extends RenderExtension {
     /**
      * @param {FogOfWarSystem} system
      */
     constructor(system: FogOfWarSystem);
-    after: (typeof HighlightExtension | typeof ParticleExtension | typeof PathDisplayExtension | typeof TrailExtension)[];
     record(frame: any): void;
     #private;
 }
@@ -67,8 +66,4 @@ 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 "./HighlightOutlineSystem.js";
-import { ParticleExtension } from "./ParticleEmitterSystem.js";
-import { PathDisplayExtension } from "./PathDisplaySystem.js";
-import { TrailExtension } from "./Trail3DSystem.js";
 //# sourceMappingURL=FogOfWarSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/FogOfWarSystem.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH;IAwCI;;OAEG;IACH,sCAMC;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,cAAc,EAMxB;IAdD,sHAAsF;IAgBtF,yBAEC;;CACJ;uBAzPsB,kBAAkB;oBADrB,+BAA+B;yBAH1B,wBAAwB;gCAHjB,mDAAmD;mCALhD,6BAA6B;kCAC9B,4BAA4B;qCACzB,wBAAwB;+BAC9B,oBAAoB"}
+{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/FogOfWarSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH;IAwCI;;OAEG;IACH,sCAMC;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,cAAc,EAMxB;IAED,yBAEC;;CACJ;uBAzPsB,kBAAkB;oBADrB,+BAA+B;yBAH1B,wBAAwB;gCAHjB,mDAAmD"}