@pieai/swimmer-avatar-kit 0.1.0

package/vendor/kindergrimm/src/gloss/gpalette.js

@@ -0,0 +1,205 @@
+// ---------------------------------------------------------------
+// THE PALETTES — twelve soft five-colour sets, from the reference
+// sheet. A character picks a PALETTE, then one colour out of it for
+// the body and a second for its warm bits (blush, tongue, an accent).
+// Both come from the same five, which is what stops a sheet of twenty
+// looking like twenty unrelated characters.
+//
+// These were sampled from the swatches by eye — the printed hex codes
+// on the sheet are below legible resolution. Correcting one is editing
+// one string, and nothing downstream reads a colour by name.
+//
+// `INK` is deliberately NOT in any palette. One warm near-black does
+// every eye, brow and mouth in the lab, and that single shared value
+// is most of the family resemblance — the same job the one graphite
+// does for the drawn crowd.
+// ---------------------------------------------------------------
+
+export const INK = '#2b2422';
+
+// The white of an eye — warm and slightly off, never paper white. It
+// sits outside the palettes for the same reason INK does: one value
+// across the whole lab is what makes twelve palettes look like one
+// cast rather than twelve unrelated ones.
+export const SCLERA = '#f6f2e9';
+
+// Inside an open mouth. Dark warm maroon, shared like INK: every open
+// maw on the sheet is the same pour, which is most of what makes a
+// mouth read as an interior rather than as a dark sticker.
+export const MAW = '#5b2530';
+
+/** a colour lifted toward white — the muzzle-patch pour. This is a
+ *  LIGHTER PART, a second colour of vinyl like a panda's white face,
+ *  not a highlight; the no-painted-shadows rule is about darkness. */
+export function tint(hex, k = .5) {
+  const n = parseInt(hex.slice(1), 16);
+  const c = [n >> 16 & 255, n >> 8 & 255, n & 255]
+    .map(v => Math.round(v + (255 - v) * k));
+  return '#' + c.map(v => v.toString(16).padStart(2, '0')).join('');
+}
+
+export const PALETTES = [
+  { id: 'dusk',    label: 'dusk',    colors: ['#CFC6D9', '#7B7BB0', '#F5C48A', '#F7E6C4', '#D9A5A5'] },
+  { id: 'meadow',  label: 'meadow',  colors: ['#F2E08D', '#9FCFE1', '#E7E3A2', '#F4B8C4', '#F6C9CE'] },
+  { id: 'harbour', label: 'harbour', colors: ['#3D77A6', '#7FA6BE', '#F2E7A0', '#F7D9B0', '#F2704A'] },
+  { id: 'denim',   label: 'denim',   colors: ['#4A7BA6', '#F2A6A0', '#F7D5D5', '#A67BA6', '#F0EDE6'] },
+  { id: 'mist',    label: 'mist',    colors: ['#C6CFE8', '#CFC6E8', '#F2D0DE', '#F7DCC0', '#F7C6CE'] },
+  { id: 'bloom',   label: 'bloom',   colors: ['#F4AFC5', '#F2D0EA', '#E0AFD9', '#B8D4F0', '#B0B9E8'] },
+  { id: 'orchard', label: 'orchard', colors: ['#6B5C7B', '#F5F0E1', '#F2E88A', '#C6DE8A', '#F2A03C'] },
+  { id: 'lagoon',  label: 'lagoon',  colors: ['#3AB8A0', '#A8D6C0', '#BDD9A0', '#D9E8A8', '#A8DEC8'] },
+  { id: 'melon',   label: 'melon',   colors: ['#A8D6C8', '#F2B8A0', '#F2A08A', '#F2C6C6', '#E85A3C'] },
+  { id: 'ember',   label: 'ember',   colors: ['#F2C6D0', '#F2A8A0', '#F29078', '#F2A03C', '#E87830'] },
+  { id: 'moss',    label: 'moss',    colors: ['#A8D6C0', '#BDE0B0', '#D2E8A8', '#EDE8A0', '#E8C84A'] },
+  { id: 'apricot', label: 'apricot', colors: ['#F7E8D9', '#F7C6A8', '#F2A88A', '#F2907A', '#E8705A'] },
+
+  // SKIN — the humanoid's, and the only palette that is not a colour
+  // scheme but a RANGE of one thing. Four skin tones pale to deep,
+  // and a rosy fifth that `colorsFor` will always score as the warm
+  // one, so the blush is a flush of the same face rather than a
+  // sticker in an unrelated colour. Kept out of the random deal (see
+  // `PALETTE_DEAL_IDS`): a skin-toned bear is just a beige bear.
+  { id: 'skin', label: 'skin', colors: ['#F7DFCE', '#EFC4A6', '#D79E76', '#A9704B', '#F0A99A'] },
+];
+
+export const PALETTE_IDS = PALETTES.map(p => p.id);
+// what an un-opinionated character may be poured in. `skin` is asked
+// for by name or pinned by hand, never dealt.
+export const PALETTE_DEAL_IDS = PALETTE_IDS.filter(id => id !== 'skin');
+export const PALETTE_BY_ID = Object.fromEntries(PALETTES.map(p => [p.id, p]));
+
+// ---------------------------------------------------------------
+// HAIR. Its own table, and that is the point: hair is never the body's
+// colour. A character's five-colour set is what makes a sheet look like
+// one cast; a HEAD's hair is what tells two of them apart, so it is
+// dealt from here instead, exactly as `INK` sits outside the palettes.
+//
+// Weighted, because frequency is art direction here too. The naturals
+// carry the line — a sheet where a third of the heads are mint is a
+// novelty aisle, not a cast of characters — and the dyed half is the
+// treat. `ink` leads: black hair is the commonest hair there is, and it
+// is the one value already doing every brow and eye in the lab.
+// ---------------------------------------------------------------
+export const HAIR_COLORS = [
+  { id: 'ink',      label: 'black',    hex: '#2B2422', w: 15 },
+  { id: 'espresso', label: 'espresso', hex: '#3B2820', w: 11 },
+  { id: 'chocolate',label: 'chocolate',hex: '#4E3527', w: 10 },
+  { id: 'chestnut', label: 'chestnut', hex: '#6B4430', w: 10 },
+  { id: 'caramel',  label: 'caramel',  hex: '#9A6C3E', w: 8 },
+  { id: 'honey',    label: 'honey',    hex: '#C0913F', w: 6 },
+  { id: 'blonde',   label: 'blonde',   hex: '#DFC072', w: 6 },
+  { id: 'platinum', label: 'platinum', hex: '#E4D8BC', w: 4 },
+  { id: 'ginger',   label: 'ginger',   hex: '#BC5A2C', w: 5 },
+  { id: 'ash',      label: 'ash',      hex: '#7E776C', w: 4 },
+  { id: 'silver',   label: 'silver',   hex: '#C3BFB6', w: 4 },
+  // the dyed half — a treat, never the rule
+  { id: 'rose',     label: 'rose',     hex: '#DE8397', w: 4 },
+  { id: 'lilac',    label: 'lilac',    hex: '#A08FC4', w: 4 },
+  { id: 'mint',     label: 'mint',     hex: '#84C1A6', w: 3 },
+  { id: 'sky',      label: 'sky',      hex: '#7BA2D2', w: 3 },
+  { id: 'plum',     label: 'plum',     hex: '#65456E', w: 3 },
+];
+
+export const HAIR_IDS = HAIR_COLORS.map(c => c.id);
+export const HAIR_BY_ID = Object.fromEntries(HAIR_COLORS.map(c => [c.id, c]));
+export const HAIR_WEIGHTS = HAIR_COLORS.filter(c => c.w > 0).map(c => [c.id, c.w]);
+
+// ---------------------------------------------------------------
+// ACCESSORIES. Their own table, for exactly the reason hair has one: a
+// hat, a frame or a plaster has to be VISIBLE, and it cannot be if it
+// is drawn from the character's own five. On a humanoid that is fatal —
+// every colour in the `skin` palette IS a skin tone, so the first
+// beanie came out as a bald head.
+//
+// These are the colours real accessories actually use: strong,
+// slightly dirty, and few. `pickAcc` then guarantees the one chosen
+// stands clear of BOTH the body and the hair, so a red hat never lands
+// on a red character and a black one never lands on black hair.
+// ---------------------------------------------------------------
+// No terracotta and no tan. They were in, and against a skin body they
+// scored well on luma while being the same HUE — a brick beanie on a
+// peach head lit by a warm key came out as another shade of face. Luma
+// is not enough; see `pickAcc`.
+export const ACC_COLORS = [
+  '#2B2422', '#F0EAE0', '#C6483E', '#D8C049',
+  '#5E9E86', '#3F7FA6', '#6E4E8C', '#8A8E93', '#B8375C', '#3E5C4A',
+];
+
+/** the accessory colour furthest in luma from both the character and its
+ *  hair, chosen deterministically from a rolled index so the same
+ *  recipe always gets the same one. */
+export function pickAcc(i, body, hair) {
+  // FULL RGB distance, not luma. Scored on lightness alone a terracotta
+  // beats a teal against peach skin — and then renders as another shade
+  // of face, because it is the same hue and the key light is warm.
+  // Distance in colour, not in brightness.
+  const rgb = hex => { const n = parseInt(hex.slice(1), 16);
+    return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255]; };
+  const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+  const B = rgb(body), H = rgb(hair);
+  let best = ACC_COLORS[0], score = -1;
+  for (let k = 0; k < ACC_COLORS.length; k++) {
+    const c = ACC_COLORS[(k + i) % ACC_COLORS.length];
+    const C = rgb(c);
+    // the WORSE of its two clearances decides — an accessory has to
+    // stand off the skin and off the hair, not average well
+    const d = Math.min(dist(C, B), dist(C, H));
+    // the rolled index breaks ties, so a sheet still varies instead of
+    // everyone converging on the one safest colour
+    const sc = d + (k === 0 ? .05 : 0);
+    if (sc > score) { score = sc; best = c; }
+  }
+  return best;
+}
+
+/**
+ * The OUTFIT: cloth for the torso, gloves, shoes — three picks from
+ * `ACC_COLORS`, chosen greedily so each stands clear of the skin, the
+ * hair AND the pieces already picked. Same scoring as `pickAcc` (full
+ * RGB distance, worst clearance decides) and deterministic from the
+ * rolled index, so a recipe always dresses the same way. Gloves and
+ * shoes only have to clear the CLOTH and the skin — a glove matching
+ * a shoe is a set, not a clash.
+ */
+export function pickOutfit(i, body, hair) {
+  const rgb = hex => { const n = parseInt(hex.slice(1), 16);
+    return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255]; };
+  const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+  const pickVs = (ix, against) => {
+    let best = ACC_COLORS[0], score = -1;
+    for (let k = 0; k < ACC_COLORS.length; k++) {
+      const c = ACC_COLORS[(k + ix) % ACC_COLORS.length];
+      const C = rgb(c);
+      const d = Math.min(...against.map(a => dist(C, rgb(a))));
+      const sc = d + (k === 0 ? .05 : 0);
+      if (sc > score) { score = sc; best = c; }
+    }
+    return best;
+  };
+  const cloth = pickVs(i, [body, hair]);
+  const glove = pickVs(i + 3, [body, cloth]);
+  const shoe = pickVs(i + 6, [body, cloth]);
+  return { cloth, glove, shoe };
+}
+
+/** a → b by t, in hex. For the brow, which is the hair's own colour
+ *  pulled toward ink: a platinum brow at full strength disappears, and
+ *  an ink one on blonde hair reads as somebody else's eyebrows. */
+export function mix(a, b, t) {
+  const A = parseInt(a.slice(1), 16), B = parseInt(b.slice(1), 16);
+  const c = [16, 8, 0].map(s =>
+    Math.round(((A >> s) & 255) + (((B >> s) & 255) - ((A >> s) & 255)) * t));
+  return '#' + c.map(v => v.toString(16).padStart(2, '0')).join('');
+}
+
+/** how dark a colour reads, 0..1 — used to keep a feature off a body
+ *  it would vanish against, never to invent a colour. */
+export function luma(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  return (.2126 * (n >> 16 & 255) + .7152 * (n >> 8 & 255) + .0722 * (n & 255)) / 255;
+}
+
+// There was a `shade()` here, darkening the body colour for a ring
+// behind each eye. It is gone with the rim: on palettes this pale a
+// darkened body tone does not read as shadow, it reads as a second
+// colour. A shadow on this lab comes from geometry and the studio,
+// never from a colour picked to look like one.

package/vendor/kindergrimm/src/gloss/gparts/blush.js

@@ -0,0 +1,57 @@
+// THE BLUSH. Two warm patches out on the cheeks, in a colour taken
+// from the character's own palette rather than a pink invented for the job —
+// which is what keeps a sheet of twenty looking like one cast.
+//
+// It sits barely proud: a cheek is the one feature that should read as
+// painted on rather than moulded in.
+const STYLE = {
+  none:   null,
+  oval:   { outline: 'ellipse', wf: 1, hf: .62, n: 1 },
+  round:  { outline: 'ellipse', wf: .8, hf: .8, n: 1 },
+  stripes:{ outline: 'rect', wf: .8, hf: .1, n: 3 },
+  heart:  { outline: 'heart', wf: .62, hf: .58, n: 1 },
+};
+
+export const BLUSH_STYLES = Object.keys(STYLE);
+
+export const Blush = {
+  id: 'blush', label: 'blush', order: 5,
+
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['none', 40], ['oval', 20], ['round', 16], ['stripes', 12], ['heart', 12]]),
+    out: C.range(rng, 'out', .24, .4),        // further out than the eyes
+    drop: C.range(rng, 'drop', .2, .38),       // and below them
+    size: C.range(rng, 'size', .8, 1.25),      // × eye size
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: BLUSH_STYLES },
+    out: { label: 'outward', range: [0, .8] },
+    drop: { label: 'drop', range: [0, .8] },
+    size: { label: 'size', range: [.4, 2] },
+  }),
+
+  build(add, P, L) {
+    const B = P.blush;
+    const st = STYLE[B.style];
+    if (!st) return;
+    const r = L.eyeR * B.size;
+
+    for (const [id, side] of [['blushL', -1], ['blushR', 1]]) {
+      // onFace, not at: a cheek is placed outboard of the eye on
+      // purpose, which walks it straight at the silhouette
+      const a = L.onFace(side * (L.eyeX + B.out), L.eyeY - B.drop,
+                         { halfW: r * st.wf });
+      for (let i = 0; i < st.n; i++) {
+        // a stripe set is one shape repeated up the cheek
+        const dy = st.n === 1 ? 0 : (i - (st.n - 1) / 2) * r * .34;
+        add({ type: 'plate', id: st.n === 1 ? id : `${id}${i}`, outline: st.outline,
+              w: r * st.wf * (st.n > 1 ? 1 - Math.abs(i - (st.n - 1) / 2) * .22 : 1),
+              h: r * st.hf,
+              p: a.p, n: a.n, roll: side * .12, offset: [0, dy],
+              d: r * .16, bevel: Math.min(r * .09, r * st.hf * .45),
+              proud: r * .04, color: L.warm });
+      }
+    }
+  },
+};

package/vendor/kindergrimm/src/gloss/gparts/body.js

@@ -0,0 +1,47 @@
+// THE BODY. Four forms and two techniques: a sphere and a cube are one
+// superellipsoid with a squareness knob, and a ROCK and a SLIME are
+// MODELED — a low-poly control cage through Catmull-Clark (`gform.js`).
+// The face catalogue never knows which: features place through `L.at`,
+// which is the only thing a form has to provide.
+export const Body = {
+  id: 'body', label: 'body', order: 0,
+
+  // The sheet normalises every character to one HEIGHT, so `r` is nearly
+  // invisible and the ratios are everything: squat-and-wide against
+  // tall-and-narrow is the only silhouette variety a sphere has. These
+  // were ±6% and every character came out the same circle.
+  gen: (rng, C) => ({
+    r: C.range(rng, 'r', .46, .54),
+    // A head is square or WIDER, never taller than it is wide. A tall
+    // narrow head reads as a face squeezed in a vice; the whole family
+    // sits between a square and a squat oval.
+    wide: C.range(rng, 'wide', 1, 1.3),
+    tall: C.range(rng, 'tall', .84, 1),
+    deep: C.range(rng, 'deep', .86, 1.06),
+    // how hard the corners are squared off. Only a `cube` reads it —
+    // a sphere is pinned at 2 so it stays an exact ball. 2.8 is a
+    // pillow, 5.5 is a proper block with the edges softened.
+    corner: C.range(rng, 'corner', 2.8, 5.5),
+  }),
+
+  meta: () => ({
+    r: { label: 'size', range: [.3, .8] },
+    wide: { label: 'width', range: [.7, 1.4] },
+    tall: { label: 'height', range: [.7, 1.4] },
+    deep: { label: 'depth', range: [.7, 1.2] },
+    corner: { label: 'squareness', range: [2, 8] },
+  }),
+
+  build(add, P, L) {
+    // a modeled form arrives as the SAME arrays the layout raycast the
+    // face against — one surface, shared, never rebuilt
+    if (L.formMesh) {
+      add({ type: 'mesh', id: 'body', mesh: L.formMesh,
+            pos: [0, L.cy, 0], color: L.body });
+      return;
+    }
+    add({ type: 'solid', id: 'body',
+          rx: L.rx, ry: L.ry, rz: L.rz, exp: L.exp,
+          pos: [0, L.cy, 0], color: L.body });
+  },
+};

package/vendor/kindergrimm/src/gloss/gparts/brows.js

@@ -0,0 +1,55 @@
+// THE BROWS. Two short bands above the eyes — and almost all of the
+// expression in the whole lab lives in their TILT. A brow rolled down
+// toward the nose is angry, rolled up is worried, and it is the same
+// geometry both times. That is why `roll` is in the plate basis rather
+// than baked into an outline.
+const STYLE = {
+  none:  null,
+  flat:  { curve: 'line', sag: 0,   wf: .9,  tf: .13, roll: 0 },
+  angry: { curve: 'line', sag: 0,   wf: .85, tf: .15, roll: -.42 },
+  sad:   { curve: 'line', sag: 0,   wf: .85, tf: .13, roll: .38 },
+  round: { curve: 'arc',  sag: -.3, wf: .9,  tf: .12, roll: 0 },
+  thick: { curve: 'arc',  sag: -.2, wf: .95, tf: .24, roll: 0 },
+  worry: { curve: 'arc',  sag: .28, wf: .8,  tf: .12, roll: .16 },
+};
+
+export const BROW_STYLES = Object.keys(STYLE);
+
+export const Brows = {
+  id: 'brows', label: 'brows', order: 2,
+
+  // ANECDOTAL. A brow changes a face completely, which is exactly why
+  // almost nobody gets one — on a sheet where every character has them they
+  // stop being expression and become furniture.
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['none', 88], ['flat', 3], ['angry', 3], ['round', 2],
+                                 ['sad', 2], ['thick', 1], ['worry', 1]]),
+    lift: C.range(rng, 'lift', .22, .42),      // above the eye, in face coordinates
+    size: C.range(rng, 'size', .9, 1.25),      // × eye size
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: BROW_STYLES },
+    lift: { label: 'lift', range: [.05, .7] },
+    size: { label: 'size', range: [.5, 1.8] },
+  }),
+
+  build(add, P, L) {
+    const st = STYLE[P.brows.style];
+    if (!st) return;
+    const r = L.eyeR * P.brows.size;
+
+    for (const [id, side] of [['browL', -1], ['browR', 1]]) {
+      const a = L.onFace(side * L.eyeX, L.eyeY + P.brows.lift,
+                         { halfW: r * st.wf });
+      add({ type: 'plate', id, outline: 'band',
+            curve: st.curve, sag: st.sag * r, tube: r * st.tf,
+            w: r * st.wf, h: r * st.tf,
+            p: a.p, n: a.n, roll: st.roll * side,
+            d: r * .22, bevel: r * st.tf * .5,
+            // the head's own hair, pulled toward ink by the layout —
+            // ink brows under blonde hair read as somebody else's
+            proud: r * .1, color: L.browColor ?? L.ink });
+    }
+  },
+};

package/vendor/kindergrimm/src/gloss/gparts/crest.js

@@ -0,0 +1,88 @@
+// THE CREST — ears, horns, and whatever else breaks the top of the
+// head. This is the other half of why the reference reads as a sheet
+// of CREATURES: a cat, a bear and a bunny are the same ball with the
+// same face, told apart entirely by what sticks up. The silhouette is
+// doing the species work.
+//
+// Ears are PLATES, like the face: flat shapes with a bevelled rim,
+// facing the camera. That is not a cheat — the reference characters' ears
+// really are this flat — and it means an inner-ear is just a smaller
+// warm plate on top, the way an eye's pupil is. They stand on
+// `L.top(t)`, the layout's rim-of-the-head anchor, tilted a little
+// toward the surface normal so a pair fans outward.
+const STYLE = {
+  none:  null,
+  cat:   { outline: 'tri',  wf: .82, hf: 1.05, inner: .5,  lean: .2 },
+  bear:  { outline: 'ellipse', wf: .76, hf: .76, inner: .55, lean: .12 },
+  bunny: { outline: 'rect', wf: .42, hf: 1.2, r: 1, inner: .55, lean: .16, tall: true },
+  horns: { outline: 'tri',  wf: .4, hf: .78,  inner: 0,  lean: .55, tone: 'warm' },
+  stubs: { outline: 'ellipse', wf: .36, hf: .52, inner: 0, lean: .3, tone: 'warm' },
+};
+
+// Three hair styles lived here — `tuft`, `mop`, `curl`, ink plates
+// standing on the crown. They were a placeholder for a real haircut and
+// they are gone: hair is `hair.js` now, a lofted shell over the skull
+// with a hem, a colour table and a finish of its own. The crest is back
+// to what it is good at, which is ears and horns.
+
+export const CREST_STYLES = Object.keys(STYLE);
+
+export const Crest = {
+  id: 'crest', label: 'ears', order: 2,
+
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['none', 26], ['bear', 20], ['cat', 18], ['bunny', 14],
+                                 ['horns', 12], ['stubs', 10]]),
+    spread: C.range(rng, 'spread', .45, .78), // out along the crown, ±1 is the side
+    size: C.range(rng, 'size', .7, .95),      // × the head's own radius
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: CREST_STYLES },
+    spread: { label: 'apart', range: [.15, 1] },
+    size: { label: 'size', range: [.4, 1.6] },
+  }),
+
+  build(add, P, L) {
+    const C = P.crest;
+    const st = STYLE[C.style];
+    if (!st) return;
+    const u = Math.min(L.rx, L.ry) * .5 * C.size;
+    const w = u * st.wf, h = u * st.hf * (st.tall ? 1 : 1);
+    const d = u * .3;
+
+    for (const [id, side] of [['earL', -1], ['earR', 1]]) {
+      const a = L.top(side * C.spread);
+      // fanned: mostly facing the camera, leaning into the head's own
+      // normal so a pair splays the way stuck-on ears do
+      const n = [a.n[0] * .45, a.n[1] * .45, 1];
+      // MIRRORED: the pair leans the other way round, so each ear
+      // carries the tilt its opposite used to. `side` is −1 left,
+      // +1 right, and negating it is the whole flip.
+      const roll = -side * st.lean;
+      // the base is buried: the plate is shifted up its own v so its
+      // bottom third is inside the head and it can never hover
+      const lift = h * .62;
+
+      add({ type: 'plate', id, outline: st.outline,
+            w, h, r: st.r == null ? undefined : Math.min(w, h) * st.r,
+            flip: true,
+            p: a.p, n, roll, d, bevel: Math.min(d * .5, w * .4),
+            offset: [0, lift],
+            color: st.tone === 'warm' ? L.warm : L.body });
+
+      if (st.inner) {
+        // centred in the VISIBLE ear, not on the plate's own middle —
+        // the outer plate's lower third is buried in the head, so an
+        // inner pad sharing its centre sits at the base of the ear
+        add({ type: 'plate', id: id + 'Inner', outline: st.outline,
+              w: w * st.inner, h: h * st.inner,
+              r: st.r == null ? undefined : Math.min(w, h) * st.inner * st.r,
+              flip: true,
+              p: a.p, n, roll, d: d * .5, bevel: d * .2,
+              offset: [0, lift + h * (1 - st.inner) * .4], proud: d * .7,
+              color: L.warm });
+      }
+    }
+  },
+};