@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/dist/numerals.js

@@ -0,0 +1,47 @@
+const NUMERAL_HEIGHT = 727.5;
+const DICE_NUMERALS = {
+  "0": {
+    advance: 630.9,
+    path: "M315.4 -9.8Q193.8 -9.8 126.7 87.9Q59.6 185.5 59.6 363.3Q59.6 540 127.2 638.7Q194.8 737.3 315.4 737.3Q436.5 737.3 503.9 638.7Q571.3 540 571.3 363.3Q571.3 185.5 504.4 87.9Q437.5 -9.8 315.4 -9.8ZM315.4 71.3Q395.5 71.3 438.7 148.2Q481.9 225.1 481.9 363.3Q481.9 502.4 438.7 579.6Q395.5 656.7 315.4 656.7Q235.8 656.7 192.4 579.3Q148.9 502 148.9 363.3Q148.9 225.1 192.4 148.2Q235.8 71.3 315.4 71.3Z"
+  },
+  "1": {
+    advance: 406.7,
+    path: "M205.1 727.5L318.8 727.5L318.8 0L227.5 0L227.5 641.6L222.7 641.6L46.9 511.2L46.9 610.8L205.1 727.5Z"
+  },
+  "2": {
+    advance: 609.9,
+    path: "M538.6 0L75.2 0L75.2 66.9L316.9 329.1Q357.4 373 384.3 406.3Q411.1 439.5 424.8 469.5Q438.5 499.5 438.5 533.2Q438.5 590.3 399.2 623.5Q359.9 656.7 301.8 656.7Q239.7 656.7 202.9 619.6Q166 582.5 166 521L77.1 521Q77.1 585.4 106.9 634.3Q136.7 683.1 188 710.2Q239.3 737.3 304.2 737.3Q369.1 737.3 419.2 710.2Q469.2 683.1 497.8 637.2Q526.4 591.3 526.4 534.2Q526.4 494.6 512.2 457.3Q498 419.9 462.4 372.6Q426.8 325.2 362.3 256.8L203.1 87.4L203.1 81.5L538.6 81.5L538.6 0Z"
+  },
+  "3": {
+    advance: 617.7,
+    path: "M310.1 -9.8Q238.8 -9.8 183.6 14.6Q128.4 39.1 95.9 82.5Q63.5 126 61 183.6L154.8 183.6Q158.7 131.8 202.6 101.8Q246.6 71.8 308.6 71.8Q377 71.8 421.6 106.9Q466.3 142.1 466.3 198.7Q466.3 257.8 422.4 295.2Q378.4 332.5 297.4 332.5L238.3 332.5L238.3 413.1L297.4 413.1Q361.3 413.1 401.1 447Q440.9 481 440.9 537.1Q440.9 591.3 405.8 624Q370.6 656.7 311 656.7Q273.9 656.7 241.5 643.3Q209 629.9 188.2 605Q167.5 580.1 166 544.4L76.7 544.4Q78.6 601.6 110.8 645Q143.1 688.5 196 712.9Q249 737.3 313 737.3Q380.9 737.3 429.9 710Q479 682.6 505.4 638.2Q531.7 593.8 531.7 542Q531.7 480.5 499.3 437.5Q466.8 394.5 411.1 377.9L411.1 372.1Q481 360.8 519.5 313.7Q558.1 266.6 558.1 197.8Q558.1 138.2 525.9 91.3Q493.7 44.4 437.5 17.3Q381.3 -9.8 310.1 -9.8Z"
+  },
+  "4": {
+    advance: 646,
+    path: "M400.9 147.9L58.6 147.9L58.6 223.6L377 727.5L489.7 727.5L489.7 229.5L588.4 229.5L588.4 147.9L489.7 147.9L489.7 0L400.9 0L400.9 147.9ZM157.7 229.5L401.4 229.5L401.4 611.3L395.5 611.3L157.7 235.4L157.7 229.5Z"
+  },
+  "5": {
+    advance: 607.9,
+    path: "M305.7 -9.8Q241.7 -9.8 190.9 15.4Q140.1 40.5 109.9 84.2Q79.6 127.9 77.1 183.6L167 183.6Q171.4 134.8 211.2 103.3Q251 71.8 305.7 71.8Q349.6 71.8 384 92.3Q418.5 112.8 438 148.9Q457.5 185.1 457.5 231Q457.5 277.8 437 314.9Q416.5 352.1 381.1 373.3Q345.7 394.5 299.8 394.5Q266.1 394.5 231.4 383.8Q196.8 373 175.3 356.4L88.4 367.2L131.3 727.5L514.2 727.5L514.2 646L209.5 646L184.6 433.6L188.5 433.6Q210.9 452.1 245.1 464.1Q279.3 476.1 316.9 476.1Q383.8 476.1 436 444.6Q488.3 413.1 518.3 357.9Q548.3 302.7 548.3 232.4Q548.3 162.6 516.8 107.9Q485.4 53.2 430.7 21.7Q376 -9.8 305.7 -9.8Z"
+  },
+  "6": {
+    advance: 620.1,
+    path: "M315.4 -9.8Q270 -9.8 224.6 6.8Q179.2 23.4 141.8 62.5Q104.5 101.6 82 168.5Q59.6 235.4 59.6 335.9Q59.6 527.8 131.3 632.6Q203.1 737.3 326.7 737.3Q387.7 737.3 436 712.9Q484.4 688.5 515.1 645Q545.9 601.6 554.7 544.4L463.9 544.4Q451.7 591.8 417.5 623.5Q383.3 655.3 326.7 655.3Q242.7 655.3 195.1 582.8Q147.5 510.3 147.5 378.9L153.3 378.9Q182.6 424.3 229.2 450Q275.9 475.6 332.5 475.6Q395 475.6 446.8 444.8Q498.5 414.1 529.5 359.6Q560.5 305.2 560.5 234.9Q560.5 167 530.3 111.6Q500 56.2 444.8 23.2Q389.6 -9.8 315.4 -9.8ZM315.4 71.8Q359.4 71.8 394.5 93.8Q429.7 115.7 450.2 152.6Q470.7 189.5 470.7 234.9Q470.7 279.3 450.9 315.7Q431.2 352.1 396.5 373.5Q361.8 395 317.9 395Q273.9 395 238.3 372.6Q202.6 350.1 181.6 313.2Q160.6 276.4 160.6 233.9Q160.6 190.9 180.7 154.1Q200.7 117.2 235.8 94.5Q271 71.8 315.4 71.8Z"
+  },
+  "7": {
+    advance: 565.9,
+    path: "M195.3 0L97.7 0L420.9 640.1L420.9 646L47.9 646L47.9 727.5L518.1 727.5L518.1 641.1L195.3 0Z"
+  },
+  "8": {
+    advance: 618.7,
+    path: "M309.1 -9.8Q235.4 -9.8 179 16.4Q122.6 42.5 91.1 88.4Q59.6 134.3 59.6 193.4Q59.6 239.3 78.1 278.6Q96.7 317.9 128.9 344.2Q161.1 370.6 201.7 377.9L201.7 381.8Q148.4 395.5 117.2 440.9Q85.9 486.3 85.9 543.9Q85.9 599.6 114.7 643.3Q143.6 687 193.8 712.2Q244.1 737.3 309.1 737.3Q373 737.3 423.3 712.2Q473.6 687 502.7 643.3Q531.7 599.6 531.7 543.9Q531.7 486.3 500.2 440.9Q468.8 395.5 417 381.8L417 377.9Q456.5 370.6 488.8 344.2Q521 317.9 540 278.6Q559.1 239.3 559.1 193.4Q559.1 134.3 527.1 88.4Q495.1 42.5 438.7 16.4Q382.3 -9.8 309.1 -9.8ZM309.1 70.8Q381.3 70.8 423.8 105.7Q466.3 140.6 466.3 198.2Q466.3 238.8 445.8 269.8Q425.3 300.8 389.6 318.6Q354 336.4 309.1 336.4Q240.2 336.4 195.6 297.6Q150.9 258.8 150.9 198.2Q150.9 140.6 193.1 105.7Q235.4 70.8 309.1 70.8ZM309.1 414.1Q366.7 414.1 404.3 448Q441.9 481.9 441.9 537.1Q441.9 591.8 405.3 624.5Q368.7 657.2 309.1 657.2Q248.5 657.2 212.2 624.5Q175.8 591.8 175.8 537.1Q175.8 481.9 212.9 448Q250 414.1 309.1 414.1Z"
+  },
+  "9": {
+    advance: 620.1,
+    path: "M294.4 -9.8Q232.4 -9.8 184.1 14.6Q135.7 39.1 105 83Q74.2 127 65.4 185.1L157.2 185.1Q168.5 136.7 202.6 104.5Q236.8 72.3 294.4 72.3Q377.4 72.3 425.5 144.8Q473.6 217.3 473.6 349.6L467.8 349.6Q438.5 305.2 392.1 278.8Q345.7 252.4 288.6 252.4Q226.1 252.4 173.8 283.4Q121.6 314.5 90.6 368.9Q59.6 423.3 59.6 493.2Q59.6 561 90.3 616.9Q121.1 672.9 176.5 705.8Q231.9 738.8 306.6 737.3Q351.6 736.8 396.5 720Q441.4 703.1 478.5 664.6Q515.6 626 538.1 559.6Q560.5 493.2 560.5 392.6Q560.5 199.7 489.3 95Q418 -9.8 294.4 -9.8ZM302.2 333.5Q346.7 333.5 382.3 356.2Q418 378.9 439.2 416Q460.4 453.1 460.4 495.6Q460.4 537.6 440.2 574Q419.9 610.4 385 633.1Q350.1 655.8 305.2 655.8Q261.2 655.8 226.3 634Q191.4 612.3 170.9 575.4Q150.4 538.6 150.4 493.7Q150.4 449.2 170.2 412.8Q189.9 376.5 224.1 355Q258.3 333.5 302.2 333.5Z"
+  }
+};
+export {
+  DICE_NUMERALS,
+  NUMERAL_HEIGHT
+};

package/dist/plugin.d.ts

@@ -0,0 +1,41 @@
+import { type AssetRef } from '@aethervtt/shard-core';
+import type { TrackWorkerLike } from '@aethervtt/shard-physics/worker';
+import { type Plugin } from '@aethervtt/shard-runtime';
+import { type DieKind } from './builtins.js';
+export interface DicePluginOptions {
+    /** The dice camera: a top-down view of the tray, clearing to alpha 0 (0052). */
+    camera?: {
+        fovY?: number;
+        /** A RenderTargets ref; null renders into the app's surface. */
+        target?: AssetRef<'RenderTarget'> | null;
+        order?: number;
+        ev100?: number;
+    };
+    /** How long dice rest before the presentation finishes, ms. Default 60 s. */
+    restMs?: number;
+    /** Bodies a roll may put on the table (percentile is two). Default 32. */
+    maxDice?: number;
+    /** Makes the track worker: `diceWorker` from `@aethervtt/shard-dice/worker`, or 'inline'. */
+    worker?: (() => TrackWorkerLike) | 'inline';
+    /** The clock rests and releases run on, ms. Default `performance.now`. */
+    now?: () => number;
+    /** Definitions a kind plays, when not the built-ins. */
+    kinds?: Partial<Record<DieKind, readonly string[]>>;
+    /** The key light's illuminance, lux. Default 60,000. */
+    illuminance?: number;
+    /** Image-based light from a small procedural studio. Default true. */
+    environment?: boolean;
+    /**
+     * How long a roll waits, past its physics, for an entrance's assets and warm-up before its die
+     * drops in instead (0065). Default 1,500 ms.
+     */
+    entranceWaitMs?: number;
+}
+/** Where the dice camera looks from: straight down, screen-up toward -z. */
+export declare const TOP_DOWN: [number, number, number, number];
+/**
+ * Dice (0054): the table, its camera, key light, image-based light and shadow-catching tray, and
+ * the systems that present rolls. Needs `forwardPlugin` (render/forward, the shadow catcher, the
+ * environment). Add `particlesPlugin` for particle bursts and `audioPlugin` for sound.
+ */
+export declare function dicePlugin(options?: DicePluginOptions): Plugin;

package/dist/plugin.js

@@ -0,0 +1,174 @@
+import { defineSystem, Update } from "@aethervtt/shard-core";
+import {
+  addShaderVariantSource,
+  Camera3d,
+  DirectionalLight,
+  EnvironmentMap,
+  Exposure,
+  GpuDeviceLost,
+  InstanceData,
+  MaterialAsset,
+  Materials,
+  Mesh3d,
+  Meshes,
+  MeshMaterial,
+  NotShadowCaster,
+  registerShaders,
+  Shaders
+} from "@aethervtt/shard-render";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { Textures } from "@aethervtt/shard-texture";
+import { lookAt, Transform } from "@aethervtt/shard-transform";
+import { KIND_DEFINITIONS, registerBuiltinDice } from "./builtins.js";
+import { DiceDie, DiceRollRequest } from "./components.js";
+import { DieDefinitionAsset } from "./definition-asset.js";
+import { DiceEffectRecipe } from "./effects.js";
+import { BUILTIN_FAMILIES } from "./families.js";
+import { registerBuiltinGlyphs } from "./glyphs.js";
+import { FaceLayout, NUMBERS_LAYOUT, PIPS_LAYOUT } from "./layout.js";
+import { allDiceFamilies, DICE_SHADERS } from "./material.js";
+import { floorQuad } from "./mesh.js";
+import { diceMethods } from "./methods.js";
+import { BUILTIN_SKINS, DICE_SKINS, DiceSkin, diceSkin } from "./skin.js";
+import { studioEnvironment } from "./studio.js";
+import { DiceTable, DiceTableState, ENTRANCE_WAIT_MS } from "./table.js";
+import { DiceTray, TRAY_SHADERS } from "./tray.js";
+import { diceVariants } from "./variants.js";
+const TOP_DOWN = [-Math.SQRT1_2, 0, 0, Math.SQRT1_2];
+const tableFrame = defineSystem({
+  name: "dice/table",
+  description: "Plays the dice presentation: samples the track, lands, accents, rests, releases.",
+  run: (_, world) => world.resource(DiceTable).frame()
+});
+const deviceLoss = defineSystem({
+  name: "dice/device-loss",
+  description: "Fails a playing roll when the GPU device is lost.",
+  setup: (world) => world.reader(GpuDeviceLost),
+  run: (reader, world) => {
+    const lost = reader.read();
+    if (lost.length > 0) world.resource(DiceTable).deviceLost(lost[0].message);
+  }
+});
+const rollRequests = defineSystem({
+  name: "dice/roll-requests",
+  description: "Plays the roll of each new dice/RollRequest entity, then removes the request.",
+  run: (_, world) => {
+    const found = [];
+    for (const e of world.query({ with: [DiceRollRequest] }).entities()) found.push(e);
+    if (found.length === 0) return;
+    const table = world.resource(DiceTable);
+    for (const e of found) {
+      const request = world.get(e, DiceRollRequest);
+      world.remove(e, DiceRollRequest);
+      void table.play(request.roll, { replace: request.replace }).catch((err) => {
+        table.lastError = err;
+      });
+    }
+  }
+});
+function dicePlugin(options = {}) {
+  return definePlugin({
+    name: "dice",
+    dependencies: ["render/forward", "render/shadow-catcher"],
+    provides: [
+      DiceTable,
+      DiceDie,
+      DiceRollRequest,
+      DiceSkin,
+      FaceLayout,
+      DiceEffectRecipe,
+      DieDefinitionAsset,
+      DiceTray,
+      BUILTIN_FAMILIES,
+      tableFrame,
+      rollRequests
+    ],
+    build(app) {
+      registerBuiltinDice();
+      registerBuiltinGlyphs();
+      const world = app.world;
+      addShaderVariantSource(world, diceVariants);
+      world.initResource(DiceSkin.store);
+      world.initResource(FaceLayout.store);
+      world.initResource(DiceEffectRecipe.store);
+      const skins = world.resource(DiceSkin.store);
+      for (const [name, json] of Object.entries(BUILTIN_SKINS)) {
+        skins.set(DICE_SKINS[name].guid, diceSkin(json));
+      }
+      const layouts = world.resource(FaceLayout.store);
+      layouts.set("dice:layout/numbers", NUMBERS_LAYOUT);
+      layouts.set("dice:layout/pips", PIPS_LAYOUT);
+      world.insertResource(
+        DiceTable,
+        new DiceTableState(world, {
+          restMs: options.restMs ?? 6e4,
+          maxDice: options.maxDice ?? 32,
+          now: options.now ?? (() => performance.now()),
+          kinds: { ...KIND_DEFINITIONS, ...options.kinds },
+          worker: options.worker ?? "inline",
+          fovY: options.camera?.fovY ?? 35,
+          entranceWaitMs: options.entranceWaitMs ?? ENTRANCE_WAIT_MS
+        })
+      );
+      app.addSystems(Update, tableFrame, rollRequests, deviceLoss);
+      app.addMethod(...diceMethods);
+    },
+    ready(app) {
+      const world = app.world;
+      const shaders = { ...DICE_SHADERS, ...TRAY_SHADERS };
+      for (const family of allDiceFamilies())
+        if (family.module) shaders[family.module.path] = family.module.source;
+      registerShaders(world.resource(Shaders), shaders);
+      const table = world.resource(DiceTable);
+      const quad = world.resource(Meshes).add(floorQuad(), "dice:tray");
+      const trayMaterial = world.resource(Materials).add(new MaterialAsset({}, DiceTray), "dice:tray");
+      table.quad = quad;
+      table.trayMaterial = trayMaterial;
+      table.floor = world.spawn(
+        [Mesh3d, { mesh: quad }],
+        [MeshMaterial, { material: trayMaterial }],
+        [InstanceData, { x: 0, y: 0 }],
+        NotShadowCaster,
+        [Transform, { scale: [7.5, 1, 4.4] }]
+      );
+      table.light = world.spawn(
+        [
+          DirectionalLight,
+          { illuminance: options.illuminance ?? 6e4, shadows: true, color: [1, 0.97, 0.91, 1] }
+        ],
+        [Transform, { rotation: lightRotation() }]
+      );
+      const q = lightRotation();
+      const fx = -2 * (q[0] * q[2] + q[3] * q[1]);
+      const fz = -(1 - 2 * (q[0] * q[0] + q[1] * q[1]));
+      const fl = Math.sqrt(fx * fx + fz * fz) || 1;
+      table.shadowDir = [fx / fl, fz / fl];
+      const cam = options.camera ?? {};
+      table.camera = world.spawn(
+        [
+          Camera3d,
+          {
+            fovY: cam.fovY ?? 35,
+            clearColor: [0, 0, 0, 0],
+            ...cam.target ? { target: cam.target } : {},
+            ...cam.order !== void 0 ? { order: cam.order } : {}
+          }
+        ],
+        [Exposure, { ev100: cam.ev100 ?? 13 }],
+        [Transform, { translation: [0, 14, 0], rotation: TOP_DOWN }]
+      );
+      if (options.environment !== false) {
+        const texture = world.resource(Textures).add(studioEnvironment(), "dice:studio");
+        world.add(table.camera, EnvironmentMap, { texture, intensity: 2600 });
+      }
+    },
+    dispose(app) {
+      app.world.tryResource(DiceTable)?.dispose();
+    }
+  });
+}
+const lightRotation = () => lookAt([-3.4, 10, 4.2], [0, 0, 0]);
+export {
+  TOP_DOWN,
+  dicePlugin
+};

package/dist/preview.d.ts

@@ -0,0 +1,32 @@
+import { type AssetRef } from '@aethervtt/shard-core';
+import { type App } from '@aethervtt/shard-runtime';
+import type { DieKind } from './builtins.js';
+export interface DiceThumbnailOptions {
+    skin: AssetRef;
+    kind: DieKind;
+    /** The value on top (a percentile's 1..100 shows its tens die unless `part` says units). */
+    value: number;
+    part?: 'tens' | 'units';
+    /** Pixels, square. Default 128. */
+    size?: number;
+    /** PNG bytes (straight alpha), or the GPU texture itself (yours to destroy). Default 'png'. */
+    output?: 'png' | 'texture';
+    /**
+     * Draws it blended or opaque; default as its family draws a die at rest. Dropped dice and large
+     * pools draw some families the other way, so a shader bake (0064) shows both.
+     */
+    blended?: boolean;
+}
+export interface DiceThumbnail {
+    width: number;
+    height: number;
+    png: Uint8Array | undefined;
+    texture: GPUTexture | undefined;
+}
+/**
+ * Renders one landed die of a skin into an offscreen target on the app's own device (no new
+ * device, no canvas): its value on top, reading upright, seen from above at an angle. The app
+ * needs `dicePlugin`. In an app a runner drives, the frames come by themselves; a manual app
+ * (tests, tools) is stepped here.
+ */
+export declare function renderDiceThumbnail(app: App, options: DiceThumbnailOptions): Promise<DiceThumbnail>;

package/dist/preview.js

@@ -0,0 +1,123 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { encodePng } from "@aethervtt/shard-protocol";
+import {
+  Camera3d,
+  captureView,
+  EnvironmentMap,
+  Exposure,
+  Gpu,
+  InstanceData,
+  Mesh3d,
+  MeshMaterial,
+  OffscreenTarget,
+  RenderStats,
+  RenderTargets,
+  Shaders
+} from "@aethervtt/shard-render";
+import { FrameDemand, LOADING_DEMAND } from "@aethervtt/shard-runtime";
+import { lookAt, Transform } from "@aethervtt/shard-transform";
+import { dieGeometry, requireDie } from "./definition.js";
+import { restingHeight, restRotation } from "./landing.js";
+import { expandRoll } from "./roll.js";
+import { DiceSkin } from "./skin.js";
+import { DiceTable } from "./table.js";
+let slot = 0;
+async function renderDiceThumbnail(app, options) {
+  const world = app.world;
+  const table = world.resource(DiceTable);
+  const size = options.size ?? 128;
+  const all = expandRoll({
+    id: "thumbnail",
+    dice: [{ kind: options.kind, value: options.value, skin: options.skin }]
+  });
+  const die = all[options.part === "units" ? all.length - 1 : 0];
+  const skin = world.resource(DiceSkin.store).get(options.skin);
+  if (!skin) {
+    throw new ShardError(
+      "dice/unknown-skin",
+      `No dice skin ${options.skin.guid ?? options.skin.path}`,
+      {
+        hint: "Load the skin (or add it to DiceSkin.store) first."
+      }
+    );
+  }
+  const g = dieGeometry(requireDie(die.definition));
+  const skinKey = options.skin.guid ?? options.skin.path ?? "";
+  const entry = table.resources.acquire(g, skinKey, skin, die.kind, (r) => table.layout(r), {});
+  const material = table.resources.material(entry, {
+    blended: options.blended ?? table.resources.blendedByNature(entry),
+    dropped: false
+  });
+  const x = 1e4 + slot++ % 64 * 20;
+  const scale = 1;
+  const rotation = restRotation(g, die.value);
+  const y = restingHeight(g, rotation, scale);
+  const gpu = world.resource(Gpu);
+  const target = new OffscreenTarget(gpu, { label: "dice-thumbnail", width: size, height: size });
+  const targetRef = world.resource(RenderTargets).add(target, `dice:thumbnail/${x}`);
+  const dieEntity = world.spawn(
+    [Mesh3d, { mesh: entry.mesh }],
+    [MeshMaterial, { material }],
+    [Transform, { translation: [x, y, 0], rotation, scale: [scale, scale, scale] }],
+    [InstanceData, { x: die.value, y: 0 }]
+  );
+  const reach = g.footprint * 0.5 * scale;
+  const fov = 30;
+  const distance = reach / Math.tan(fov / 2 * Math.PI / 180) * 1.45;
+  const eye = [x, y + distance * 0.82, distance * 0.57];
+  const camera = world.spawn(
+    [Camera3d, { fovY: fov, clearColor: [0, 0, 0, 0], target: targetRef, order: 50 }],
+    [Exposure, { ev100: 13 }],
+    [Transform, { translation: eye, rotation: lookAt(eye, [x, y * 0.6, 0], [0, 0, -1]) }]
+  );
+  const env = world.tryGet(table.camera, EnvironmentMap);
+  if (env) world.add(camera, EnvironmentMap, { texture: env.texture, intensity: env.intensity });
+  const view = `camera:${camera}`;
+  const manual = world.resource(FrameDemand).mode === "manual";
+  try {
+    const demand = world.resource(FrameDemand);
+    let image;
+    for (let i = 0; i < 240; i++) {
+      const shot = captureView(world, view);
+      if (manual) {
+        app.update(1 / 60);
+        await world.resource(Shaders).whenIdle();
+        await gpu.pipelines.whenIdle();
+      }
+      const frame = await shot;
+      const stats = world.resource(RenderStats).get(view);
+      if (stats && stats.drawCalls > 0 && stats.pending === 0 && !demand.isHeld(LOADING_DEMAND)) {
+        image = frame;
+        break;
+      }
+      if (!manual) await gpu.pipelines.whenIdle();
+    }
+    if (!image)
+      throw new ShardError("dice/thumbnail-failed", "The thumbnail never finished rendering");
+    if (options.output === "texture") {
+      return { width: size, height: size, png: void 0, texture: target.texture() };
+    }
+    const data = new Uint8Array(image.data);
+    for (let i = 0; i < data.length; i += 4) {
+      const a = data[i + 3];
+      if (a === 0 || a === 255) continue;
+      for (let k = 0; k < 3; k++) data[i + k] = Math.min(255, Math.round(data[i + k] * 255 / a));
+    }
+    return {
+      width: size,
+      height: size,
+      png: await encodePng(data, image.width, image.height),
+      texture: void 0
+    };
+  } finally {
+    world.despawn(dieEntity);
+    world.despawn(camera);
+    world.resource(RenderTargets).delete(targetRef.guid);
+    if (options.output !== "texture") target.destroy();
+    table.resources.release(entry, table.options.now());
+    world.resource(FrameDemand).after(8016);
+  }
+}
+export {
+  renderDiceThumbnail
+};

package/dist/quality.d.ts

@@ -0,0 +1,12 @@
+import type { DiceQualityPreference } from './roll.js';
+export type DiceQuality = 'full' | 'balanced' | 'large-pool';
+export interface DiceQualityChoice {
+    tier: DiceQuality;
+    /** Why, for `dice.describe`. */
+    reason: string;
+}
+/**
+ * The tier for a number of bodies and a preference: `auto` is full up to 12, balanced to 16, then
+ * large-pool; `balanced` holds to 12 and `full` to 24 before large-pool takes over.
+ */
+export declare function resolveDiceQuality(count: number, preference?: DiceQualityPreference): DiceQualityChoice;

package/dist/quality.js

@@ -0,0 +1,18 @@
+function resolveDiceQuality(count, preference = "auto") {
+  const n = `${count} ${count === 1 ? "die" : "dice"}`;
+  switch (preference) {
+    case "large-pool":
+      return { tier: "large-pool", reason: "large-pool asked for" };
+    case "full":
+      return count > 24 ? { tier: "large-pool", reason: `full asked for, but ${n} is over 24` } : { tier: "full", reason: `full asked for (${n})` };
+    case "balanced":
+      return count > 12 ? { tier: "large-pool", reason: `balanced asked for, but ${n} is over 12` } : { tier: "balanced", reason: `balanced asked for (${n})` };
+    default:
+      if (count > 16) return { tier: "large-pool", reason: `auto: ${n}, over 16` };
+      if (count > 12) return { tier: "balanced", reason: `auto: ${n}, over 12` };
+      return { tier: "full", reason: `auto: ${n}` };
+  }
+}
+export {
+  resolveDiceQuality
+};

package/dist/resources.d.ts

@@ -0,0 +1,85 @@
+import type { AssetRef, World } from '@aethervtt/shard-core';
+import type { DieKind } from './builtins.js';
+import type { DieGeometry } from './definition.js';
+import type { FaceLayoutValue } from './layout.js';
+import { type BakeMarksOptions, type MarkAtlas } from './marks.js';
+import { type DiceFamily } from './material.js';
+import { type DiceSkinValue } from './skin.js';
+export declare const RELEASE_AFTER_MS = 8000;
+/** Which material a die draws with. */
+export interface DiceLookKey {
+    /**
+     * Premultiplied: dropped dice, fading dice, see-through families (but for the large-pool tier,
+     * which draws those opaque so they batch).
+     */
+    blended: boolean;
+    dropped: boolean;
+    /**
+     * An entrance die's index (0065): it draws with a material of its own, so its result and
+     * resultTime are its own (it lands after the dice sharing its kind and skin).
+     */
+    entrance?: number;
+}
+export interface DiceResourceEntry {
+    key: string;
+    geometry: DieGeometry;
+    kind: DieKind;
+    family: DiceFamily;
+    refs: number;
+    releaseAt: number;
+    mesh: AssetRef<'Mesh'>;
+    atlas: MarkAtlas;
+    texture: AssetRef<'Texture'>;
+    params: Record<string, unknown>;
+    materials: Map<string, AssetRef<'Material'>>;
+    /** Entrance dice's own materials (0065), by look: apart, so setAll leaves them be. */
+    own: Map<string, AssetRef<'Material'>>;
+}
+export declare class DiceResources {
+    private readonly entries;
+    private readonly world;
+    /** The earliest release due (Infinity when none): checked every frame, so kept, not searched. */
+    private due;
+    constructor(world: World);
+    /**
+     * The resources for one kind of die in one skin, made on first use. Each acquire needs a
+     * release. Throws `dice/unknown-family` for a skin whose family isn't defined.
+     */
+    acquire(geometry: DieGeometry, skinKey: string, skin: DiceSkinValue, kind: DieKind, layouts: (ref: AssetRef) => FaceLayoutValue | undefined, bake: BakeMarksOptions): DiceResourceEntry;
+    /** The entry's material for a look, made on first use. */
+    material(entry: DiceResourceEntry, look: DiceLookKey): AssetRef<'Material'>;
+    /** Whether dice of this entry need blending in their normal look (glass, see-through resin). */
+    blendedByNature(entry: DiceResourceEntry): boolean;
+    /** Whether the family's type fixes a blend: its dice blend in every tier, large pools too. */
+    fixedBlend(entry: DiceResourceEntry): boolean;
+    /**
+     * Sets a field on every material of these entries (result, its time, fade); entrance dice's own
+     * (in `own`) follow their own landing.
+     */
+    setAll(entries: Iterable<DiceResourceEntry>, field: 'result' | 'resultTime' | 'fade', value: number): void;
+    release(entry: DiceResourceEntry, now: number): void;
+    /** The earliest release due, or Infinity. */
+    nextRelease(): number;
+    /** Frees entries unused for 8 s. Returns how many. */
+    sweep(now: number): number;
+    private free;
+    /** Frees everything, used or not (teardown). */
+    dispose(): void;
+    stats(): {
+        entries: number;
+        used: number;
+        meshes: number;
+        atlases: number;
+        materials: number;
+    };
+    describe(): {
+        key: string;
+        die: string;
+        kind: DieKind;
+        family: string;
+        refs: number;
+        releaseInMs: number | null;
+        materials: string[];
+        atlas: [number, number];
+    }[];
+}