@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/dist/material.js

@@ -0,0 +1,343 @@
+import { ShardError, t } from "@aethervtt/shard-core";
+import {
+  defineMaterial,
+  findMaterialType,
+  materialModulePath
+} from "@aethervtt/shard-render";
+import { MARK_RANGE } from "./cells.js";
+const DICE_FIELDS = {
+  marks: t.handle("Texture", { description: "The mark atlas (MSDF), baked by the package." }),
+  markColor: t.color({ default: [0.95, 0.94, 0.9, 1], description: "Mark ink (linear)." }),
+  markEmissive: t.f32({
+    min: 0,
+    unit: "cd/m\xB2",
+    description: "Glowing marks: luminance of the ink."
+  }),
+  markRoughness: t.f32({ default: 0.55, min: 0, max: 1, description: "Roughness of the ink." }),
+  markMetallic: t.f32({ min: 0, max: 1, description: "Metallic ink (gilded marks)." }),
+  markDepth: t.f32({
+    default: 0.6,
+    min: 0,
+    max: 1,
+    description: "How deep the marks are engraved: a bump taken from the distance field. 0 prints them."
+  }),
+  edgeColor: t.color({
+    default: [0.5, 0.5, 0.5, 1],
+    description: "Color the chamfer blends toward."
+  }),
+  edgeMix: t.f32({
+    default: 0.3,
+    min: 0,
+    max: 1,
+    description: "How much of edgeColor the chamfer takes."
+  }),
+  droppedColor: t.color({
+    default: [0.34, 0.38, 0.43, 1],
+    description: "The dropped look's tone: dropped dice fade toward it."
+  }),
+  dropped: t.f32({
+    min: 0,
+    max: 1,
+    description: "Blend toward the dropped look: desaturated, 0.62 opacity, rougher, no transmission."
+  }),
+  fade: t.f32({ default: 1, min: 0, max: 1, description: "Opacity for blended dice fading in." }),
+  result: t.f32({
+    min: 0,
+    max: 1,
+    description: "0 while tumbling, 1 once landed: result-reactive families light the face on top."
+  }),
+  resultTime: t.f32({
+    unit: "s",
+    description: "The shader clock (globals.time) when the dice landed: reactions animate from globals.time \u2212 resultTime once result is above 0."
+  })
+};
+const DICE_FIELD_NAMES = Object.keys(DICE_FIELDS);
+const DICE_SHADERS = {
+  "shard::dice::surface": `
+import shard::pbr::types::{ VertexOutput, PbrInput };
+import shard::pbr::standard::material;
+import shard::mesh::vertex_instance_data;
+import shard::view::view;
+
+/** The atlas's distance range, in atlas pixels (the bake's MARK_RANGE). */
+const DICE_MARK_RANGE: f32 = ${MARK_RANGE.toFixed(1)};
+
+/** What every family's dice fields say, gathered by its shader. */
+struct DiceLook {
+  mark_color: vec4f,
+  edge_color: vec4f,
+  dropped_color: vec4f,
+  mark_emissive: f32,
+  mark_roughness: f32,
+  mark_metallic: f32,
+  mark_depth: f32,
+  edge_mix: f32,
+  dropped: f32,
+  fade: f32,
+  result: f32,
+  /** globals.time when the dice landed (see result). */
+  result_time: f32,
+}
+
+/** The mark at a fragment. */
+struct DiceMark {
+  /** 1 on faces, 0 on the chamfer. */
+  face: f32,
+  /** Ink coverage, antialiased in screen space. */
+  coverage: f32,
+  /** Signed distance to the mark's outline in atlas pixels, positive inside. */
+  inside: f32,
+  /** The distance's change per atlas pixel along u and v. */
+  slope: vec2f,
+  /** How squarely this face points up: 1 on the face on top. */
+  top: f32,
+}
+
+/** For vertex_extra: the object-space position (for body patterns that stick to the die), and the die's value. */
+fn dice_extra(position: vec3f) -> vec4f {
+  return vec4f(position, vertex_instance_data().x);
+}
+
+fn dice_median(c: vec3f) -> f32 {
+  return max(min(c.r, c.g), min(max(c.r, c.g), c.b));
+}
+
+/** Samples the mark atlas. Call it first in pbr_input: it takes derivatives. */
+fn dice_mark(in: VertexOutput, atlas: texture_2d<f32>, samp: sampler) -> DiceMark {
+  let size = vec2f(textureDimensions(atlas));
+  let texel = 1.0 / size;
+  let fw = fwidth(in.uv * size);
+  let c = textureSample(atlas, samp, in.uv).rgb;
+  let cx = textureSample(atlas, samp, in.uv + vec2f(texel.x, 0.0)).rgb;
+  let cy = textureSample(atlas, samp, in.uv + vec2f(0.0, texel.y)).rgb;
+  let d = (dice_median(c) - 0.5) * DICE_MARK_RANGE;
+  var m: DiceMark;
+  m.face = step(0.5, in.uv1.x);
+  let per_pixel = max(0.5 * (fw.x + fw.y), 1e-3);
+  m.coverage = clamp(d / per_pixel + 0.5, 0.0, 1.0) * m.face;
+  m.inside = d;
+  m.slope = vec2f((dice_median(cx) - 0.5) * DICE_MARK_RANGE - d, (dice_median(cy) - 0.5) * DICE_MARK_RANGE - d);
+  m.top = smoothstep(0.9, 0.995, normalize(in.world_normal).y) * m.face;
+  return m;
+}
+
+/** The surface from the standard fields: baseColor, metallic, roughness, emissive. */
+fn dice_base(in: VertexOutput) -> PbrInput {
+  var p: PbrInput;
+  p.base_color = material.baseColor.rgb;
+  p.alpha = material.baseColor.a;
+  p.normal = normalize(in.world_normal);
+  p.metallic = material.metallic;
+  p.roughness = clamp(material.roughness, 0.045, 1.0);
+  p.emissive = material.emissive.rgb * material.emissiveLuminance;
+  p.occlusion = 1.0;
+  return p;
+}
+
+/** From the surface toward the camera. */
+fn dice_view(in: VertexOutput) -> vec3f {
+  return normalize(view.cameraPosition - in.world_position);
+}
+
+/**
+ * The ray from the camera through this fragment in the die's own space (unit length), for what's
+ * seen inside a die: a vortex, a star field at depth. It's recovered from how the world and object
+ * positions change across the pixel (one rigid map for the whole die), so call it where
+ * derivatives are valid: in the surface's top level, not under a branch.
+ */
+fn dice_local_ray(in: VertexOutput, local: vec3f) -> vec3f {
+  let wx = dpdx(in.world_position);
+  let wy = dpdy(in.world_position);
+  let lx = dpdx(local);
+  let ly = dpdy(local);
+  let wn = cross(wx, wy);
+  let ln = cross(lx, ly);
+  let d = normalize(in.world_position - view.cameraPosition);
+  let det = max(dot(wn, wn), 1e-30);
+  // d = a\xB7wx + b\xB7wy + c\xB7wn, and the die's space maps wx, wy, wn to s\xB7lx, s\xB7ly, s\xB2\xB7ln.
+  let a = dot(cross(wy, wn), d) / det;
+  let b = dot(cross(wn, wx), d) / det;
+  let c = dot(wn, d) / det;
+  let s = sqrt(length(wn) / max(length(ln), 1e-30));
+  let r = a * lx + b * ly + c * s * ln;
+  return r / max(length(r), 1e-20);
+}
+
+fn dice_hash(p: vec3f) -> f32 {
+  var q = fract(p * 0.1031);
+  q += dot(q, q.yzx + 33.33);
+  return fract((q.x + q.y) * q.z);
+}
+
+/** Smooth value noise in 0..1, for body patterns in object space. */
+fn dice_noise(p: vec3f) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(mix(dice_hash(i), dice_hash(i + vec3f(1.0, 0.0, 0.0)), u.x),
+        mix(dice_hash(i + vec3f(0.0, 1.0, 0.0)), dice_hash(i + vec3f(1.0, 1.0, 0.0)), u.x), u.y),
+    mix(mix(dice_hash(i + vec3f(0.0, 0.0, 1.0)), dice_hash(i + vec3f(1.0, 0.0, 1.0)), u.x),
+        mix(dice_hash(i + vec3f(0.0, 1.0, 1.0)), dice_hash(i + vec3f(1.0, 1.0, 1.0)), u.x), u.y),
+    u.z);
+}
+
+/** Two octaves of dice_noise. */
+fn dice_fbm(p: vec3f) -> f32 {
+  return dice_noise(p) * 0.65 + dice_noise(p * 2.13 + vec3f(5.2, 1.3, 7.1)) * 0.35;
+}
+
+fn dice_luma(c: vec3f) -> f32 {
+  return dot(c, vec3f(0.2126, 0.7152, 0.0722));
+}
+
+/**
+ * Finishes a family's body: the chamfer toward edge_color, the marks (ink, engraving, glow), the
+ * dropped look, and the fade. Families shade the body into p, then call this.
+ */
+fn dice_finish(p: ptr<function, PbrInput>, m: DiceMark, look: DiceLook, in: VertexOutput) {
+  let n = normalize(in.world_normal);
+  let chamfer = 1.0 - m.face;
+  (*p).base_color = mix((*p).base_color, look.edge_color.rgb, look.edge_mix * chamfer);
+
+  // Engraving: the rim of each mark slopes into it, and the recess is a little shadowed.
+  let t = in.world_tangent.xyz;
+  if (look.mark_depth > 0.0 && m.face > 0.5 && dot(t, t) > 1e-8) {
+    let tangent = normalize(t - n * dot(n, t));
+    let bitangent = cross(n, tangent) * in.world_tangent.w;
+    let rim = clamp((m.inside + 1.0) / 2.5, 0.0, 1.0);
+    let wall = 6.0 * rim * (1.0 - rim) * look.mark_depth;
+    (*p).normal = normalize(n + (tangent * m.slope.x - bitangent * m.slope.y) * wall * 0.9);
+    (*p).occlusion *= 1.0 - 0.35 * look.mark_depth * clamp(m.inside / 3.0, 0.0, 1.0);
+  }
+
+  let ink = m.coverage * look.mark_color.a;
+  (*p).base_color = mix((*p).base_color, look.mark_color.rgb, ink);
+  (*p).roughness = mix((*p).roughness, look.mark_roughness, ink);
+  (*p).metallic = mix((*p).metallic, look.mark_metallic, ink);
+  (*p).emissive += look.mark_color.rgb * look.mark_emissive * ink;
+  (*p).alpha = max((*p).alpha, ink);
+
+  // Dropped: toward the dropped tone, keeping some of the body's lightness; rougher, 0.62 opaque.
+  let d = look.dropped;
+  let tone = look.dropped_color.rgb * (0.55 + 0.45 * dice_luma((*p).base_color) / max(dice_luma(look.dropped_color.rgb), 0.05));
+  (*p).base_color = mix((*p).base_color, tone, d * 0.85);
+  (*p).roughness = min(1.0, (*p).roughness + 0.24 * d);
+  (*p).metallic *= 1.0 - d;
+  (*p).emissive *= 1.0 - 0.8 * d;
+  (*p).alpha = mix((*p).alpha, 0.62, d) * look.fade;
+}
+`
+};
+const families = /* @__PURE__ */ new Map();
+function snake(name) {
+  return materialModulePath(name).slice("material::".length);
+}
+function familyModule(name, type, surface) {
+  const u = type.varName;
+  const look = [
+    "markColor",
+    "edgeColor",
+    "droppedColor",
+    "markEmissive",
+    "markRoughness",
+    "markMetallic",
+    "markDepth",
+    "edgeMix",
+    "dropped",
+    "fade",
+    "result",
+    "resultTime"
+  ].map((f) => `${u}.${f}`).join(", ");
+  const path = `dice::family::${snake(name)}`;
+  const source = `
+import shard::pbr::types::{ VertexOutput, PbrInput };
+import shard::globals::globals;
+import shard::dice::surface::{ DiceLook, DiceMark, dice_base, dice_mark, dice_finish, dice_extra, dice_view, dice_local_ray, dice_hash, dice_noise, dice_fbm, dice_luma };
+import ${type.modulePath}::{ ${u}, ${u}_marks, ${u}_marks_sampler };
+
+override fn vertex_extra(position: vec3f, normal: vec3f, uv: vec2f) -> vec4f {
+  return dice_extra(position);
+}
+
+override fn pbr_input(in: VertexOutput) -> PbrInput {
+  let m = dice_mark(in, ${u}_marks, ${u}_marks_sampler);
+  let look = DiceLook(${look});
+  var p = dice_base(in);
+  let F = ${u};
+  let local = in.extra.xyz;
+  let value = floor(in.extra.w + 0.5);
+  let v = dice_view(in);
+${surface}
+  dice_finish(&p, m, look, in);
+  return p;
+}
+`;
+  return { path, source };
+}
+function defineDiceFamily(name, options) {
+  for (const key of Object.keys(options.fields ?? {})) {
+    if (DICE_FIELD_NAMES.includes(key)) {
+      throw new ShardError(
+        "dice/family-field-clash",
+        `Dice family ${name} redefines the dice field "${key}"`,
+        {
+          hint: "Give the field another name: the dice fields are shared by every family."
+        }
+      );
+    }
+  }
+  if (!options.surface && !options.shader) {
+    throw new ShardError(
+      "dice/invalid-family",
+      `Dice family ${name} has no surface and no shader`,
+      {
+        hint: "Give a WGSL `surface` snippet, or a `shader` module overriding pbr_input."
+      }
+    );
+  }
+  const shaderPath = options.shader ?? `dice::family::${snake(name)}`;
+  const type = defineMaterial(name, {
+    extends: "standard",
+    standardTextures: false,
+    fields: { ...DICE_FIELDS, ...options.fields },
+    blend: options.blend,
+    shader: shaderPath,
+    description: options.description ?? `Dice family ${name}.`
+  });
+  const animated = options.animated;
+  if (typeof animated === "object" && !(animated.fps > 0)) {
+    throw new ShardError(
+      "dice/invalid-family",
+      `Dice family ${name} animates at ${animated.fps} fps`,
+      { hint: "Give animated: true (the display rate) or { fps } above 0.", path: "animated.fps" }
+    );
+  }
+  const family = {
+    name,
+    type,
+    module: options.surface ? familyModule(name, type, options.surface) : void 0,
+    translucent: options.translucent,
+    fps: animated === true ? Number.POSITIVE_INFINITY : animated ? animated.fps : 0
+  };
+  families.set(name, family);
+  return family;
+}
+function findDiceFamily(name) {
+  return families.get(name);
+}
+function allDiceFamilies() {
+  return [...families.values()];
+}
+function isDiceMaterial(type) {
+  return DICE_FIELD_NAMES.every((f) => f in type.schema.fields);
+}
+export {
+  DICE_FIELDS,
+  DICE_SHADERS,
+  allDiceFamilies,
+  defineDiceFamily,
+  findDiceFamily,
+  findMaterialType,
+  isDiceMaterial
+};

package/dist/math.d.ts

@@ -0,0 +1,39 @@
+export type V3 = [number, number, number];
+/** x y z w. */
+export type Q4 = [number, number, number, number];
+export declare const EPSILON = 0.00001;
+export declare const v3: (x?: number, y?: number, z?: number) => V3;
+export declare const add: (a: V3, b: V3) => V3;
+export declare const sub: (a: V3, b: V3) => V3;
+export declare const scale: (a: V3, s: number) => V3;
+export declare const dot: (a: V3, b: V3) => number;
+export declare const cross: (a: V3, b: V3) => V3;
+export declare const length: (a: V3) => number;
+export declare function normalize(a: V3): V3;
+export declare const distance: (a: V3, b: V3) => number;
+/** The part of `a` perpendicular to unit `n`, normalized. */
+export declare function tangentOf(a: V3, n: V3): V3;
+/** A unit tangent of unit `n` that doesn't depend on anything else (Aether's convention). */
+export declare function stableTangent(n: V3): V3;
+export declare const qIdentity: () => Q4;
+export declare function qMul(a: Q4, b: Q4): Q4;
+export declare const qConj: (q: Q4) => Q4;
+export declare function qNormalize(q: Q4): Q4;
+export declare function qRotate(q: Q4, v: V3): V3;
+export declare function qAxisAngle(axis: V3, radians: number): Q4;
+/** The rotation whose matrix has these columns (an orthonormal, right-handed basis). */
+export declare function qFromBasis(x: V3, y: V3, z: V3): Q4;
+/**
+ * The rotation taking the frame (n, b) to (n2, b2): n and n2 unit normals, b ⟂ n and b2 ⟂ n2 unit
+ * "up" directions. Exact when the angle between n and b equals the one between n2 and b2.
+ */
+export declare function qFromFrames(n: V3, b: V3, n2: V3, b2: V3): Q4;
+/** Canonical sign (first non-zero of w, x, y, z positive), so equal rotations compare equal. */
+export declare function qCanonical(q: Q4): Q4;
+export declare const qKey: (q: Q4) => string;
+/** Rounds away float noise, so hull output and frames are stable across platforms. */
+export declare function round(v: number): number;
+/** The angle between two unit vectors, in radians. */
+export declare function angleBetween(a: V3, b: V3): number;
+/** FNV-1a over a string, finished with a 32-bit mix: a stable seed from a roll id. */
+export declare function hashString(s: string): number;

package/dist/math.js

@@ -0,0 +1,136 @@
+const EPSILON = 1e-5;
+const v3 = (x = 0, y = 0, z = 0) => [x, y, z];
+const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+const length = (a) => Math.sqrt(dot(a, a));
+function normalize(a) {
+  const l = length(a);
+  return l > 0 ? [a[0] / l, a[1] / l, a[2] / l] : [0, 0, 0];
+}
+const distance = (a, b) => length(sub(a, b));
+function tangentOf(a, n) {
+  return normalize(sub(a, scale(n, dot(a, n))));
+}
+function stableTangent(n) {
+  const axis = Math.abs(n[1]) < 0.82 ? [0, 1, 0] : [1, 0, 0];
+  return tangentOf(axis, n);
+}
+const qIdentity = () => [0, 0, 0, 1];
+function qMul(a, b) {
+  const [ax, ay, az, aw] = a;
+  const [bx, by, bz, bw] = b;
+  return [
+    aw * bx + ax * bw + ay * bz - az * by,
+    aw * by - ax * bz + ay * bw + az * bx,
+    aw * bz + ax * by - ay * bx + az * bw,
+    aw * bw - ax * bx - ay * by - az * bz
+  ];
+}
+const qConj = (q) => [-q[0], -q[1], -q[2], q[3]];
+function qNormalize(q) {
+  const l = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3]) || 1;
+  return [q[0] / l, q[1] / l, q[2] / l, q[3] / l];
+}
+function qRotate(q, v) {
+  const [qx, qy, qz, qw] = q;
+  const tx = 2 * (qy * v[2] - qz * v[1]);
+  const ty = 2 * (qz * v[0] - qx * v[2]);
+  const tz = 2 * (qx * v[1] - qy * v[0]);
+  return [
+    v[0] + qw * tx + (qy * tz - qz * ty),
+    v[1] + qw * ty + (qz * tx - qx * tz),
+    v[2] + qw * tz + (qx * ty - qy * tx)
+  ];
+}
+function qAxisAngle(axis, radians) {
+  const n = normalize(axis);
+  const s = Math.sin(radians / 2);
+  return [n[0] * s, n[1] * s, n[2] * s, Math.cos(radians / 2)];
+}
+function qFromBasis(x, y, z) {
+  const m00 = x[0];
+  const m11 = y[1];
+  const m22 = z[2];
+  const trace = m00 + m11 + m22;
+  let q;
+  if (trace > 0) {
+    const s = Math.sqrt(trace + 1) * 2;
+    q = [(y[2] - z[1]) / s, (z[0] - x[2]) / s, (x[1] - y[0]) / s, s / 4];
+  } else if (m00 > m11 && m00 > m22) {
+    const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
+    q = [s / 4, (y[0] + x[1]) / s, (z[0] + x[2]) / s, (y[2] - z[1]) / s];
+  } else if (m11 > m22) {
+    const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
+    q = [(y[0] + x[1]) / s, s / 4, (z[1] + y[2]) / s, (z[0] - x[2]) / s];
+  } else {
+    const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
+    q = [(z[0] + x[2]) / s, (z[1] + y[2]) / s, s / 4, (x[1] - y[0]) / s];
+  }
+  return qNormalize(q);
+}
+function qFromFrames(n, b, n2, b2) {
+  const t = cross(b, n);
+  const t2 = cross(b2, n2);
+  const from = qFromBasis(t, b, n);
+  const to = qFromBasis(t2, b2, n2);
+  return qNormalize(qMul(to, qConj(from)));
+}
+function qCanonical(q) {
+  const pivot = [q[3], q[0], q[1], q[2]].find((v) => Math.abs(v) > 1e-8) ?? 1;
+  const s = pivot < 0 ? -1 : 1;
+  return [round(q[0] * s), round(q[1] * s), round(q[2] * s), round(q[3] * s)];
+}
+const qKey = (q) => qCanonical(q).map((v) => v.toFixed(6)).join(":");
+function round(v) {
+  return Math.abs(v) < 1e-9 ? 0 : Number(v.toFixed(9));
+}
+function angleBetween(a, b) {
+  return Math.acos(Math.max(-1, Math.min(1, dot(a, b))));
+}
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507);
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+export {
+  EPSILON,
+  add,
+  angleBetween,
+  cross,
+  distance,
+  dot,
+  hashString,
+  length,
+  normalize,
+  qAxisAngle,
+  qCanonical,
+  qConj,
+  qFromBasis,
+  qFromFrames,
+  qIdentity,
+  qKey,
+  qMul,
+  qNormalize,
+  qRotate,
+  round,
+  scale,
+  stableTangent,
+  sub,
+  tangentOf,
+  v3
+};

package/dist/mesh.d.ts

@@ -0,0 +1,9 @@
+import { Mesh } from '@aethervtt/shard-mesh';
+import type { DieGeometry } from './definition.js';
+/**
+ * A chamfered, flat-shaded die: `bevel` (default the definition's) moves each face corner toward
+ * its face's center. Unit radius; the entity's scale sizes it.
+ */
+export declare function dieMesh(g: DieGeometry, bevel?: number): Mesh;
+/** A unit quad on the floor (y up), for the tray and its contact blobs. */
+export declare function floorQuad(): Mesh;

package/dist/mesh.js

@@ -0,0 +1,105 @@
+import { Mesh } from "@aethervtt/shard-mesh";
+import { cellLayout, cellUv } from "./cells.js";
+import { add, cross, dot, normalize, scale, stableTangent, sub } from "./math.js";
+function vertex(b, p, n, t, u, v, face) {
+  const i = b.positions.length / 3;
+  b.positions.push(p[0], p[1], p[2]);
+  b.normals.push(n[0], n[1], n[2]);
+  b.tangents.push(t[0], t[1], t[2], 1);
+  b.uvs.push(u, v);
+  b.uvs1.push(face >= 0 ? 1 : 0, face);
+  return i;
+}
+function fan(b, ids) {
+  for (let k = 1; k + 1 < ids.length; k++) b.indices.push(ids[0], ids[k], ids[k + 1]);
+}
+function dieMesh(g, bevel = g.definition.bevel) {
+  const { points, faces } = g.polytope;
+  const layout = cellLayout(g);
+  const b = { positions: [], normals: [], uvs: [], uvs1: [], tangents: [], indices: [] };
+  const inset = faces.map((face) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const v of face.vertices) {
+      map.set(v, add(points[v], scale(sub(face.center, points[v]), bevel)));
+    }
+    return map;
+  });
+  const uv = [0, 0];
+  faces.forEach((face, f) => {
+    const cell = layout.faces[f];
+    const ids = face.vertices.map((v) => {
+      const p = inset[f].get(v);
+      cellUv(layout, cell, p, uv, 0);
+      return vertex(b, p, face.normal, cell.tangent, uv[0], uv[1], f);
+    });
+    fan(b, ids);
+  });
+  if (bevel <= 0) return build(b);
+  const radial = (p) => normalize(p);
+  const chamferVertex = (p) => {
+    const n = radial(p);
+    return vertex(b, p, n, stableTangent(n), 0, 0, -1);
+  };
+  const edges = /* @__PURE__ */ new Map();
+  faces.forEach((face, f) => {
+    const vs = face.vertices;
+    for (let k = 0; k < vs.length; k++) {
+      const a = vs[k];
+      const c = vs[(k + 1) % vs.length];
+      const key = a < c ? `${a}:${c}` : `${c}:${a}`;
+      const list = edges.get(key) ?? [];
+      list.push({ face: f, a, b: c });
+      edges.set(key, list);
+    }
+  });
+  for (const pair of edges.values()) {
+    if (pair.length !== 2) continue;
+    const [first, second] = pair;
+    const quad = [
+      inset[first.face].get(first.a),
+      inset[first.face].get(first.b),
+      inset[second.face].get(first.b),
+      inset[second.face].get(first.a)
+    ];
+    const center = scale(add(add(quad[0], quad[1]), add(quad[2], quad[3])), 0.25);
+    const n = cross(sub(quad[1], quad[0]), sub(quad[2], quad[0]));
+    if (dot(n, center) < 0) quad.reverse();
+    fan(b, quad.map(chamferVertex));
+  }
+  points.forEach((p, v) => {
+    const around = [];
+    faces.forEach((face, f) => {
+      if (face.vertices.includes(v)) around.push(inset[f].get(v));
+    });
+    if (around.length < 3) return;
+    const out = normalize(p);
+    const t = stableTangent(out);
+    const bt = cross(out, t);
+    around.sort((l, r) => Math.atan2(dot(l, bt), dot(l, t)) - Math.atan2(dot(r, bt), dot(r, t)));
+    fan(b, around.map(chamferVertex));
+  });
+  return build(b);
+}
+function build(b) {
+  const n = b.positions.length / 3;
+  return Mesh.create({
+    positions: Float32Array.from(b.positions),
+    normals: Float32Array.from(b.normals),
+    uvs: Float32Array.from(b.uvs),
+    uvs1: Float32Array.from(b.uvs1),
+    tangents: Float32Array.from(b.tangents),
+    indices: n < 65536 ? Uint16Array.from(b.indices) : Uint32Array.from(b.indices)
+  });
+}
+function floorQuad() {
+  return Mesh.create({
+    positions: Float32Array.from([-1, 0, -1, 1, 0, -1, 1, 0, 1, -1, 0, 1]),
+    normals: Float32Array.from([0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]),
+    uvs: Float32Array.from([0, 0, 1, 0, 1, 1, 0, 1]),
+    indices: Uint16Array.from([0, 2, 1, 0, 3, 2])
+  });
+}
+export {
+  dieMesh,
+  floorQuad
+};

package/dist/methods.d.ts

@@ -0,0 +1,2 @@
+import type { AppMethod } from '@aethervtt/shard-runtime';
+export declare const diceMethods: AppMethod[];

package/dist/methods.js

@@ -0,0 +1,42 @@
+import { defineSchema, t } from "@aethervtt/shard-core";
+import { DiceTable } from "./table.js";
+const diceMethods = [
+  {
+    name: "dice.describe",
+    description: "The dice table: phase, quality tier and its reason, each die (kind, value, label, natural value, correction, placed), the track (hash, steps, settled, maxStepsHit, simulation ms, contacts), placed-fallback dice, matched recipes, draw calls, live attachments, the dice's lens fields, resources and GPU objects.",
+    params: defineSchema("dice/DescribeParams", {}),
+    handler: ({ world }) => world.resource(DiceTable).describe()
+  },
+  {
+    name: "dice.play",
+    description: "Plays a roll the host decided: { roll: { id, dice: [{ kind: 'd20', value: 17, skin: { guid: 'dice:skin/ivory' } }], seed, tray, motion, quality, effects }, replace, wait }. With wait, resolves with the outcome once it's over (a 60 s rest unless dismissed); otherwise at once.",
+    params: defineSchema("dice/PlayParams", {
+      roll: t.json({ description: "A DiceRoll." }),
+      replace: t.bool({ description: "Dismiss a roll that is playing." }),
+      wait: t.bool({ description: "Resolve with the outcome instead of at once." })
+    }),
+    handler: async ({ world }, p) => {
+      const table = world.resource(DiceTable);
+      const outcome = table.play(p.roll, { replace: p.replace });
+      if (p.wait) return { outcome: await outcome, lastError: table.describe().lastError };
+      outcome.catch(() => {
+      });
+      return { started: true, phase: table.phase };
+    }
+  },
+  {
+    name: "dice.dismiss",
+    description: "Dismisses the roll on the table, if any.",
+    params: defineSchema("dice/DismissParams", {}),
+    handler: ({ world }) => ({ dismissed: world.resource(DiceTable).dismiss() })
+  },
+  {
+    name: "dice.skip",
+    description: "Lands every entrance still to come or playing, now (0065): each die snaps to its rest pose, target up; scenes wind down within 400 ms.",
+    params: defineSchema("dice/SkipParams", {}),
+    handler: ({ world }) => ({ skipped: world.resource(DiceTable).skip() })
+  }
+];
+export {
+  diceMethods
+};

package/dist/numerals.d.ts

@@ -0,0 +1,9 @@
+export interface NumeralGlyph {
+    /** Advance width, thousandths of an em. */
+    advance: number;
+    /** Outline: M, L, Q, C and Z commands, absolute, y up. */
+    path: string;
+}
+/** Cap height of the digits, thousandths of an em. */
+export declare const NUMERAL_HEIGHT = 727.5;
+export declare const DICE_NUMERALS: Readonly<Record<string, NumeralGlyph>>;