@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/dist/marks.d.ts

@@ -0,0 +1,54 @@
+import type { AssetRef } from '@aethervtt/shard-core';
+import { type Font } from '@aethervtt/shard-text';
+import { type CellLayout } from './cells.js';
+import type { DieGeometry } from './definition.js';
+import { type FaceLayoutValue, type ResolvedMark } from './layout.js';
+export interface MarkAtlas {
+    /** What it was baked from: definition hash, layout, fonts. */
+    key: string;
+    width: number;
+    height: number;
+    layout: CellLayout;
+    /** Distance range in pixels. */
+    range: number;
+    pixels: Uint8Array;
+    /** Values drawn, per face (d4 faces carry three). */
+    values: number[][];
+    /** How long the bake took, ms. */
+    ms: number;
+}
+export interface BakeMarksOptions {
+    /** Loaded fonts for text marks that name one. */
+    font?: (ref: AssetRef) => Font | undefined;
+}
+export interface Placement {
+    mark: ResolvedMark;
+    /** Center in cell pixels (y up). */
+    x: number;
+    y: number;
+    /** Mark height in pixels. */
+    height: number;
+    /** Up direction angle, radians counter-clockwise from +y. */
+    angle: number;
+    /** The flat area the mark keeps inside, in cell pixels: [x0, y0, x1, y1, …]. */
+    region: number[];
+    /** The largest height the mark's ink can take there, keeping the margin clear. */
+    fit: number;
+}
+/** The share of a region's inscribed radius a mark's ink keeps clear of its edges. */
+export declare const MARK_MARGIN = 0.12;
+/**
+ * Every mark of a die under a layout, where the bake draws it: at the definition's height, shrunk
+ * (one scale for the whole die, so its numbers match) until every mark's ink fits its region.
+ */
+export declare function markPlacements(g: DieGeometry, layout: FaceLayoutValue, options?: BakeMarksOptions): Placement[][];
+/** The cache key of a bake: the definition's hash, the layout's content, and its fonts' guids. */
+export declare function markAtlasKey(g: DieGeometry, layout: FaceLayoutValue): string;
+/**
+ * Bakes a die's marks under a layout into one MSDF atlas: glyph outlines from the font (or the
+ * built-in numerals), pips as analytic circles, glyphs from their registered paths. Cached by
+ * (definition, layout).
+ */
+export declare function bakeMarks(g: DieGeometry, layout: FaceLayoutValue, options?: BakeMarksOptions): MarkAtlas;
+/** Drops every cached bake (tests, or a host changing fonts under the same refs). */
+export declare function clearMarkCache(): void;

package/dist/marks.js

@@ -0,0 +1,543 @@
+import {
+  generateMsdf,
+  prepareShape,
+  shapeBounds,
+  shapeFromCommands
+} from "@aethervtt/shard-text";
+import { cellLayout, cellPixel, MARK_RANGE } from "./cells.js";
+import { findDiceGlyph, parseSvgPath } from "./glyphs.js";
+import { resolveMark } from "./layout.js";
+import { add, scale, sub } from "./math.js";
+import { DICE_NUMERALS, NUMERAL_HEIGHT } from "./numerals.js";
+const PIPS = {
+  1: [[0, 0]],
+  2: [
+    [-1, 1],
+    [1, -1]
+  ],
+  3: [
+    [-1, 1],
+    [0, 0],
+    [1, -1]
+  ],
+  4: [
+    [-1, -1],
+    [1, -1],
+    [-1, 1],
+    [1, 1]
+  ],
+  5: [
+    [-1, -1],
+    [1, -1],
+    [0, 0],
+    [-1, 1],
+    [1, 1]
+  ],
+  6: [
+    [-1, -1],
+    [1, -1],
+    [-1, 0],
+    [1, 0],
+    [-1, 1],
+    [1, 1]
+  ],
+  7: [
+    [-1, -1],
+    [1, -1],
+    [-1, 0],
+    [0, 0],
+    [1, 0],
+    [-1, 1],
+    [1, 1]
+  ],
+  8: [
+    [-1, -1],
+    [0, -1],
+    [1, -1],
+    [-1, 0],
+    [1, 0],
+    [-1, 1],
+    [0, 1],
+    [1, 1]
+  ],
+  9: [
+    [-1, -1],
+    [0, -1],
+    [1, -1],
+    [-1, 0],
+    [0, 0],
+    [1, 0],
+    [-1, 1],
+    [0, 1],
+    [1, 1]
+  ]
+};
+const numeralShapes = /* @__PURE__ */ new Map();
+function numeral(ch) {
+  let o = numeralShapes.get(ch);
+  if (o) return o;
+  const n = DICE_NUMERALS[ch];
+  if (!n) return void 0;
+  const cmds = parseSvgPath(n.path, `numeral ${ch}`);
+  const shape = shapeFromCommands(cmds);
+  for (const c of shape.contours)
+    for (const e of c.edges) for (let i = 0; i < e.p.length; i++) e.p[i] /= 1e3;
+  o = { shape, advance: n.advance / 1e3 };
+  numeralShapes.set(ch, o);
+  return o;
+}
+function fontGlyph(font, ch) {
+  const source = font.source;
+  if (!source) return void 0;
+  const index = source.glyphIndex(ch.codePointAt(0));
+  if (index === 0) return void 0;
+  const shape = source.shape(index);
+  const upem = source.unitsPerEm;
+  for (const c of shape.contours)
+    for (const e of c.edges) for (let i = 0; i < e.p.length; i++) e.p[i] /= upem;
+  return { shape, advance: source.advance(index) / upem };
+}
+function place(out, shape, m, tx, ty) {
+  for (const c of shape.contours) {
+    out.push({
+      edges: c.edges.map((e) => {
+        const p = e.p.slice();
+        for (let i = 0; i < p.length; i += 2) {
+          const x = p[i];
+          const y = p[i + 1];
+          p[i] = m[0] * x + m[1] * y + tx;
+          p[i + 1] = m[2] * x + m[3] * y + ty;
+        }
+        return { kind: e.kind, p, color: e.color };
+      })
+    });
+  }
+}
+function area(c) {
+  let a = 0;
+  for (const e of c.edges) {
+    const p = e.p;
+    const n = p.length;
+    a += p[0] * p[n - 1] - p[n - 2] * p[1];
+  }
+  return a / 2;
+}
+function rect(l, b, r, t, ccw) {
+  const pts = ccw ? [l, b, r, b, r, t, l, t] : [l, b, l, t, r, t, r, b];
+  const edges = [];
+  for (let i = 0; i < 4; i++) {
+    const j = (i + 1) % 4;
+    edges.push({
+      kind: 1,
+      p: [pts[i * 2], pts[i * 2 + 1], pts[j * 2], pts[j * 2 + 1]],
+      color: 7
+    });
+  }
+  return { edges };
+}
+function scaled(shape, sx, sy, dx, dy) {
+  const out = [];
+  place(out, shape, [sx, 0, 0, sy], dx, dy);
+  return out;
+}
+function markPieces(p, options, weightPx) {
+  const m = p.mark;
+  const turn = p.angle - m.rotation;
+  const cos = Math.cos(turn);
+  const sin = Math.sin(turn);
+  if (m.kind === "glyph") {
+    const glyph = findDiceGlyph(m.glyph);
+    if (!glyph) return [];
+    const s = p.height;
+    const contours2 = [];
+    place(
+      contours2,
+      shapeFromCommands(glyph.commands),
+      [cos * s, -sin * s, sin * s, cos * s],
+      p.x,
+      p.y
+    );
+    return [{ contours: contours2, ox: 0, oy: 0, key: void 0 }];
+  }
+  const font = m.font ? options.font?.(m.font) : void 0;
+  const chars = [];
+  for (const ch of m.text) {
+    const outline = font ? fontGlyph(font, ch) : numeral(ch);
+    if (outline) chars.push({ ch, outline });
+  }
+  if (chars.length === 0) return [];
+  const capHeight = font ? capOf(chars.map((c) => c.outline)) : NUMERAL_HEIGHT / 1e3;
+  let width = 0;
+  for (const c of chars) width += c.outline.advance;
+  const sy = p.height / capHeight;
+  const sx = sy * Math.min(1, 1.35 * p.height / (width * sy));
+  const baseline = -capHeight / 2;
+  const local = [];
+  const fontKey = m.font?.guid ?? m.font?.path ?? "numerals";
+  const size = `${sx.toFixed(3)}:${sy.toFixed(3)}:${weightPx.toFixed(2)}`;
+  let pen = -width / 2;
+  for (const c of chars) {
+    local.push({ contours: c.outline.shape.contours, x: pen, key: `${fontKey}:${c.ch}:${size}` });
+    pen += c.outline.advance;
+  }
+  let bar;
+  if (m.underline) {
+    const all = chars.flatMap((c) => c.outline.shape.contours);
+    const outer = all.reduce((a, c) => Math.abs(area(c)) > Math.abs(area(a)) ? c : a, all[0]);
+    const w = Math.min(width * 0.72, capHeight * 0.95);
+    const y = baseline - capHeight * 0.2;
+    bar = rect(-w / 2, y - capHeight * 0.09, w / 2, y, area(outer) > 0);
+  }
+  if (Math.abs(turn) < 1e-6) {
+    const pieces = local.map((l) => {
+      const ox = Math.round(p.x + l.x * sx);
+      const oy = Math.round(p.y + baseline * sy);
+      return { contours: scaled({ contours: l.contours }, sx, sy, 0, 0), ox, oy, key: l.key };
+    });
+    if (bar) {
+      const contours2 = [];
+      place(contours2, { contours: [bar] }, [sx, 0, 0, sy], 0, 0);
+      pieces.push({ contours: contours2, ox: Math.round(p.x), oy: Math.round(p.y), key: void 0 });
+    }
+    return pieces;
+  }
+  const contours = [];
+  const r = [cos * sx, -sin * sy, sin * sx, cos * sy];
+  for (const l of local) {
+    for (const c of l.contours) {
+      place(
+        contours,
+        { contours: [c] },
+        r,
+        p.x + r[0] * (l.x + 0) + r[1] * baseline,
+        p.y + r[2] * l.x + r[3] * baseline
+      );
+    }
+  }
+  if (bar) place(contours, { contours: [bar] }, r, p.x, p.y);
+  return [{ contours, ox: 0, oy: 0, key: void 0 }];
+}
+function capOf(outlines) {
+  let top = 0;
+  for (const o of outlines) {
+    const b = shapeBounds(o.shape);
+    if (b) top = Math.max(top, b[3]);
+  }
+  return top || 0.7;
+}
+const tiles = /* @__PURE__ */ new Map();
+const TILE_CACHE = 1024;
+function bakeTile(piece, weightPx) {
+  const shape = { contours: piece.contours };
+  prepareShape(shape);
+  const bounds = shapeBounds(shape);
+  if (!bounds) return void 0;
+  const half = MARK_RANGE / 2 + 1;
+  const l = Math.floor(bounds[0] - half);
+  const b = Math.floor(bounds[1] - half);
+  const r = Math.ceil(bounds[2] + half);
+  const t = Math.ceil(bounds[3] + half);
+  const box = { width: r - l, height: t - b, tx: -l, ty: -b, plane: [l, b, r, t] };
+  const sdf = generateMsdf(shape, box, { scale: 1, range: MARK_RANGE });
+  const data = new Float32Array(box.width * box.height * 3);
+  const bias = weightPx / MARK_RANGE;
+  for (let i = 0; i < data.length; i++) data[i] = sdf[i] + bias;
+  return { l, b, width: box.width, height: box.height, data };
+}
+function tileOf(piece, weightPx) {
+  if (!piece.key) return bakeTile(piece, weightPx);
+  const hit = tiles.get(piece.key);
+  if (hit) return hit;
+  const tile = bakeTile(piece, weightPx);
+  if (!tile) return void 0;
+  tiles.set(piece.key, tile);
+  if (tiles.size > TILE_CACHE) tiles.delete(tiles.keys().next().value);
+  return tile;
+}
+const med = (a, b, c) => Math.max(Math.min(a, b), Math.min(Math.max(a, b), c));
+const byte = (v) => v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+function blitTile(atlas, owner, piece, atlasWidth, cellX, cellY, cell, tile, ox, oy) {
+  for (let row = 0; row < tile.height; row++) {
+    const y = oy + tile.b + row;
+    if (y < 0 || y >= cell) continue;
+    const atlasRow = cellY + (cell - 1 - y);
+    for (let col = 0; col < tile.width; col++) {
+      const x = ox + tile.l + col;
+      if (x < 0 || x >= cell) continue;
+      const s = (row * tile.width + col) * 3;
+      const r = tile.data[s];
+      const g = tile.data[s + 1];
+      const b = tile.data[s + 2];
+      const t = atlasRow * atlasWidth + cellX + x;
+      const o = t * 4;
+      const was = owner[t];
+      owner[t] = piece;
+      if (was < 0 || was === piece) {
+        atlas[o] = byte(r);
+        atlas[o + 1] = byte(g);
+        atlas[o + 2] = byte(b);
+        continue;
+      }
+      const m = Math.max(byte(med(r, g, b)), med(atlas[o], atlas[o + 1], atlas[o + 2]));
+      atlas[o] = atlas[o + 1] = atlas[o + 2] = m;
+    }
+  }
+}
+function drawPips(atlas, atlasWidth, cellX, cellY, cell, p) {
+  const layout = PIPS[p.mark.count];
+  if (!layout) return;
+  const spread = p.height * 0.62;
+  const radius = p.height * 0.21 + p.mark.weight * p.height;
+  const cos = Math.cos(p.angle - p.mark.rotation);
+  const sin = Math.sin(p.angle - p.mark.rotation);
+  const centers = layout.map(([gx, gy]) => [
+    p.x + (cos * gx - sin * gy) * spread,
+    p.y + (sin * gx + cos * gy) * spread
+  ]);
+  for (let y = 0; y < cell; y++) {
+    const atlasRow = cellY + (cell - 1 - y);
+    const py = y + 0.5;
+    for (let x = 0; x < cell; x++) {
+      const px = x + 0.5;
+      let d = Number.NEGATIVE_INFINITY;
+      for (const c of centers)
+        d = Math.max(d, radius - Math.sqrt((px - c[0]) ** 2 + (py - c[1]) ** 2));
+      const v = d / MARK_RANGE + 0.5;
+      const byte2 = v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+      const o = (atlasRow * atlasWidth + cellX + x) * 4;
+      if (byte2 > atlas[o]) atlas[o] = atlas[o + 1] = atlas[o + 2] = byte2;
+    }
+  }
+}
+const MARK_MARGIN = 0.12;
+function regions(g, layout, faceIndex) {
+  const face = layout.faces[faceIndex];
+  const poly = g.polytope.faces[faceIndex];
+  const bevel = g.definition.bevel;
+  const flat = poly.vertices.map((v) => {
+    const p = g.polytope.points[v];
+    return cellPixel(layout, face, add(p, scale(sub(face.center, p), bevel)));
+  });
+  if (face.value !== void 0) return [{ value: face.value, poly: flat.flat(), angle: 0 }];
+  const c = layout.cell / 2;
+  const n = flat.length;
+  return poly.vertices.map((v, i) => {
+    const [x, y] = flat[i];
+    const [px, py] = flat[(i + n - 1) % n];
+    const [nx, ny] = flat[(i + 1) % n];
+    return {
+      value: g.vertexValues[v],
+      poly: [c, c, (x + nx) / 2, (y + ny) / 2, x, y, (x + px) / 2, (y + py) / 2],
+      angle: Math.atan2(-(x - c), y - c)
+    };
+  });
+}
+function edgesOf(poly) {
+  const n = poly.length / 2;
+  let twice = 0;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    twice += poly[i * 2] * poly[j * 2 + 1] - poly[j * 2] * poly[i * 2 + 1];
+  }
+  const sign = twice > 0 ? 1 : -1;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const dx = poly[j * 2] - poly[i * 2];
+    const dy = poly[j * 2 + 1] - poly[i * 2 + 1];
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len < 1e-9) continue;
+    const nx = sign * dy / len;
+    const ny = -sign * dx / len;
+    out.push(nx, ny, nx * poly[i * 2] + ny * poly[i * 2 + 1]);
+  }
+  return out;
+}
+function clearance(edges, x, y) {
+  let m = Number.POSITIVE_INFINITY;
+  for (let e = 0; e < edges.length; e += 3)
+    m = Math.min(m, edges[e + 2] - edges[e] * x - edges[e + 1] * y);
+  return m;
+}
+function golden(f, a, b) {
+  const k = (Math.sqrt(5) - 1) / 2;
+  let lo = a;
+  let hi = b;
+  for (let i = 0; i < 28; i++) {
+    const m1 = hi - k * (hi - lo);
+    const m2 = lo + k * (hi - lo);
+    if (f(m1) < f(m2)) lo = m1;
+    else hi = m2;
+  }
+  return (lo + hi) / 2;
+}
+function deepest(edges, x, y, span) {
+  let bx = x;
+  let by = y;
+  for (let round = 0; round < 3; round++) {
+    by = golden((t) => clearance(edges, bx, t), by - span, by + span);
+    bx = golden((t) => clearance(edges, t, by), bx - span, bx + span);
+  }
+  return clearance(edges, bx, by) > clearance(edges, x, y) * 1.02 ? [bx, by] : [x, y];
+}
+function inkOf(m, options) {
+  if (m.kind === "blank") return void 0;
+  if (m.kind === "pips") {
+    const layout = PIPS[m.count];
+    if (!layout) return void 0;
+    return { points: layout.flatMap(([x, y]) => [x * 0.62, y * 0.62]), grow: 0.21 + m.weight };
+  }
+  if (m.kind === "glyph") {
+    const glyph = findDiceGlyph(m.glyph);
+    if (!glyph) return void 0;
+    const points2 = [];
+    for (const c of shapeFromCommands(glyph.commands).contours)
+      for (const e of c.edges) for (let i = 0; i < e.p.length; i++) points2.push(e.p[i]);
+    return { points: points2, grow: 0 };
+  }
+  const font = m.font ? options.font?.(m.font) : void 0;
+  const outlines = [];
+  for (const ch of m.text) {
+    const o = font ? fontGlyph(font, ch) : numeral(ch);
+    if (o) outlines.push(o);
+  }
+  if (outlines.length === 0) return void 0;
+  const cap = font ? capOf(outlines) : NUMERAL_HEIGHT / 1e3;
+  let width = 0;
+  for (const o of outlines) width += o.advance;
+  const sy = 1 / cap;
+  const sx = sy * Math.min(1, 1.35 / (width * sy));
+  const points = [];
+  let pen = -width / 2;
+  for (const o of outlines) {
+    for (const c of o.shape.contours) {
+      for (const e of c.edges) {
+        for (let i = 0; i < e.p.length; i += 2)
+          points.push((e.p[i] + pen) * sx, (e.p[i + 1] - cap / 2) * sy);
+      }
+    }
+    pen += o.advance;
+  }
+  if (m.underline) {
+    const w = Math.min(width * 0.72, cap * 0.95) / 2;
+    const bottom = -0.5 - 0.29;
+    points.push(-w * sx, bottom, w * sx, bottom);
+  }
+  return { points, grow: m.weight / cap };
+}
+function fitHeight(edges, ink, x, y, turn, margin) {
+  const c = Math.cos(turn);
+  const s = Math.sin(turn);
+  let h = Number.POSITIVE_INFINITY;
+  for (let e = 0; e < edges.length; e += 3) {
+    const nx = edges[e];
+    const ny = edges[e + 1];
+    let reach = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < ink.points.length; i += 2) {
+      const px = ink.points[i];
+      const py = ink.points[i + 1];
+      reach = Math.max(reach, nx * (c * px - s * py) + ny * (s * px + c * py));
+    }
+    reach += ink.grow;
+    const room = edges[e + 2] - nx * x - ny * y - margin;
+    if (reach > 1e-9) h = Math.min(h, room / reach);
+  }
+  return Math.max(0, h);
+}
+function placements(g, layout, faceIndex, marks, options) {
+  const def = g.definition;
+  const inner = layout.cell * (1 - 2 * layout.pad);
+  const height = (def.markScale ?? 0.4) * inner;
+  return regions(g, layout, faceIndex).map((r) => {
+    const mark = resolveMark(marks, def, r.value);
+    const edges = edgesOf(r.poly);
+    let cx = 0;
+    let cy = 0;
+    for (let i = 0; i < r.poly.length; i += 2) {
+      cx += r.poly[i];
+      cy += r.poly[i + 1];
+    }
+    cx /= r.poly.length / 2;
+    cy /= r.poly.length / 2;
+    const [x, y] = deepest(edges, cx, cy, inner * 0.35);
+    const ink = inkOf(mark, options);
+    const margin = MARK_MARGIN * clearance(edges, x, y);
+    const fit = ink ? fitHeight(edges, ink, x, y, r.angle - mark.rotation, margin) : Infinity;
+    return { mark, x, y, height: height * mark.size, angle: r.angle, region: r.poly, fit };
+  });
+}
+function markPlacements(g, layout, options = {}) {
+  const cells = cellLayout(g);
+  const all = cells.faces.map((face) => placements(g, cells, face.face, layout, options));
+  let k = 1;
+  for (const face of all) for (const p of face) if (p.height > 0) k = Math.min(k, p.fit / p.height);
+  if (k < 1) for (const face of all) for (const p of face) p.height *= k;
+  return all;
+}
+const cache = /* @__PURE__ */ new Map();
+const CACHE_SIZE = 24;
+function markAtlasKey(g, layout) {
+  return `${g.hash.toString(16)}:${JSON.stringify(layout)}`;
+}
+function bakeMarks(g, layout, options = {}) {
+  const key = markAtlasKey(g, layout);
+  const hit = cache.get(key);
+  if (hit) {
+    cache.delete(key);
+    cache.set(key, hit);
+    return hit;
+  }
+  const start = performance.now();
+  const cells = cellLayout(g);
+  const width = cells.cols * cells.cell;
+  const height = cells.rows * cells.cell;
+  const pixels = new Uint8Array(width * height * 4);
+  for (let i = 3; i < pixels.length; i += 4) pixels[i] = 255;
+  const values = [];
+  const placed = markPlacements(g, layout, options);
+  const owner = new Int32Array(width * height).fill(-1);
+  let pieces = 0;
+  for (const face of cells.faces) {
+    const cellX = face.col * cells.cell;
+    const cellY = face.row * cells.cell;
+    for (const p of placed[face.face]) {
+      if (p.mark.kind === "blank") continue;
+      if (p.mark.kind === "pips") {
+        drawPips(pixels, width, cellX, cellY, cells.cell, p);
+        continue;
+      }
+      const weightPx = p.mark.weight * (p.height / (NUMERAL_HEIGHT / 1e3));
+      for (const piece of markPieces(p, options, weightPx)) {
+        const tile = tileOf(piece, weightPx);
+        if (!tile) continue;
+        blitTile(pixels, owner, pieces++, width, cellX, cellY, cells.cell, tile, piece.ox, piece.oy);
+      }
+    }
+    values.push(
+      face.value !== void 0 ? [face.value] : g.polytope.faces[face.face].vertices.map((v) => g.vertexValues[v])
+    );
+  }
+  const atlas = {
+    key,
+    width,
+    height,
+    layout: cells,
+    range: MARK_RANGE,
+    pixels,
+    values,
+    ms: performance.now() - start
+  };
+  cache.set(key, atlas);
+  if (cache.size > CACHE_SIZE) cache.delete(cache.keys().next().value);
+  return atlas;
+}
+function clearMarkCache() {
+  cache.clear();
+}
+export {
+  MARK_MARGIN,
+  bakeMarks,
+  clearMarkCache,
+  markAtlasKey,
+  markPlacements
+};

package/dist/material.d.ts

@@ -0,0 +1,80 @@
+import { type Fields } from '@aethervtt/shard-core';
+import { type BlendMode, findMaterialType, type MaterialType } from '@aethervtt/shard-render';
+/** Fields every dice family has, before its own. */
+export declare const DICE_FIELDS: {
+    marks: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+    markColor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    markEmissive: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    markRoughness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    markMetallic: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    markDepth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    edgeColor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    edgeMix: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    droppedColor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    dropped: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    fade: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    result: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    resultTime: import("@aethervtt/shard-core").FieldType<number, "f32">;
+};
+/** The shared WGSL: marks from the atlas, the engraving, the chamfer, dropped and fade. */
+export declare const DICE_SHADERS: Record<string, string>;
+/** What a family adds to the dice fields. */
+export interface DiceFamilyOptions {
+    /** The family's own fields (names can't clash with the dice or standard fields). */
+    fields?: Fields;
+    /**
+     * WGSL shading the body, run inside the family's generated `pbr_input` with `p` (a PbrInput from
+     * the standard fields), `m` (DiceMark), `look` (DiceLook), `in`, `local` (object-space
+     * position), `value` (the die's value), `v` (toward the camera) and `F` (this family's uniform)
+     * in scope, and `globals.time` (seconds) to animate by. Helpers: `dice_hash`, `dice_noise` and
+     * `dice_fbm` (object-space noise), `dice_luma`, and `dice_local_ray(in, local)`, the view ray
+     * inside the die. The shared `dice_finish` runs after it. Leave it out and give `shader` instead
+     * to write the whole module.
+     */
+    surface?: string;
+    /**
+     * The body moves with `globals.time` (a vortex turning, a pulsar sweeping): while its dice are on
+     * the table, frames keep coming, at the display's rate (`true`) or at most `fps`. Without it the
+     * table draws nothing once dice rest, and a time-driven body holds still. Reduced motion stops it.
+     */
+    animated?: boolean | {
+        fps: number;
+    };
+    /** A shader module with the family's own hook overrides (instead of `surface`). */
+    shader?: string;
+    /**
+     * A fixed blend mode, for families that only work blended (an additive glow). Their dice blend in
+     * every tier, so they don't batch in large pools. Omitted, dice follow their material's
+     * alphaMode: see-through families (`translucent`) blend, but draw opaque in large pools.
+     */
+    blend?: BlendMode;
+    /**
+     * Whether a skin's parameters make these dice see-through (their material blends, so they cast
+     * no shadow and get a contact blob instead). Families with a fixed transparent blend always are.
+     */
+    translucent?: (params: Record<string, unknown>) => boolean;
+    description?: string;
+}
+export interface DiceFamily {
+    name: string;
+    type: MaterialType;
+    /** The generated module (families defined with `surface`), for the dice plugin to register. */
+    module: {
+        path: string;
+        source: string;
+    } | undefined;
+    translucent: ((params: Record<string, unknown>) => boolean) | undefined;
+    /** Frames per second the body animates at while shown: 0 still, Infinity the display's rate. */
+    fps: number;
+}
+/**
+ * Declares a dice family: `defineMaterial` extending the standard material with the dice fields
+ * required. Skins name it by `name`. Aether's nebula, plasma, stained glass and black hole are
+ * such families, defined in Aether.
+ */
+export declare function defineDiceFamily(name: string, options: DiceFamilyOptions): DiceFamily;
+export declare function findDiceFamily(name: string): DiceFamily | undefined;
+export declare function allDiceFamilies(): DiceFamily[];
+/** Whether a material type has every dice field (a family defined some other way still renders). */
+export declare function isDiceMaterial(type: MaterialType): boolean;
+export { findMaterialType };