@woosh/meep-engine 3.53.0 → 3.54.0

package/src/engine/graphics/texture/atlas/ReferencedTextureAtlas.js

@@ -1,83 +1,110 @@
-import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
-import { Reference } from "../../../reference/v2/Reference.js";
-
-export class ReferencedTextureAtlas extends AbstractTextureAtlas {
-    /**
-     *
-     * @type {Map<Sampler2D, AtlasPatch>}
-     * @private
-     */
-    __patches = new Map();
-
-    /**
-     *
-     * @type {Map<AtlasPatch, number>}
-     * @private
-     */
-    __ref_counts = new Map();
-
-    /**
-     *
-     * @param {AbstractTextureAtlas} atlas
-     */
-    constructor(atlas) {
-        super();
-
-        this.__atlas = atlas;
-    }
-
-    update() {
-        this.__atlas.update();
-    }
-
-    /**
-     *
-     * @param {Reference} ref
-     * @param {AtlasPatch} patch
-     * @private
-     */
-    __handle_ref_release(ref, patch) {
-        const ref_counts = this.__ref_counts;
-
-        const ref_count = ref_counts.get(patch);
-        ref_counts.set(patch, ref_count - 1);
-
-        if (ref_count === 1) {
-            // last reference removed, clear patch
-            this.__atlas.remove(patch);
-            ref_counts.delete(patch);
-            this.__patches.delete(patch.sampler);
-        }
-    }
-
-
-    /**
-     *
-     * @param {Sampler2D} sampler
-     * @returns {Reference<AtlasPatch>}
-     */
-    acquire(sampler) {
-
-        let patch = this.__patches.get(sampler);
-
-        const ref_counts = this.__ref_counts;
-
-        const atlas = this.__atlas;
-
-        if (patch === undefined) {
-            patch = atlas.add(sampler);
-            ref_counts.set(patch, 1)
-
-            this.__patches.set(sampler, patch);
-        } else {
-            ref_counts.set(patch, ref_counts.get(patch) + 1);
-        }
-
-        const ref = new Reference();
-        ref.bind(patch);
-
-        ref.onReleased.add(this.__handle_ref_release, this);
-
-        return ref;
-    }
-}
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+import { Reference } from "../../../reference/v2/Reference.js";
+
+export class ReferencedTextureAtlas extends AbstractTextureAtlas {
+    /**
+     *
+     * @type {Map<Sampler2D, AtlasPatch>}
+     * @private
+     */
+    __patches = new Map();
+
+    /**
+     *
+     * @type {Map<AtlasPatch, number>}
+     * @private
+     */
+    __ref_counts = new Map();
+
+    /**
+     *
+     * @param {AbstractTextureAtlas} atlas
+     */
+    constructor(atlas) {
+        super();
+
+        this.__atlas = atlas;
+    }
+
+    /**
+     * @returns {AbstractTextureAtlas}
+     */
+    get atlas() {
+        return this.__atlas;
+    }
+
+    /**
+     * @returns {Sampler2D}
+     */
+    get sampler() {
+        return this.__atlas.sampler;
+    }
+
+    update() {
+        this.__atlas.update();
+    }
+
+    reset() {
+        this.__patches.clear();
+        this.__ref_counts.clear();
+
+        if (typeof this.__atlas.reset === 'function') {
+            this.__atlas.reset();
+        }
+    }
+
+    /**
+     *
+     * @param {Reference} ref
+     * @param {AtlasPatch} patch
+     * @private
+     */
+    __handle_ref_release(ref, patch) {
+        const ref_counts = this.__ref_counts;
+
+        const ref_count = ref_counts.get(patch);
+        if (ref_count === undefined) {
+            return;
+        }
+
+        ref_counts.set(patch, ref_count - 1);
+
+        if (ref_count === 1) {
+            // last reference removed, clear patch
+            this.__atlas.remove(patch);
+            ref_counts.delete(patch);
+            this.__patches.delete(patch.sampler);
+        }
+    }
+
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {Reference<AtlasPatch>}
+     */
+    acquire(sampler) {
+
+        let patch = this.__patches.get(sampler);
+
+        const ref_counts = this.__ref_counts;
+
+        const atlas = this.__atlas;
+
+        if (patch === undefined) {
+            patch = atlas.add(sampler);
+            ref_counts.set(patch, 1);
+
+            this.__patches.set(sampler, patch);
+        } else {
+            ref_counts.set(patch, ref_counts.get(patch) + 1);
+        }
+
+        const ref = new Reference();
+        ref.bind(patch);
+
+        ref.onReleased.add(this.__handle_ref_release, this);
+
+        return ref;
+    }
+}

package/src/engine/graphics/texture/atlas/SpriteAtlas.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A texture atlas whose patches can be **mipmapped without bleeding into each other**.
+ *
+ * A plain {@link TextureAtlas} reserves padding around each patch but never fills it, leaving a
+ * zeroed gutter that every mip level past the first averages against the patch content.
+ *
+ * Three things fix it, and all three are here: a border sized in proportion to the patch
+ * ({@link sprite_atlas_border}), a border that is actually **filled**, by a rule that suits what the
+ * channel means ({@link SpriteAtlasFill}), and a per-patch bound on how deep the mip chain may be
+ * sampled ({@link sprite_atlas_max_lod}), because no finite border protects every level.
+ *
+ * Packing, growth, repacking and uv bookkeeping are the base class's and are untouched — it already
+ * places content at `packing + padding`, which is the whole geometry of a bordered patch.
+ */
+export class SpriteAtlas extends TextureAtlas {
+    /**
+     * @param {SpriteAtlasFill} fill
+     * @param {number} [size] initial edge length; the atlas grows on demand
+     */
+    constructor(fill: SpriteAtlasFill, size?: number);
+    /**
+     * @returns {SpriteAtlasFill}
+     */
+    get fill(): number;
+    /**
+     * The border is the patch's own size, not the caller's choice — every patch in one atlas has to
+     * obey the same rule for {@link sprite_atlas_max_lod}'s "+1 from the neighbour" to hold.
+     *
+     * @param {import("../sampler/Sampler2D.js").Sampler2D} sampler
+     * @returns {number}
+     */
+    compute_padding(sampler: import("../sampler/Sampler2D.js").Sampler2D): number;
+    /**
+     * @param {import("../sampler/Sampler2D.js").Sampler2D} sampler
+     * @returns {import("./AtlasPatch.js").AtlasPatch}
+     */
+    add(sampler: import("../sampler/Sampler2D.js").Sampler2D): import("./AtlasPatch.js").AtlasPatch;
+    #private;
+}
+import { TextureAtlas } from "./TextureAtlas.js";
+import { SpriteAtlasFill } from "./SpriteAtlasFill.js";
+//# sourceMappingURL=SpriteAtlas.d.ts.map

package/src/engine/graphics/texture/atlas/SpriteAtlas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpriteAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/SpriteAtlas.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH;IAMI;;;OAGG;IACH,kBAHW,eAAe,SACf,MAAM,EAQhB;IAED;;OAEG;IACH,mBAEC;IAED;;;;;;OAMG;IACH,yBAHW,OAAO,yBAAyB,EAAE,SAAS,GACzC,MAAM,CAMlB;IAED;;;OAGG;IACH,aAHW,OAAO,yBAAyB,EAAE,SAAS,GACzC,OAAO,iBAAiB,EAAE,UAAU,CAMhD;;CAsIJ;6BAvM4B,mBAAmB;gCAGhB,sBAAsB"}

package/src/engine/{graphics3/decal/DecalAtlas.js → graphics/texture/atlas/SpriteAtlas.js}

@@ -1,194 +1,202 @@
-import { assert } from "../../../core/assert.js";
-import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
-import { TextureAtlas } from "../../graphics/texture/atlas/TextureAtlas.js";
-import { AtlasPatchFlag } from "../../graphics/texture/atlas/AtlasPatchFlag.js";
-import { decal_atlas_border } from "./decal_atlas_border.js";
-import { DecalAtlasFill } from "./DecalAtlasFill.js";
-
-/**
- * A texture atlas whose patches can be **mipmapped without bleeding into each other**.
- *
- * The atlas this replaces generates mipmaps and reserves padding, and still bleeds: nothing ever
- * fills the padding, so the gutter is zeros and every level past the first averages a patch against
- * whatever lies beyond it. The workarounds are visible in the shader that reads it — a negative LOD
- * bias, and a switch to turn mipmapping off when a scene has many overlapping decals.
- *
- * Three things fix it, and all three are here: a border sized in proportion to the patch
- * ({@link decal_atlas_border}), a border that is actually **filled**, by a rule that suits what the
- * channel means ({@link DecalAtlasFill}), and a per-patch bound on how deep the mip chain may be
- * sampled ({@link decal_atlas_max_lod}), because no finite border protects every level.
- *
- * Packing, growth, repacking and uv bookkeeping are the base class's and are untouched — it already
- * places content at `packing + padding`, which is the whole geometry of a bordered patch.
- */
-export class DecalAtlas extends TextureAtlas {
-    /**
-     * @type {DecalAtlasFill}
-     */
-    #fill;
-
-    /**
-     * @param {DecalAtlasFill} fill
-     * @param {number} [size] initial edge length; the atlas grows on demand
-     */
-    constructor(fill, size = 16) {
-        super(size, BinaryDataType.Uint8, 4);
-
-        assert.enum(fill, DecalAtlasFill, 'fill');
-
-        this.#fill = fill;
-    }
-
-    /**
-     * @returns {DecalAtlasFill}
-     */
-    get fill() {
-        return this.#fill;
-    }
-
-    /**
-     * The border is the patch's own size, not the caller's choice — every patch in one atlas has to
-     * obey the same rule for {@link decal_atlas_max_lod}'s "+1 from the neighbour" to hold.
-     *
-     * @param {Sampler2D} sampler
-     * @returns {AtlasPatch}
-     */
-    add(sampler) {
-        assert.defined(sampler, 'sampler');
-
-        return super.add(sampler, decal_atlas_border(sampler.width, sampler.height));
-    }
-
-    /**
-     * @param {AtlasPatch} patch
-     */
-    paintPatch(patch) {
-        const target = this.sampler;
-        const source = patch.sampler;
-
-        const width = patch.size.x;
-        const height = patch.size.y;
-
-        const x0 = patch.position.x;
-        const y0 = patch.position.y;
-
-        const border = patch.padding;
-
-        const premultiply = this.#fill === DecalAtlasFill.PremultipliedCoverage;
-
-        const target_data = target.data;
-        const source_data = source.data;
-        const target_width = target.width;
-
-        for (let y = 0; y < height; y++) {
-            const source_row = y * width * 4;
-            const target_row = ((y0 + y) * target_width + x0) * 4;
-
-            for (let x = 0; x < width; x++) {
-                const s = source_row + x * 4;
-                const t = target_row + x * 4;
-
-                const alpha = source_data[s + 3];
-
-                if (premultiply) {
-                    // integer rounding rather than truncation, so a fully opaque texel survives
-                    // the round trip exactly
-                    target_data[t] = (source_data[s] * alpha + 127) / 255 | 0;
-                    target_data[t + 1] = (source_data[s + 1] * alpha + 127) / 255 | 0;
-                    target_data[t + 2] = (source_data[s + 2] * alpha + 127) / 255 | 0;
-                } else {
-                    target_data[t] = source_data[s];
-                    target_data[t + 1] = source_data[s + 1];
-                    target_data[t + 2] = source_data[s + 2];
-                }
-
-                target_data[t + 3] = alpha;
-            }
-        }
-
-        if (premultiply) {
-            this.#fill_border_zero(x0, y0, width, height, border);
-        } else {
-            this.#fill_border_extend(x0, y0, width, height, border);
-        }
-
-        patch.setFlag(AtlasPatchFlag.Painted);
-        patch.last_painted_version = source.version;
-    }
-
-    /**
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} width
-     * @param {number} height
-     * @param {number} border
-     */
-    #fill_border_zero(x0, y0, width, height, border) {
-        const target = this.sampler;
-
-        const data = target.data;
-        const target_width = target.width;
-
-        for (let y = y0 - border; y < y0 + height + border; y++) {
-            const inside_rows = y >= y0 && y < y0 + height;
-
-            for (let x = x0 - border; x < x0 + width + border; x++) {
-                if (inside_rows && x >= x0 && x < x0 + width) {
-                    // the content itself, already painted
-                    x = x0 + width - 1;
-
-                    continue;
-                }
-
-                const t = (y * target_width + x) * 4;
-
-                data[t] = 0;
-                data[t + 1] = 0;
-                data[t + 2] = 0;
-                data[t + 3] = 0;
-            }
-        }
-    }
-
-    /**
-     * The nearest content texel, repeated outward — corners included, which is where a fill written
-     * as "rows then columns" leaves a hole.
-     *
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} width
-     * @param {number} height
-     * @param {number} border
-     */
-    #fill_border_extend(x0, y0, width, height, border) {
-        const target = this.sampler;
-
-        const data = target.data;
-        const target_width = target.width;
-
-        for (let y = y0 - border; y < y0 + height + border; y++) {
-            const inside_rows = y >= y0 && y < y0 + height;
-
-            // clamp to the content, on both axes independently, which is what covers the corners
-            const source_y = y < y0 ? y0 : (y >= y0 + height ? y0 + height - 1 : y);
-
-            for (let x = x0 - border; x < x0 + width + border; x++) {
-                if (inside_rows && x >= x0 && x < x0 + width) {
-                    x = x0 + width - 1;
-
-                    continue;
-                }
-
-                const source_x = x < x0 ? x0 : (x >= x0 + width ? x0 + width - 1 : x);
-
-                const s = (source_y * target_width + source_x) * 4;
-                const t = (y * target_width + x) * 4;
-
-                data[t] = data[s];
-                data[t + 1] = data[s + 1];
-                data[t + 2] = data[s + 2];
-                data[t + 3] = data[s + 3];
-            }
-        }
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
+import { TextureAtlas } from "./TextureAtlas.js";
+import { AtlasPatchFlag } from "./AtlasPatchFlag.js";
+import { sprite_atlas_border } from "./sprite_atlas_border.js";
+import { SpriteAtlasFill } from "./SpriteAtlasFill.js";
+
+/**
+ * A texture atlas whose patches can be **mipmapped without bleeding into each other**.
+ *
+ * A plain {@link TextureAtlas} reserves padding around each patch but never fills it, leaving a
+ * zeroed gutter that every mip level past the first averages against the patch content.
+ *
+ * Three things fix it, and all three are here: a border sized in proportion to the patch
+ * ({@link sprite_atlas_border}), a border that is actually **filled**, by a rule that suits what the
+ * channel means ({@link SpriteAtlasFill}), and a per-patch bound on how deep the mip chain may be
+ * sampled ({@link sprite_atlas_max_lod}), because no finite border protects every level.
+ *
+ * Packing, growth, repacking and uv bookkeeping are the base class's and are untouched — it already
+ * places content at `packing + padding`, which is the whole geometry of a bordered patch.
+ */
+export class SpriteAtlas extends TextureAtlas {
+    /**
+     * @type {SpriteAtlasFill}
+     */
+    #fill;
+
+    /**
+     * @param {SpriteAtlasFill} fill
+     * @param {number} [size] initial edge length; the atlas grows on demand
+     */
+    constructor(fill, size = 16) {
+        super(size, BinaryDataType.Uint8, 4);
+
+        assert.enum(fill, SpriteAtlasFill, 'fill');
+
+        this.#fill = fill;
+    }
+
+    /**
+     * @returns {SpriteAtlasFill}
+     */
+    get fill() {
+        return this.#fill;
+    }
+
+    /**
+     * The border is the patch's own size, not the caller's choice — every patch in one atlas has to
+     * obey the same rule for {@link sprite_atlas_max_lod}'s "+1 from the neighbour" to hold.
+     *
+     * @param {import("../sampler/Sampler2D.js").Sampler2D} sampler
+     * @returns {number}
+     */
+    compute_padding(sampler) {
+        assert.defined(sampler, 'sampler');
+
+        return sprite_atlas_border(sampler.width, sampler.height);
+    }
+
+    /**
+     * @param {import("../sampler/Sampler2D.js").Sampler2D} sampler
+     * @returns {import("./AtlasPatch.js").AtlasPatch}
+     */
+    add(sampler) {
+        assert.defined(sampler, 'sampler');
+
+        return super.add(sampler, this.compute_padding(sampler));
+    }
+
+    /**
+     * @param {import("./AtlasPatch.js").AtlasPatch} patch
+     */
+    paintPatch(patch) {
+        const target = this.sampler;
+        const source = patch.sampler;
+
+        const width = patch.size.x;
+        const height = patch.size.y;
+
+        const x0 = patch.position.x;
+        const y0 = patch.position.y;
+
+        const border = patch.padding;
+
+        const premultiply = this.#fill === SpriteAtlasFill.PremultipliedCoverage;
+
+        const target_data = target.data;
+        const source_data = source.data;
+        const target_width = target.width;
+
+        for (let y = 0; y < height; y++) {
+            const source_row = y * width * 4;
+            const target_row = ((y0 + y) * target_width + x0) * 4;
+
+            for (let x = 0; x < width; x++) {
+                const s = source_row + x * 4;
+                const t = target_row + x * 4;
+
+                const alpha = source_data[s + 3];
+
+                if (premultiply) {
+                    // integer rounding rather than truncation, so a fully opaque texel survives
+                    // the round trip exactly
+                    target_data[t] = (source_data[s] * alpha + 127) / 255 | 0;
+                    target_data[t + 1] = (source_data[s + 1] * alpha + 127) / 255 | 0;
+                    target_data[t + 2] = (source_data[s + 2] * alpha + 127) / 255 | 0;
+                } else {
+                    target_data[t] = source_data[s];
+                    target_data[t + 1] = source_data[s + 1];
+                    target_data[t + 2] = source_data[s + 2];
+                }
+
+                target_data[t + 3] = alpha;
+            }
+        }
+
+        if (premultiply) {
+            this.#fill_border_zero(x0, y0, width, height, border);
+        } else {
+            this.#fill_border_extend(x0, y0, width, height, border);
+        }
+
+        patch.setFlag(AtlasPatchFlag.Painted);
+        patch.last_painted_version = source.version;
+    }
+
+    /**
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} width
+     * @param {number} height
+     * @param {number} border
+     */
+    #fill_border_zero(x0, y0, width, height, border) {
+        const target = this.sampler;
+
+        const data = target.data;
+        const target_width = target.width;
+
+        for (let y = y0 - border; y < y0 + height + border; y++) {
+            const inside_rows = y >= y0 && y < y0 + height;
+
+            for (let x = x0 - border; x < x0 + width + border; x++) {
+                if (inside_rows && x >= x0 && x < x0 + width) {
+                    // the content itself, already painted
+                    x = x0 + width - 1;
+
+                    continue;
+                }
+
+                const t = (y * target_width + x) * 4;
+
+                data[t] = 0;
+                data[t + 1] = 0;
+                data[t + 2] = 0;
+                data[t + 3] = 0;
+            }
+        }
+    }
+
+    /**
+     * The nearest content texel, repeated outward — corners included, which is where a fill written
+     * as "rows then columns" leaves a hole.
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} width
+     * @param {number} height
+     * @param {number} border
+     */
+    #fill_border_extend(x0, y0, width, height, border) {
+        const target = this.sampler;
+
+        const data = target.data;
+        const target_width = target.width;
+
+        for (let y = y0 - border; y < y0 + height + border; y++) {
+            const inside_rows = y >= y0 && y < y0 + height;
+
+            // clamp to the content, on both axes independently, which is what covers the corners
+            const source_y = y < y0 ? y0 : (y >= y0 + height ? y0 + height - 1 : y);
+
+            for (let x = x0 - border; x < x0 + width + border; x++) {
+                if (inside_rows && x >= x0 && x < x0 + width) {
+                    x = x0 + width - 1;
+
+                    continue;
+                }
+
+                const source_x = x < x0 ? x0 : (x >= x0 + width ? x0 + width - 1 : x);
+
+                const s = (source_y * target_width + source_x) * 4;
+                const t = (y * target_width + x) * 4;
+
+                data[t] = data[s];
+                data[t + 1] = data[s + 1];
+                data[t + 2] = data[s + 2];
+                data[t + 3] = data[s + 3];
+            }
+        }
+    }
+}

package/src/engine/graphics/texture/atlas/SpriteAtlasFill.d.ts

@@ -0,0 +1,12 @@
+/**
+ * How a {@link SpriteAtlas } fills the border around a patch.
+ *
+ * Two rules rather than one, because the correct fill depends on what the channel means and getting
+ * it wrong shows up only once the mip chain is built.
+ */
+export type SpriteAtlasFill = number;
+export namespace SpriteAtlasFill {
+    let PremultipliedCoverage: number;
+    let EdgeExtend: number;
+}
+//# sourceMappingURL=SpriteAtlasFill.d.ts.map