@woosh/meep-engine 3.53.0 → 3.54.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpriteAtlasFill.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/SpriteAtlasFill.js"],"names":[],"mappings":";;;;;;8BAMU,MAAM"}

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

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ *
+ * @enum {number}
+ */
+export const SpriteAtlasFill = {
+    /**
+     * Colour weighted by coverage, and a gutter of nothing.
+     *
+     * The patch is stored **premultiplied** and its border is zero. Averaging that pair down a mip
+     * chain gives premultiplied colour times coverage at every level, which is what a sprite or
+     * decal fading out at its edge should look like. The same arrangement in *straight* alpha is
+     * where dark halos come from — an edge texel averaged against transparent black keeps its alpha
+     * and loses its colour.
+     */
+    PremultipliedCoverage: 0,
+
+    /**
+     * The nearest content texel, repeated outward.
+     *
+     * For channels that carry no coverage of their own — a normal, a roughness, a metalness — or
+     * straight-alpha sprites whose shader applies coverage separately, a zeroed gutter would drag a
+     * partially covered mip texel toward a meaningless value. Repeating the edge lets the mip chain
+     * average content against more of the same.
+     */
+    EdgeExtend: 1,
+};

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

@@ -100,6 +100,13 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @param {number} y1
      */
     private eraseArea;
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number} [padding]
+     * @return {AtlasPatch}
+     */
+    compute_padding(_sampler: any, padding?: number): AtlasPatch;
     /**
      *
      * @param {Sampler2D} sampler

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

@@ -1 +1 @@
-{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAyED;;OAEG;IACH,cASC;;CACJ;qCAxlBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}
+{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,yCAHW,MAAM,GACL,UAAU,CAIrB;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAyED;;OAEG;IACH,cASC;;CACJ;qCAlmBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}

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

@@ -268,6 +268,16 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @param {number} [padding]
      * @return {AtlasPatch}
      */
+    compute_padding(_sampler, padding = 4) {
+        return padding;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number} [padding]
+     * @return {AtlasPatch}
+     */
     add(sampler, padding = 4) {
 
         assert.notNull(sampler, 'sampler');
@@ -518,7 +528,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
              The atlas's own pixels have changed, and everything that mirrors them -- a GPU texture,
              a debug canvas -- decides whether to re-read by comparing this version. The bump belongs
              here rather than in `paintPatch`, because that is the method subclasses override: one
-             that paints into `data` itself, as `DecalAtlas` does for its borders, never reaches the
+             that paints into `data` itself, as `SpriteAtlas` does for its borders, never reaches the
              copy helper that would otherwise have moved the version for it.
             */
             this.__sampler.version++;

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

@@ -0,0 +1,52 @@
+/**
+ * Border, in texels, for a patch of this size.
+ *
+ * Driven by the longer side, because one border value protects both axes and the atlas halves both
+ * together when it builds its mip chain.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @returns {number}
+ */
+export function sprite_atlas_border(width: number, height: number): number;
+/**
+ * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
+ *
+ * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
+ * {@link SPRITE_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
+ * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
+ * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
+ * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
+ *
+ * Past this level the sampler is clamped rather than allowed to keep minifying, so a sprite seen from
+ * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
+ * shimmering sprite is still that sprite, a bleeding one is somebody else's texture.
+ *
+ * @param {number} border
+ * @returns {number}
+ */
+export function sprite_atlas_max_lod(border: number): number;
+/**
+ * How much of a patch's own size is spent on its border.
+ *
+ * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
+ * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
+ * proportion makes that limit the same for every sprite whatever its resolution. At 1/64 every patch
+ * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
+ *
+ * A fixed border does the opposite: generous for small patches and useless for large ones.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_RATIO: number;
+/**
+ * The smallest border a patch may have, in texels.
+ *
+ * One, not more. A 64x64 sprite is common and needs four texels at the very most; eight would spend a
+ * tenth of the texture on gutter to protect mip levels at which the sprite is a handful of pixels on
+ * screen. One texel is also not really one — see {@link sprite_atlas_max_lod}.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_MINIMUM: number;
+//# sourceMappingURL=sprite_atlas_border.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sprite_atlas_border.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/sprite_atlas_border.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6CAHW,MAAM,GACJ,MAAM,CAOlB;AAlED;;;;;;;;;;;GAWG;AACH,wCAFU,MAAM,CAEgC;AAEhD;;;;;;;;GAQG;AACH,0CAFU,MAAM,CAE6B"}

package/src/engine/{graphics3/decal/decal_atlas_border.js → graphics/texture/atlas/sprite_atlas_border.js}

@@ -1,69 +1,69 @@
-import { assert } from "../../../core/assert.js";
-
-/**
- * How much of a patch's own size is spent on its border.
- *
- * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
- * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
- * proportion makes that limit the same for every decal whatever its resolution. At 1/64 every patch
- * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
- *
- * A fixed border does the opposite: generous for small patches and useless for large ones.
- *
- * @type {number}
- */
-export const DECAL_ATLAS_BORDER_RATIO = 1 / 64;
-
-/**
- * The smallest border a patch may have, in texels.
- *
- * One, not more. A 64x64 decal is common and needs four texels at the very most; eight would spend a
- * tenth of the texture on gutter to protect mip levels at which the decal is a handful of pixels on
- * screen. One texel is also not really one — see {@link decal_atlas_max_lod}.
- *
- * @type {number}
- */
-export const DECAL_ATLAS_BORDER_MINIMUM = 1;
-
-/**
- * Border, in texels, for a patch of this size.
- *
- * Driven by the longer side, because one border value protects both axes and the atlas halves both
- * together when it builds its mip chain.
- *
- * @param {number} width
- * @param {number} height
- * @returns {number}
- */
-export function decal_atlas_border(width, height) {
-    assert.isNonNegativeInteger(width, 'width');
-    assert.isNonNegativeInteger(height, 'height');
-
-    return Math.max(
-        DECAL_ATLAS_BORDER_MINIMUM,
-        Math.ceil(Math.max(width, height) * DECAL_ATLAS_BORDER_RATIO)
-    );
-}
-
-/**
- * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
- *
- * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
- * {@link DECAL_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
- * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
- * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
- * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
- *
- * Past this level the sampler is clamped rather than allowed to keep minifying, so a decal seen from
- * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
- * shimmering decal is a decal, a bleeding one is somebody else's texture.
- *
- * @param {number} border
- * @returns {number}
- */
-export function decal_atlas_max_lod(border) {
-    assert.isNonNegativeInteger(border, 'border');
-    assert.greaterThanOrEqual(border, DECAL_ATLAS_BORDER_MINIMUM, 'border');
-
-    return Math.floor(Math.log2(border + 1));
-}
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * How much of a patch's own size is spent on its border.
+ *
+ * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
+ * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
+ * proportion makes that limit the same for every sprite whatever its resolution. At 1/64 every patch
+ * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
+ *
+ * A fixed border does the opposite: generous for small patches and useless for large ones.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_RATIO = 1 / 64;
+
+/**
+ * The smallest border a patch may have, in texels.
+ *
+ * One, not more. A 64x64 sprite is common and needs four texels at the very most; eight would spend a
+ * tenth of the texture on gutter to protect mip levels at which the sprite is a handful of pixels on
+ * screen. One texel is also not really one — see {@link sprite_atlas_max_lod}.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_MINIMUM = 1;
+
+/**
+ * Border, in texels, for a patch of this size.
+ *
+ * Driven by the longer side, because one border value protects both axes and the atlas halves both
+ * together when it builds its mip chain.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @returns {number}
+ */
+export function sprite_atlas_border(width, height) {
+    assert.isNonNegativeInteger(width, 'width');
+    assert.isNonNegativeInteger(height, 'height');
+
+    return Math.max(
+        SPRITE_ATLAS_BORDER_MINIMUM,
+        Math.ceil(Math.max(width, height) * SPRITE_ATLAS_BORDER_RATIO)
+    );
+}
+
+/**
+ * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
+ *
+ * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
+ * {@link SPRITE_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
+ * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
+ * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
+ * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
+ *
+ * Past this level the sampler is clamped rather than allowed to keep minifying, so a sprite seen from
+ * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
+ * shimmering sprite is still that sprite, a bleeding one is somebody else's texture.
+ *
+ * @param {number} border
+ * @returns {number}
+ */
+export function sprite_atlas_max_lod(border) {
+    assert.isNonNegativeInteger(border, 'border');
+    assert.greaterThanOrEqual(border, SPRITE_ATLAS_BORDER_MINIMUM, 'border');
+
+    return Math.floor(Math.log2(border + 1));
+}

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":"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;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAzbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}
+{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAmHI;;;OAGG;IACH,4DAkCC;IAxJD,oDAAoC;IAyFpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAoDD,2CAUC;IAED,4CAgBC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAqDD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAzbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}