@aethervtt/shard-dice 0.0.0-stage → 0.2.0

package/dist/resources.js

@@ -0,0 +1,191 @@
+import { GpuAssetsResource, MaterialAsset, Materials, Meshes } from "@aethervtt/shard-render";
+import { Texture, Textures } from "@aethervtt/shard-texture";
+import { bakeMarks } from "./marks.js";
+import { findDiceFamily } from "./material.js";
+import { dieMesh } from "./mesh.js";
+import { skinVariant } from "./skin.js";
+const RELEASE_AFTER_MS = 8e3;
+const lookKey = (l) => `${l.blended ? "b" : "o"}${l.dropped ? "d" : ""}${l.entrance === void 0 ? "" : `@${l.entrance}`}`;
+class DiceResources {
+  entries = /* @__PURE__ */ new Map();
+  world;
+  /** The earliest release due (Infinity when none): checked every frame, so kept, not searched. */
+  due = Number.POSITIVE_INFINITY;
+  constructor(world) {
+    this.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, skinKey, skin, kind, layouts, bake) {
+    const key = `${geometry.hash.toString(16)}|${skinKey}|${kind}`;
+    let entry = this.entries.get(key);
+    if (!entry) {
+      const family = findDiceFamily(skin.family);
+      if (!family) throw new Error(`unknown family ${skin.family}`);
+      const variant = skinVariant(skin, kind, geometry.definition.id, layouts);
+      const atlas = bakeMarks(geometry, variant.layout, bake);
+      const texture = this.world.resource(Textures).add(
+        Texture.create({
+          width: atlas.width,
+          height: atlas.height,
+          format: "rgba8unorm",
+          usage: "data",
+          mips: [atlas.pixels],
+          cpu: true
+        }),
+        `dice:marks/${geometry.definition.id}`
+      );
+      const mesh = this.world.resource(Meshes).add(
+        dieMesh(geometry, variant.bevel),
+        `dice:mesh/${geometry.definition.id}`
+      );
+      entry = {
+        key,
+        geometry,
+        kind,
+        family,
+        refs: 0,
+        releaseAt: Number.POSITIVE_INFINITY,
+        mesh,
+        atlas,
+        texture,
+        params: variant.params,
+        materials: /* @__PURE__ */ new Map(),
+        own: /* @__PURE__ */ new Map()
+      };
+      this.entries.set(key, entry);
+    }
+    entry.refs++;
+    entry.releaseAt = Number.POSITIVE_INFINITY;
+    return entry;
+  }
+  /** The entry's material for a look, made on first use. */
+  material(entry, look) {
+    const k = lookKey(look);
+    const store = look.entrance === void 0 ? entry.materials : entry.own;
+    const existing = store.get(k);
+    if (existing) return existing;
+    const family = entry.family;
+    const schema = family.type.schema;
+    const params = {};
+    for (const [name, v] of Object.entries(entry.params))
+      if (name in schema.fields) params[name] = v;
+    const value = schema.deserialize(params);
+    value.marks = entry.texture;
+    value.dropped = look.dropped ? 1 : 0;
+    value.fade = 1;
+    value.result = 0;
+    if (look.blended && !family.type.blend) value.alphaMode = "premultiplied";
+    const ref = this.world.resource(Materials).add(
+      new MaterialAsset(value, family.type),
+      `dice:material/${entry.key}/${k}`
+    );
+    store.set(k, ref);
+    return ref;
+  }
+  /** Whether dice of this entry need blending in their normal look (glass, see-through resin). */
+  blendedByNature(entry) {
+    return this.fixedBlend(entry) || (entry.family.translucent?.(entry.params) ?? false);
+  }
+  /** Whether the family's type fixes a blend: its dice blend in every tier, large pools too. */
+  fixedBlend(entry) {
+    const blend = entry.family.type.blend;
+    return blend === "alpha" || blend === "premultiplied" || blend === "additive";
+  }
+  /**
+   * 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, field, value) {
+    const materials = this.world.resource(Materials);
+    for (const entry of entries) {
+      for (const ref of entry.materials.values()) {
+        const m = materials.get(ref);
+        if (m && m.value[field] !== value) m.set({ [field]: value });
+      }
+    }
+  }
+  release(entry, now) {
+    entry.refs = Math.max(0, entry.refs - 1);
+    if (entry.refs === 0) {
+      entry.releaseAt = now + RELEASE_AFTER_MS;
+      this.due = Math.min(this.due, entry.releaseAt);
+    }
+  }
+  /** The earliest release due, or Infinity. */
+  nextRelease() {
+    return this.due;
+  }
+  /** Frees entries unused for 8 s. Returns how many. */
+  sweep(now) {
+    let n = 0;
+    this.due = Number.POSITIVE_INFINITY;
+    for (const entry of [...this.entries.values()]) {
+      if (entry.refs > 0) continue;
+      if (entry.releaseAt > now) {
+        this.due = Math.min(this.due, entry.releaseAt);
+        continue;
+      }
+      this.free(entry);
+      n++;
+    }
+    return n;
+  }
+  free(entry) {
+    const world = this.world;
+    const gpu = world.tryResource(GpuAssetsResource);
+    const meshes = world.resource(Meshes);
+    const materials = world.resource(Materials);
+    const textures = world.resource(Textures);
+    const mesh = meshes.get(entry.mesh);
+    if (mesh) gpu?.releaseMesh(mesh);
+    meshes.delete(entry.mesh.guid);
+    for (const ref of [...entry.materials.values(), ...entry.own.values()]) {
+      const m = materials.get(ref);
+      if (m) gpu?.releaseMaterial(m);
+      materials.delete(ref.guid);
+    }
+    const texture = textures.get(entry.texture);
+    if (texture) gpu?.releaseTexture(texture);
+    textures.delete(entry.texture.guid);
+    this.entries.delete(entry.key);
+  }
+  /** Frees everything, used or not (teardown). */
+  dispose() {
+    for (const entry of [...this.entries.values()]) this.free(entry);
+    this.due = Number.POSITIVE_INFINITY;
+  }
+  stats() {
+    let used = 0;
+    let materials = 0;
+    for (const e of this.entries.values()) {
+      if (e.refs > 0) used++;
+      materials += e.materials.size + e.own.size;
+    }
+    return {
+      entries: this.entries.size,
+      used,
+      meshes: this.entries.size,
+      atlases: this.entries.size,
+      materials
+    };
+  }
+  describe() {
+    return [...this.entries.values()].map((e) => ({
+      key: e.key,
+      die: e.geometry.definition.id,
+      kind: e.kind,
+      family: e.family.name,
+      refs: e.refs,
+      releaseInMs: e.refs > 0 ? null : e.releaseAt,
+      materials: [...e.materials.keys(), ...e.own.keys()],
+      atlas: [e.atlas.width, e.atlas.height]
+    }));
+  }
+}
+export {
+  DiceResources,
+  RELEASE_AFTER_MS
+};

package/dist/roll.d.ts

@@ -0,0 +1,68 @@
+import { type AssetRef } from '@aethervtt/shard-core';
+import { type DieKind } from './builtins.js';
+import type { DiceTray } from './settle.js';
+import { type DiceTrackRequest, type LaunchEdge } from './track.js';
+/** A roll the host decided: what to show, never what to decide (0054). */
+export interface DiceRoll {
+    /** The host's entry id; also the default seed. */
+    id: string;
+    dice: DiceRollDie[];
+    total?: number;
+    source?: {
+        mine: boolean;
+        gm: boolean;
+    };
+    /** Host semantic tags, at most 8, for effect conditions. */
+    tags?: string[];
+    seed?: string;
+    /** A fixed tray every viewer shares; omitted, the tray follows this viewport. */
+    tray?: DiceTray;
+    /** The tray edge the dice come in from; the seed picks one when omitted. */
+    launch?: LaunchEdge;
+    quality?: DiceQualityPreference;
+    motion?: 'full' | 'reduced';
+    effects?: boolean;
+    /** 0..1. */
+    soundGain?: number;
+}
+export interface DiceRollDie {
+    kind: DieKind;
+    value: number;
+    /** A DiceSkin. */
+    skin: AssetRef<'dice/DiceSkin'> | AssetRef;
+    dropped?: boolean;
+    high?: boolean;
+    low?: boolean;
+}
+export type DiceQualityPreference = 'auto' | 'full' | 'balanced' | 'large-pool';
+/** One body on the table: a roll's die, or half of a percentile. */
+export interface PhysicalDie {
+    /** Index into `roll.dice`. */
+    source: number;
+    kind: DieKind;
+    definition: string;
+    /** The definition's value to show (a percentile's tens die shows 1..10). */
+    value: number;
+    /** What the host rolled for the roll die (a percentile's 1..100). */
+    rolled: number;
+    /** The printed mark on top. */
+    label: string;
+    part: 'tens' | 'units' | undefined;
+    skin: AssetRef;
+    dropped: boolean;
+    high: boolean;
+    low: boolean;
+    /** World scale of the unit-radius die. */
+    scale: number;
+}
+/** Presentation scale by the number of bodies, as Aether steps it. */
+export declare function presentationScale(count: number): number;
+/** The tray that follows a viewport: as wide as its aspect allows, 3.15 deep (Aether's). */
+export declare function viewportTray(aspect: number): DiceTray;
+/**
+ * The bodies a roll puts on the table, in order: percentile plays a tens and a units d10. Values
+ * the dice can't show fail with `dice/invalid-value` naming the die; nothing is played.
+ */
+export declare function expandRoll(roll: DiceRoll, kinds?: Readonly<Record<DieKind, readonly string[]>>): PhysicalDie[];
+/** The track request of a roll's bodies: its seed (default the id), tray, and dice. */
+export declare function rollTrackRequest(roll: DiceRoll, dice: readonly PhysicalDie[], tray: DiceTray): DiceTrackRequest;

package/dist/roll.js

@@ -0,0 +1,97 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { DIE_KINDS, KIND_DEFINITIONS, kindSides, percentileValues } from "./builtins.js";
+import { dieGeometry, frameOf, labelOf, physicalScale, requireDie } from "./definition.js";
+import { MAX_DICE } from "./track.js";
+const MAX_TAGS = 8;
+function invalidValue(message, path) {
+  return new ShardError("dice/invalid-value", message, {
+    path,
+    hint: "The host decides the result; pass one the die can show."
+  });
+}
+function presentationScale(count) {
+  if (count <= 2) return 0.68;
+  if (count <= 8) return 0.56;
+  if (count <= 16) return 0.46;
+  return 0.38;
+}
+function viewportTray(aspect) {
+  const a = Number.isFinite(aspect) && aspect > 0 ? aspect : 16 / 9;
+  return { halfWidth: Math.max(2.35, Math.min(5.4, 3.15 * a)), halfDepth: 3.15 };
+}
+function expandRoll(roll, kinds = KIND_DEFINITIONS) {
+  if (typeof roll.id !== "string" || roll.id === "") {
+    throw new ShardError("dice/invalid-roll", "A roll needs an id", { path: "id" });
+  }
+  if ((roll.tags?.length ?? 0) > MAX_TAGS) {
+    throw new ShardError("dice/invalid-roll", `A roll has at most ${MAX_TAGS} tags`, {
+      path: "tags"
+    });
+  }
+  const out = [];
+  roll.dice.forEach((die, i) => {
+    const path = `dice[${i}]`;
+    if (!DIE_KINDS.includes(die.kind)) {
+      throw new ShardError("dice/invalid-roll", `${path}.kind "${die.kind}" isn't a die kind`, {
+        path: `${path}.kind`,
+        hint: `Kinds: ${DIE_KINDS.join(", ")}.`
+      });
+    }
+    const sides = kindSides(die.kind);
+    if (!Number.isInteger(die.value) || die.value < 1 || die.value > sides) {
+      throw invalidValue(
+        `${path} is a ${die.kind} showing ${die.value}; it shows 1 to ${sides}`,
+        `${path}.value`
+      );
+    }
+    const defs = kinds[die.kind];
+    const values = die.kind === "percentile" ? percentileValues(die.value) : [die.value];
+    defs.forEach((id, k) => {
+      const def = requireDie(id);
+      const value = values[k] ?? die.value;
+      frameOf(dieGeometry(def), value);
+      out.push({
+        source: i,
+        kind: die.kind,
+        definition: id,
+        value,
+        rolled: die.value,
+        label: labelOf(def, value),
+        part: die.kind === "percentile" ? k === 0 ? "tens" : "units" : void 0,
+        skin: die.skin,
+        dropped: die.dropped ?? false,
+        high: die.high ?? false,
+        low: die.low ?? false,
+        scale: 0
+      });
+    });
+  });
+  if (out.length === 0 || out.length > MAX_DICE) {
+    throw new ShardError(
+      "dice/invalid-roll",
+      `A roll puts 1 to ${MAX_DICE} dice on the table, not ${out.length}`,
+      {
+        path: "dice"
+      }
+    );
+  }
+  const base = presentationScale(out.length);
+  const reference = dieGeometry(requireDie("d20"));
+  for (const d of out)
+    d.scale = base * physicalScale(dieGeometry(requireDie(d.definition)), reference);
+  return out;
+}
+function rollTrackRequest(roll, dice, tray) {
+  return {
+    seed: roll.seed ?? roll.id,
+    tray: { halfWidth: tray.halfWidth, halfDepth: tray.halfDepth },
+    dice: dice.map((d) => ({ definition: d.definition, scale: d.scale, dropped: d.dropped })),
+    launch: roll.launch
+  };
+}
+export {
+  expandRoll,
+  presentationScale,
+  rollTrackRequest,
+  viewportTray
+};

package/dist/settle.d.ts

@@ -0,0 +1,53 @@
+import type { SettleRule } from '@aethervtt/shard-physics/track';
+export interface DiceTray {
+    /** Half the tray's width (x) and depth (z), in world units. */
+    halfWidth: number;
+    halfDepth: number;
+}
+/** What `dice-settle` needs about each body. */
+export interface DiceSettleParams {
+    tray: DiceTray;
+    bodies: {
+        /** Unit directions (x y z each) whose value reads when up: face normals, or the d4's vertices. */
+        directions: number[];
+        /** Collider points, scaled (hulls), for floor clearance. */
+        points?: number[];
+        /** Ball radius. */
+        radius?: number;
+    }[];
+}
+export declare const DICE_SETTLE_RULE = "dice-settle";
+/** The step a track still not settled runs its one cleanup phase. */
+export declare const DICE_CLEANUP_STEP = 240;
+/** A ball's damping after its first bounce: angular ramps up over `steps`, linear jumps. */
+export declare const BALL_DAMPING: {
+    from: number;
+    to: number;
+    steps: number;
+    linear: number;
+};
+/** Collision groups: dice touch dice, walls and the floor; walls and floor touch dice. */
+export declare const DICE_GROUPS: {
+    dice: {
+        layers: number;
+        mask: number;
+    };
+    walls: {
+        layers: number;
+        mask: number;
+    };
+    floor: {
+        layers: number;
+        mask: number;
+    };
+};
+/** Outside the tray for good: below the floor, or past a wall. */
+export declare function outsideTray(p: ArrayLike<number>, tray: DiceTray): boolean;
+/** A body at rest reading a value: flat (a face, or the d4's vertex, up) and on the floor. */
+export declare function restingFlat(body: DiceSettleParams['bodies'][number], pos: ArrayLike<number>, rot: ArrayLike<number>): boolean;
+/**
+ * Done once every die in the tray sleeps resting flat (dice that left the tray are the placed
+ * fallback's). Every body asleep with one cocked, or step 240 unsettled, runs the cleanup phase
+ * once. A ball's angular damping ramps up after its first bounce, so it settles when the others do.
+ */
+export declare const diceSettle: SettleRule;

package/dist/settle.js

@@ -0,0 +1,96 @@
+const DICE_SETTLE_RULE = "dice-settle";
+const DICE_CLEANUP_STEP = 240;
+const FLAT_ALIGNMENT = 0.995;
+const FLOOR_CLEARANCE = 0.035;
+const MIN_SETTLE_STEP = 45;
+const BALL_DAMPING = { from: 0.2, to: 8, steps: 20, linear: 2.4 };
+const DICE_GROUPS = {
+  dice: { layers: 1, mask: 1 | 2 | 4 },
+  walls: { layers: 2, mask: 1 },
+  floor: { layers: 4, mask: 1 }
+};
+const CLEANUP = {
+  groups: { dice: { layers: 1, mask: 4 } },
+  disableGroups: ["walls"],
+  wake: true
+};
+function outsideTray(p, tray) {
+  return p[1] < -0.5 || Math.abs(p[0]) > tray.halfWidth + 0.3 || Math.abs(p[2]) > tray.halfDepth + 0.3;
+}
+function rotatedY(q, x, y, z) {
+  const qx = q[0];
+  const qy = q[1];
+  const qz = q[2];
+  const qw = q[3];
+  const tx = 2 * (qy * z - qz * y);
+  const tz = 2 * (qx * y - qy * x);
+  return y + qw * (2 * (qz * x - qx * z)) + (qz * tx - qx * tz);
+}
+function restingFlat(body, pos, rot) {
+  if (body.radius !== void 0) return pos[1] - body.radius <= FLOOR_CLEARANCE;
+  let up = Number.NEGATIVE_INFINITY;
+  const d = body.directions;
+  for (let i = 0; i < d.length; i += 3)
+    up = Math.max(up, rotatedY(rot, d[i], d[i + 1], d[i + 2]));
+  if (up < FLAT_ALIGNMENT) return false;
+  let low = Number.POSITIVE_INFINITY;
+  const p = body.points;
+  for (let i = 0; i < p.length; i += 3) {
+    low = Math.min(low, rotatedY(rot, p[i], p[i + 1], p[i + 2]));
+  }
+  return pos[1] + low <= FLOOR_CLEARANCE;
+}
+const diceSettle = (raw) => {
+  const params = raw;
+  const n = params.bodies.length;
+  const pos = new Float64Array(3);
+  const rot = new Float64Array(4);
+  const bounced = new Uint8Array(n);
+  const damping = new Float64Array(n);
+  let cleaned = false;
+  return (view) => {
+    let phase;
+    for (let i = 0; i < n; i++) {
+      const body = params.bodies[i];
+      if (body.radius === void 0) continue;
+      view.pose(i, pos, rot);
+      if (!bounced[i] && pos[1] - body.radius < 0.02) {
+        bounced[i] = 1;
+        damping[i] = BALL_DAMPING.from;
+      }
+      if (bounced[i] && damping[i] < BALL_DAMPING.to) {
+        damping[i] = Math.min(
+          BALL_DAMPING.to,
+          damping[i] + (BALL_DAMPING.to - BALL_DAMPING.from) / BALL_DAMPING.steps
+        );
+        phase ??= { damping: [] };
+        phase.damping.push({ body: i, angular: damping[i], linear: BALL_DAMPING.linear });
+      }
+    }
+    if (view.step >= MIN_SETTLE_STEP) {
+      let asleep = true;
+      let flat = true;
+      for (let i = 0; i < n && asleep; i++) {
+        view.pose(i, pos, rot);
+        if (outsideTray(pos, params.tray)) continue;
+        if (view.sleeping[i] === 0) asleep = false;
+        else if (flat && !restingFlat(params.bodies[i], pos, rot)) flat = false;
+      }
+      if (asleep && flat) return "done";
+      if ((asleep || view.step >= DICE_CLEANUP_STEP) && !cleaned) {
+        cleaned = true;
+        phase = { ...phase, ...CLEANUP };
+      }
+    }
+    return phase ?? "continue";
+  };
+};
+export {
+  BALL_DAMPING,
+  DICE_CLEANUP_STEP,
+  DICE_GROUPS,
+  DICE_SETTLE_RULE,
+  diceSettle,
+  outsideTray,
+  restingFlat
+};

package/dist/skin.d.ts

@@ -0,0 +1,64 @@
+import { type AssetRef, type FieldValue, type Infer, ShardError } from '@aethervtt/shard-core';
+import { type DieKind } from './builtins.js';
+import type { DiceEffectRecipeValue } from './effects.js';
+import { type FaceLayoutValue } from './layout.js';
+declare const VARIANT: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    layout: import("@aethervtt/shard-core").FieldType<AssetRef<"dice/FaceLayout"> | null, "object">;
+    bevel: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    params: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+}>, "object">;
+export declare const IMPACT_SOUNDS: readonly ['resin', 'metal', 'wood', 'glass'];
+export type ImpactSound = (typeof IMPACT_SOUNDS)[number];
+/** A dice skin: `data/**\/*.dice-skin.json`. */
+export declare const DiceSkin: import("@aethervtt/shard-assets").DataType<{
+    readonly version: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly id: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly family: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly params: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly variants: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<Record<"d10" | "d100" | "d12" | "d20" | "d4" | "d6" | "d8" | "percentile", import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        layout: import("@aethervtt/shard-core").FieldType<AssetRef<"dice/FaceLayout"> | null, "object">;
+        bevel: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        params: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    }>, "object">>>, "object">;
+    readonly sounds: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        impact: import("@aethervtt/shard-core").FieldType<"glass" | "metal" | "resin" | "wood", "u8">;
+        impactEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
+        entranceEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
+        resultEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
+        accent: import("@aethervtt/shard-core").FieldType<"" | "arcane-spark" | "resin-chime" | "void-whump", "u8">;
+    }>, "object">;
+    readonly effects: import("@aethervtt/shard-core").FieldType<(AssetRef<"dice/DiceEffectRecipe"> | null)[], "object">;
+}, "dice/DiceSkin">;
+export type DiceSkinValue = Infer<typeof DiceSkin>;
+export type DiceSkinVariant = FieldValue<typeof VARIANT>;
+export declare const MAX_SKIN_EFFECTS = 4;
+export interface SkinContext {
+    layout?: (ref: AssetRef) => FaceLayoutValue | undefined;
+    recipe?: (ref: AssetRef) => DiceEffectRecipeValue | undefined;
+}
+/**
+ * Everything wrong with a skin, each error with a path into it: an unknown family
+ * (`dice/unknown-family`), parameters its family doesn't have, a layout that can't show a value
+ * of its kind (`dice/layout-missing-value`), more than 4 recipes, or a recipe over its bounds
+ * (`dice/recipe-bounds`). Layouts and recipes resolve through `ctx`.
+ */
+export declare function validateDiceSkin(skin: DiceSkinValue, ctx?: SkinContext): ShardError[];
+/** A skin from its JSON form (files, or objects written like them), with defaults filled in. */
+export declare function diceSkin(json: Record<string, unknown>): DiceSkinValue;
+/** The layout a skin prints on a kind, and its bevel. */
+export declare function skinVariant(skin: DiceSkinValue, kind: DieKind, definition: string, layouts: (ref: AssetRef) => FaceLayoutValue | undefined): {
+    layout: FaceLayoutValue;
+    bevel: number | undefined;
+    params: Record<string, unknown>;
+};
+/** Skins the package ships, one or two per family, for previews, tests and quick starts. */
+export declare const DICE_SKINS: {
+    readonly ivory: AssetRef<"dice/DiceSkin">;
+    readonly obsidian: AssetRef<"dice/DiceSkin">;
+    readonly teal: AssetRef<"dice/DiceSkin">;
+    readonly ember: AssetRef<"dice/DiceSkin">;
+    readonly brass: AssetRef<"dice/DiceSkin">;
+    readonly frost: AssetRef<"dice/DiceSkin">;
+};
+export declare const BUILTIN_SKINS: Readonly<Record<keyof typeof DICE_SKINS, Record<string, unknown>>>;
+export {};