@woosh/meep-engine 3.52.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/AnimationGraphSystem.d.ts

@@ -1,12 +1,13 @@
 /**
- * Drives every entity's {@link AnimationGraphController}: runs its clock, and tells the renderer
- * what its clips weigh and where they are playing.
+ * Drives every entity's {@link AnimationGraphController}: runs its clock, writes its clips' weights
+ * and times into the entity's {@link AnimationClips}, and hands that blend to the renderer through
+ * {@link AnimationClipsSink}.
  *
  * **The clips are the entity's {@link AnimationClips}.** An entity is driven while it carries both
  * components, whoever put them there — a model `MeshSystem` loaded, or a rig built in code. New
  * clips are a new component, which this system sees as the entity leaving and coming back.
  *
- * **Every node the clips key holds a row here** ({@link hold_clip_targets}), from the graph being
+ * **Every node the clips key holds a row here** ({@link AnimationClipsSink}), from the graph being
  * bound to the clips until they go. A clip binds only once all of them do, and a keyed node outside
  * every skin with nothing drawn under it — a socket, say — is held by no other system.
  *
@@ -27,8 +28,8 @@ export class AnimationGraphSystem extends System<any> {
      * @param {Scene} scene
      */
     constructor(graphics: GraphicsEngine, scene: Scene);
-    dependencies: (typeof AnimationGraphController | typeof AnimationClips)[];
-    components_used: ResourceAccessSpecification<typeof AnimationGraphController>[];
+    dependencies: (typeof AnimationClips | typeof AnimationGraphController)[];
+    components_used: (ResourceAccessSpecification<typeof AnimationClips> | ResourceAccessSpecification<typeof AnimationGraphController>)[];
     /**
      * Only noted here: the graph is bound to the clips by the next {@link update}. A link can happen
      * anywhere the components are added — inside a model's spawn, for one `MeshSystem` loads — and a
@@ -41,21 +42,8 @@ export class AnimationGraphSystem extends System<any> {
      */
     link(controller: AnimationGraphController, clips: AnimationClips, entity: number): void;
     /**
-     * What the entity is playing, in the form the CPU pose evaluator takes: one entry per clip
-     * **this graph names**, at the weight and the time the renderer has been given.
-     *
-     * **The clips the graph does not name are not here, because they are not registered** (D37).
-     * The GPU's accumulator marks a joint dirty for every bound clip that writes to it, weight and
-     * all — so a bound clip at weight zero resolves the joints only it drives to zero rather than
-     * leaving them at rest. The answer is not to hand those clips to the evaluator so it can make
-     * the same mistake; it is not to bind them. What the graph never names, nothing plays, and the
-     * joints it alone would have driven stay where they rest.
-     *
-     * A clip the graph names but is not currently playing **is** here, at weight zero, because it is
-     * bound and the accumulator does see it.
-     *
-     * The entries are this system's own and are rewritten by the next call, which is what keeps a
-     * query on a per-frame path from allocating.
+     * What the entity is playing, in the form the CPU pose evaluator takes: delegates to the
+     * entity's {@link AnimationClips#write_pose_playbacks}.
      *
      * @param {PosePlayback[]} target appended to
      * @param {number} entity
@@ -75,8 +63,7 @@ export class AnimationGraphSystem extends System<any> {
     #private;
 }
 import { System } from "../ecs/System.js";
-import { AnimationGraphController } from "./animation/AnimationGraphController.js";
 import { AnimationClips } from "./animation/AnimationClips.js";
+import { AnimationGraphController } from "./animation/AnimationGraphController.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
-import { PosePlayback } from "../../shade/renderer/animation/pose/PosePlayback.js";
 //# sourceMappingURL=AnimationGraphSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AnimationGraphSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationGraphSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAyBI;;;OAGG;IACH,oDAgBC;IAPG,0EAA8D;IAI9D,gFAEC;IAGL;;;;;;;;;OASG;IACH,iBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAehB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BANW,YAAY,EAAE,UACd,MAAM,GACJ,OAAO,CAgDnB;IAED;;;;OAIG;IACH,mBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAkBhB;IAED,2CAaC;IAED,4CAWC;;CA2JJ;uBAvXsB,kBAAkB;yCAEA,yCAAyC;+BADnD,+BAA+B;4CAHlB,iDAAiD;6BAChE,qDAAqD"}
+{"version":3,"file":"AnimationGraphSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/AnimationGraphSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAWI;;;OAGG;IACH,oDAcC;IATG,0EAA8D;IAK9D,uIAGC;IAGL;;;;;;;;;OASG;IACH,iBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,6BANW,cAAc,UACd,MAAM,GACJ,OAAO,CAYnB;IAED;;;;OAIG;IACH,mBAJW,wBAAwB,SACxB,cAAc,UACd,MAAM,QAYhB;IAED,2CAEC;IAED,4CAYC;;CAoGJ;uBAxOsB,kBAAkB;+BACV,+BAA+B;yCAErB,yCAAyC;4CAJtC,iDAAiD"}