@pieai/swimmer-avatar-kit 0.1.0

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

@@ -0,0 +1,100 @@
+// THE HAIR — the humanoid's only, and the part that turns a head into a
+// character. The shapes are all in `ghair.js`; this file is the dice.
+//
+// The DEFAULT IS BALD, and that is deliberate rather than lazy: a cast
+// style table is exclusive, so a species that says nothing about hair
+// gets none, and only the humanoid casts real styles. A bear with a
+// ponytail is one line away and it is not one anybody wanted.
+import { buildHair, HAIR_STYLES } from '../ghair.js';
+import { HAIR_IDS, HAIR_WEIGHTS } from '../gpalette.js';
+
+export { HAIR_STYLES };
+
+export const Hair = {
+  id: 'hair', label: 'hair', order: 2,
+
+  gen: (rng, C) => ({
+    // bald unless a species asks — see the header
+    style: C.pick(rng, 'style', [['bald', 100]]),
+    // hair has its own colour table, never the body's palette
+    color: C.pick(rng, 'color', HAIR_WEIGHTS),
+    // how far the clumps stand off the head. WIDE, because flat-and-
+    // sleek against big-and-soft is most of the difference between two
+    // heads wearing the same cut.
+    vol: C.range(rng, 'vol', .7, 1.5),
+    // how many clumps: fewer and chunkier, or more and finer
+    density: C.range(rng, 'density', .8, 1.25),
+    // how far each clump wraps past its own slice — the overlap
+    width: C.range(rng, 'width', .9, 1.15),
+    // how unequal the tips are. This is what stops a hem reading as a
+    // line somebody ruled across the head.
+    jag: C.range(rng, 'jag', .6, 1.5),
+    wave: C.range(rng, 'wave', .7, 1.35),
+    part: C.range(rng, 'part', .7, 1.3),
+    // how hard an upswept style lifts. Only the styles that ask.
+    pomp: C.range(rng, 'pomp', .75, 1.35),
+    // where this head's whorl sits, nudged off the style's own spot —
+    // two heads with the same cut still comb differently
+    whorl: C.range(rng, 'whorl', -.35, .35),
+    // how long and how present the point strands are — the momiage in
+    // front of the ears, the loose fringe wisps, the flyaways
+    wisps: C.range(rng, 'wisps', .75, 1.3),
+    // ONE seed for every per-clump variation on the head. It has to be
+    // a rolled parameter rather than live randomness: hair is rebuilt
+    // on every boil frame, and anything re-rolled per frame shimmers.
+    seed: rng.r(0, 6.283),
+    // the tied-up styles
+    // Just BEHIND the ear — about a right angle off the nose. Tied
+    // further round than that the tail hangs behind the head and the
+    // whole silhouette is lost from the front, which is the only angle
+    // the sheet ever sees; tied forward of it, it covers the cheek.
+    tailAng: C.range(rng, 'tailAng', 1.45, 1.85),   // radians off the face
+    tailY: C.range(rng, 'tailY', .5, .78),          // how high it is tied
+    tailLen: C.range(rng, 'tailLen', .8, 1.9),      // × head height
+    bunAng: C.range(rng, 'bunAng', .7, 1.15),
+    bunR: C.range(rng, 'bunR', .17, .26),
+    // THE AHOGE, and it is worth a knob of its own: one strand off the
+    // crown reads as a whole personality, so it is dealt often but not
+    // to everyone.
+    ahoge: C.chance(rng, 'ahoge', .22),
+    ahogeAng: rng.r(-.5, .5),
+    ahogeDir: rng.chance(.5) ? 1 : -1,
+  }),
+
+  meta: () => ({
+    style: { label: 'cut', pick: HAIR_STYLES },
+    color: { label: 'colour', pick: HAIR_IDS },
+    vol: { label: 'volume', range: [.5, 2] },
+    wave: { label: 'wave', range: [0, 2] },
+    part: { label: 'parting', range: [0, 2] },
+    density: { label: 'clumps', range: [.6, 1.6] },
+    width: { label: 'clump width', range: [.7, 1.4] },
+    jag: { label: 'ragged tips', range: [0, 2] },
+    pomp: { label: 'sweep up', range: [0, 2] },
+    whorl: { label: 'whorl', range: [-1, 1] },
+    wisps: { label: 'wisps', range: [.3, 2] },
+    seed: { label: 'shuffle', range: [0, 6.28] },
+    tailY: { label: 'tied at', range: [.2, .8] },
+    tailLen: { label: 'tail length', range: [.4, 2.4] },
+    tailAng: { label: 'tails apart', range: [1.2, 2.6] },
+    bunR: { label: 'bun size', range: [.1, .35] },
+    ahoge: { label: 'ahoge', bool: true },
+  }),
+
+  build(add, P, L) {
+    for (const piece of buildHair(P, L)) {
+      // a bun is a ball, and the body's own solid primitive already
+      // makes those — no reason for `ghair.js` to loft a sphere
+      if (piece.ball) {
+        add({ type: 'solid', id: piece.id, color: L.hair, cast: true, finish: 'hair',
+              rx: piece.ball.r, ry: piece.ball.r * .92, rz: piece.ball.r,
+              pos: [piece.ball.pos[0], piece.ball.pos[1] + L.cy, piece.ball.pos[2]] });
+        continue;
+      }
+      // hair is a real volume standing off the head, not a feature lying
+      // flush on it, so unlike every other face part it CASTS
+      add({ type: 'mesh', id: piece.id, mesh: piece.mesh,
+            pos: [0, L.cy, 0], color: L.hair, cast: true, finish: 'hair' });
+    }
+  },
+};

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

@@ -0,0 +1,163 @@
+// HEADWEAR — the last of the extras and the loudest, because unlike a
+// mark or a pair of glasses a hat changes the SILHOUETTE, which is the
+// only thing that survives at sheet scale.
+//
+// Its relationship with the HAIR splits the catalogue in two, and
+// getting that wrong is what a first pass does:
+//
+//   HUG    a beanie or a cap is PULLED ON, and a real one compresses
+//          the hair under it — it wants the head's own radius plus a
+//          little, and the hair poking out below the rim is the read.
+//          Sized to clear a big soft cut instead, it stands a whole
+//          hair's volume off the skull at every height, including
+//          down at the ears where there is no hair at all, and comes
+//          out as a bowl balanced on the head.
+//   PERCH  a headband, a bow, a flower, a crown — these sit ON TOP of
+//          whatever is up there and genuinely need `L.hairTop`, which
+//          the hair publishes via `hairOuter`. Same edge as the eyes
+//          publishing `eyeProud` for the spectacles.
+//
+// The vocabulary is deliberately three shapes of thing:
+//
+//   DOME   a sphere cut short (`dome`) — a beanie, a cap's crown
+//   BAND   a sphere ZONE, cut at both ends (`domeFrom`) — a brim, a
+//          cuff, a headband. This is what `domeFrom` was added for.
+//   PLATE  the flat stuff — a bow, a flower, a crown's points
+//
+// Colour comes off the character's own palette (`warm`, `lite`, `ink`) rather
+// than a new table. A hat in an unrelated colour is a different
+// object; a hat in the family's colours is an accessory.
+const STYLE = {
+  none:    null,
+  // pulled down over the crown, with a rolled cuff at the rim
+  beanie:  { dome: .42, cuff: [.38, .47], hug: 1.09, bare: true },
+  // a thin zone lying round the head: the headband
+  band:    { band: [.26, .33], hug: 1.05, bare: true },
+  // points standing round the crown
+  crown:   { points: 6, grow: 1.03 },
+  // one bow on the side of the head
+  bow:     { bow: true, grow: 1.02 },
+  // and one flower, same place, quieter
+  flower:  { bloom: true, grow: 1.02 },
+};
+
+export const HAT_STYLES = Object.keys(STYLE);
+
+/**
+ * Does this hat go on a BARE head?
+ *
+ * A beanie and a headband are pulled ON, and there is no arrangement of
+ * sizes that lets one share a skull with a big soft haircut: sized to
+ * clear the hair it is a bowl balanced on the head, sized to the skull
+ * it vanishes underneath, and squashing the hair under its rim — which
+ * was built, and worked — still leaves the two fighting for the same
+ * few millimetres at every seed. So they are simply worn on a bare
+ * head, which is a real look and needs no negotiation at all.
+ *
+ * `ghair.js` reads this off the LAYOUT and builds nothing. The hats
+ * that PERCH (a bow, a flower, a crown) sit on top of the hair as
+ * before and are not listed here.
+ */
+export function hatBare(P) {
+  return !!STYLE[P.hat?.style]?.bare;
+}
+
+export const Hat = {
+  // after the hair, whose outer radius it needs
+  id: 'hat', label: 'hat', order: 3,
+
+  // Rare. A hat is a strong statement and the sheet can carry a few.
+  gen: (rng, C) => ({
+    // NOBODY wears a hat unless a species asks — see the header. A bear
+    // in a beanie is one line away and it is not one anybody wanted.
+    style: C.pick(rng, 'style', [['none', 100]]),
+    // WHICH accessory colour. The layout turns this into a hex that is
+    // guaranteed to stand clear of the skin and the hair.
+    accIx: rng.ri(0, 9),
+    size: C.range(rng, 'size', .94, 1.12),
+    // which side a bow or a flower sits on, and how far round
+    side: rng.chance(.5) ? 1 : -1,
+    lean: C.range(rng, 'lean', .7, 1.15),
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: HAT_STYLES },
+    accIx: { label: 'colour', range: [0, 9] },
+    size: { label: 'size', range: [.8, 1.3] },
+    lean: { label: 'placement', range: [.4, 1.5] },
+  }),
+
+  build(add, P, L) {
+    const T = P.hat;
+    const st = STYLE[T.style];
+    if (!st) return;
+    const col = L.acc;
+    // An accessory is NOT made of the character: left to inherit the shell's
+    // finish a beanie on a humanoid is poured in SKIN. `acc` is the
+    // soft plastic they all wear, and its sheen is self-coloured —
+    // rubber's white one washed a brick red out to pale pink.
+    const fin = 'acc';
+    // HUG the head and let the hair squash under it, or PERCH on top
+    // of whatever the hair is doing — see the header
+    const k = (st.hug ?? (L.hairTop * st.grow)) * T.size;
+    const rx = L.rx * k, ry = L.ry * k, rz = L.rz * k;
+    const solid = (id, extra) => add({
+      type: 'solid', id, rx, ry, rz, exp: L.exp, cast: true, finish: fin,
+      pos: [0, L.cy, 0], color: col, ...extra });
+
+    if (st.dome) {
+      solid('hat', { dome: st.dome });
+      // the CUFF: a zone, slightly fatter than the crown it rolls
+      // under, which is the whole read of a knitted brim
+      if (st.cuff)
+        add({ type: 'solid', id: 'hatCuff', exp: L.exp, cast: true,
+              rx: rx * 1.045, ry: ry * 1.03, rz: rz * 1.045,
+              dome: st.cuff[1], domeFrom: st.cuff[0], finish: fin,
+              pos: [0, L.cy, 0], color: col });
+    }
+    if (st.band)
+      add({ type: 'solid', id: 'hat', exp: L.exp, cast: true,
+            rx, ry, rz, dome: st.band[1], domeFrom: st.band[0], finish: fin,
+            pos: [0, L.cy, 0], color: col });
+
+    // THE CROWN — points standing round the top on `L.top`, the same
+    // anchor the ears use
+    if (st.points) {
+      for (let i = 0; i < st.points; i++) {
+        const t = (i / (st.points - 1) - .5) * 1.5;
+        const a = L.top(t);
+        const u = L.s * .16 * T.size;
+        add({ type: 'plate', id: 'hatPoint' + i, outline: 'tri', flip: true,
+              w: u * .5, h: u, p: a.p, n: [a.n[0] * .5, a.n[1] * .5, 1],
+              roll: -t * .5, d: u * .35, bevel: u * .16,
+              offset: [0, u * .35], color: col, cast: true, finish: fin });
+      }
+    }
+
+    // A BOW or a FLOWER, off to one side of the crown — the two extras
+    // that are placed rather than worn
+    if (st.bow || st.bloom) {
+      const a = L.top(T.side * T.lean * .62);
+      const u = L.s * (st.bow ? .2 : .17) * T.size;
+      const n = [a.n[0] * .6, a.n[1] * .6, .8];
+      if (st.bloom) {
+        add({ type: 'plate', id: 'hatBloom', outline: 'flower', petals: 5, amp: .34,
+              w: u, h: u, p: a.p, n, d: u * .3, bevel: u * .14,
+              proud: u * .1, color: col, cast: true, finish: fin });
+        add({ type: 'plate', id: 'hatBloomEye', outline: 'ellipse',
+              w: u * .3, h: u * .3, p: a.p, n, d: u * .2, bevel: u * .09,
+              proud: u * .34, color: L.sclera, finish: fin });
+        return;
+      }
+      // two loops and a knot: the cheapest bow that reads as one
+      for (const s of [-1, 1])
+        add({ type: 'plate', id: 'hatBow' + (s < 0 ? 'L' : 'R'), outline: 'tri',
+              w: u * .5, h: u * .8, p: a.p, n, roll: s * Math.PI / 2,
+              offset: [s * u * .62, 0], d: u * .3, bevel: u * .13,
+              proud: u * .08, color: col, cast: true, finish: fin });
+      add({ type: 'plate', id: 'hatKnot', outline: 'ellipse',
+            w: u * .26, h: u * .26, p: a.p, n,
+            d: u * .3, bevel: u * .13, proud: u * .2, color: col, finish: fin });
+    }
+  },
+};

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

@@ -0,0 +1,33 @@
+// The registry. Order is build order, and the only hard requirement is
+// that `body` runs first — the layout it establishes is what every
+// face part places against.
+//
+// Adding a face part = one file here + one line below. It never
+// touches the rig, the shapes it can use are in `gshape.js`, and it
+// places itself through `L.at`.
+import { Body } from './body.js';
+import { Frame } from './frame.js';
+import { Crest } from './crest.js';
+import { Hair } from './hair.js';
+import { Eyes } from './eyes.js';
+import { Brows } from './brows.js';
+import { Nose } from './nose.js';
+import { Mouth } from './mouth.js';
+import { Blush } from './blush.js';
+// THE EXTRAS. Everything above is what a character IS; these are what it is
+// WEARING or what has happened to it, and all three are dealt rare on
+// purpose — an accessory on every character is not a character, it is the
+// house style.
+import { Specs } from './specs.js';
+import { Hat } from './hat.js';
+import { Mark } from './mark.js';
+
+// There WAS a `muzzle` part here — a second storey on the lower face
+// in patch, lump and snout. All three are gone. The flat patch read as
+// a white block behind the mouth, and the two solid ones pushed the
+// face out into a snout that fought the head's own silhouette. What
+// carries a species turned out to be the EARS and the eye patches, not
+// a second lump of geometry.
+export const GPARTS = [Body, Frame, Crest, Hair, Hat, Eyes, Brows, Specs, Nose, Mouth,
+                       Blush, Mark];
+export const GPART_BY_ID = Object.fromEntries(GPARTS.map(p => [p.id, p]));

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

@@ -0,0 +1,139 @@
+// MARKS — the small stuff painted or stuck on a face: a scar, a
+// plaster, freckles, a beauty spot, ink tears. The drawn generator has
+// had these since the beginning (`src/parts/extras.js`) and they do the
+// same job here: they are the difference between a mascot and a
+// character, and they cost almost nothing.
+//
+// EVERY ONE IS ASYMMETRIC OR SCATTERED, on purpose. A mark mirrored
+// neatly onto both cheeks stops reading as something that HAPPENED to
+// this character and starts reading as decoration that came out of the mould
+// — which is the one thing a scar must not do. So a scar takes a side,
+// freckles are a scatter, and only `tears` is a pair (it is a face
+// doing something, not a mark).
+//
+// Marks lie FLAT: barely proud, no bevel to speak of. They are the one
+// family in the lab that is painted rather than moulded, and a mark
+// with a fat rounded rim reads as a lump of vinyl stuck on a cheek.
+const STYLE = {
+  none:     null,
+  // one stroke across a brow, and a second short one crossing it
+  scar:     { kind: 'scar', ticks: 1 },
+  // the stitched version: a stroke with rungs
+  sutures:  { kind: 'scar', ticks: 4 },
+  // a plaster: a pad with a lighter middle
+  plaster:  { kind: 'plaster' },
+  // a scatter across the nose and both cheeks
+  freckles: { kind: 'dots', n: 7, size: .09, spread: 1 },
+  // one small dot, high on a cheek
+  spot:     { kind: 'dots', n: 1, size: .13, spread: 0 },
+  // two ink streaks running down from the eyes — the drawn rig's
+  // black tears, and the only mark here that is a pair
+  tears:    { kind: 'tears' },
+};
+
+export const MARK_STYLES = Object.keys(STYLE);
+
+export const Mark = {
+  // LAST. It goes over everything, including the blush.
+  id: 'mark', label: 'marks', order: 6,
+
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['none', 82], ['freckles', 5], ['scar', 3],
+                                 ['plaster', 3], ['spot', 3], ['sutures', 2],
+                                 ['tears', 2]]),
+    side: rng.chance(.5) ? 1 : -1,
+    size: C.range(rng, 'size', .85, 1.2),
+    roll: rng.r(-.5, .5),
+    // a scar over the brow reads as a fight; the same scar on the
+    // cheek reads as a scratch. Worth having both.
+    high: rng.chance(.55),
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: MARK_STYLES },
+    size: { label: 'size', range: [.5, 1.8] },
+    roll: { label: 'tilt', range: [-1.2, 1.2] },
+    high: { label: 'over the brow', bool: true },
+  }),
+
+  build(add, P, L) {
+    const M = P.mark;
+    const st = STYLE[M.style];
+    if (!st) return;
+    const r = L.eyeR * M.size;
+    const sd = M.side;
+    // a plaster is not made of skin either — see `acc` in gmedia.js
+    const fin = 'acc';
+
+    // ---- SCAR / SUTURES ------------------------------------------------
+    if (st.kind === 'scar') {
+      const ay = M.high ? L.eyeY + .34 : L.eyeY - .3;
+      const a = L.onFace(sd * (L.eyeX + .06), ay, { halfW: r * .5 });
+      const len = r * .58, tube = r * .055;
+      add({ type: 'plate', id: 'markScar', outline: 'band', curve: 'line',
+            w: len, h: tube, tube,
+            p: a.p, n: a.n, roll: M.roll + sd * .5,
+            d: tube * 1.2, bevel: tube * .5, proud: tube * .3, color: L.ink });
+      // the rungs. One is a crossed scar; four is a stitched seam.
+      for (let i = 0; i < st.ticks; i++) {
+        const t = st.ticks === 1 ? 0 : (i / (st.ticks - 1) - .5) * 1.3;
+        add({ type: 'plate', id: 'markTick' + i, outline: 'band', curve: 'line',
+              w: tube * 3.2, h: tube * .8, tube: tube * .8,
+              p: a.p, n: a.n, roll: M.roll + sd * .5 + Math.PI / 2,
+              offset: [t * len * .78, 0],
+              d: tube, bevel: tube * .4, proud: tube * .3, color: L.ink });
+      }
+      return;
+    }
+
+    // ---- PLASTER -------------------------------------------------------
+    if (st.kind === 'plaster') {
+      const a = L.onFace(sd * (L.eyeX + .1), L.eyeY - .34, { halfW: r * .62 });
+      const w = r * .62, h = r * .26;
+      add({ type: 'plate', id: 'markPlaster', outline: 'rect',
+            w, h, r: h * .5,
+            p: a.p, n: a.n, roll: M.roll + sd * .38,
+            d: r * .07, bevel: r * .035, proud: r * .03, color: L.sclera, finish: fin });
+      // the pad: the darker middle every plaster has
+      add({ type: 'plate', id: 'markPad', outline: 'rect',
+            w: w * .38, h: h * .62, r: h * .2,
+            p: a.p, n: a.n, roll: M.roll + sd * .38,
+            d: r * .05, bevel: r * .02, proud: r * .055, color: L.warm, finish: fin });
+      return;
+    }
+
+    // ---- DOTS: freckles, or one beauty spot ----------------------------
+    if (st.kind === 'dots') {
+      const rr = r * st.size;
+      for (let i = 0; i < st.n; i++) {
+        // A FIXED scatter, not a rolled one: marks are rebuilt every
+        // boil frame, so anything random here would crawl across the
+        // face. Two harmonics give a spread that does not read as a row.
+        const u = st.n === 1 ? 0 : i / (st.n - 1) * 2 - 1;
+        const ax = st.spread
+          ? u * (L.eyeX + .34) + Math.sin(i * 2.4) * .06
+          : sd * (L.eyeX + .3);
+        const ay = st.spread
+          ? L.eyeY - .3 + Math.sin(i * 3.9) * .1
+          : L.eyeY - .16;
+        const a = L.onFace(ax, ay, { halfW: rr });
+        add({ type: 'plate', id: 'markDot' + i, outline: 'ellipse',
+              w: rr, h: rr, p: a.p, n: a.n,
+              d: rr * .5, bevel: rr * .25, proud: rr * .1,
+              color: st.n === 1 ? L.ink : L.warm });
+      }
+      return;
+    }
+
+    // ---- TEARS ---------------------------------------------------------
+    // straight down from under each eye, and long: a short one reads as
+    // a smudge rather than as something running
+    for (const [id, side] of [['markTearL', -1], ['markTearR', 1]]) {
+      const a = L.onFace(side * L.eyeX, L.eyeY - .34, { halfW: r * .09 });
+      add({ type: 'plate', id, outline: 'band', curve: 'line',
+            w: r * .5, h: r * .085, tube: r * .085,
+            p: a.p, n: a.n, roll: Math.PI / 2,
+            d: r * .06, bevel: r * .03, proud: r * .03, color: L.ink });
+    }
+  },
+};

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

@@ -0,0 +1,170 @@
+// THE MOUTH — two families now, and the split is the whole reference:
+//
+//   LINES — a stroke along a centreline (smile, cat, zig…). Small,
+//   ink, the pastel-egg register. These are what we had.
+//
+//   MAWS — a CONSTRUCTED mouth: an ink outline with a dark maroon
+//   interior behind it, and optionally a white strip of teeth hanging
+//   from the top lip and a warm tongue rising from the bottom. This is
+//   the Ferriz read — the shark grin, the zombie teeth, the huge
+//   open holler — and it is allowed to be ENORMOUS: half the face and
+//   more. The earlier small-and-black rule was for the line family,
+//   and the maws are exactly the exception it was waiting for.
+//
+// A maw is stacked plates, nothing else — the same trick as a pupil
+// on a white. Interior parked behind the outline, furniture parked in
+// front of the interior.
+const STYLE = {
+  none:  null,
+  // -- lines: small, ink -------------------------------------------
+  smile: { line: true, curve: 'arc',  sag: .42, wf: 1, tf: .15 },
+  frown: { line: true, curve: 'arc',  sag: -.4, wf: .9, tf: .15 },
+  flat:  { line: true, curve: 'line', sag: 0,   wf: .8, tf: .14 },
+  cat:   { line: true, curve: 'wave', sag: .34, wf: 1.05, tf: .14 },
+  zig:   { line: true, curve: 'zig',  sag: .34, wf: 1, tf: .12 },
+  // -- maws: big, built --------------------------------------------
+  // mul is the licence to go big: it scales the whole construction
+  // `mul` is the licence to go big — but it was written when the eye
+  // unit was half this size, and everything here scales off that unit.
+  // At 2.3 a maw came out spanning the whole face.
+  open:   { maw: true, wf: 1, hf: .78, mul: 1.42 },
+  holler: { maw: true, wf: .8, hf: 1.05, mul: 1.45 },      // taller than wide
+  grin:   { maw: true, wf: 1.3, hf: .52, mul: 1.5, allTeeth: true },
+};
+
+export const MOUTH_STYLES = Object.keys(STYLE);
+
+/** how far the mouth reaches above its own centre, in units of
+ *  `L.eyeR`. The layout asks, the same way it asks `eyeReach`, so a
+ *  maw two eyes tall still gets pushed clear of the eyes. */
+export function mouthReach(P) {
+  const st = STYLE[P.mouth.style];
+  if (!st) return 0;
+  return (st.line ? st.tf * 1.4 : st.hf) * (st.mul ?? 1) * P.mouth.size;
+}
+
+/** and sideways: the mouth's half-width in units of `L.eyeR`. A maw on
+ *  a narrow chin is the layout's problem in BOTH axes. */
+export function mouthSpan(P) {
+  const st = STYLE[P.mouth.style];
+  if (!st) return 0;
+  return (st.wf ?? 1) * (st.mul ?? 1) * P.mouth.size;
+}
+
+export const Mouth = {
+  id: 'mouth', label: 'mouth', order: 5,
+
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['open', 18], ['smile', 16], ['grin', 12], ['cat', 12],
+                                 ['flat', 10], ['holler', 9], ['zig', 7], ['frown', 6],
+                                 ['none', 10]]),
+    // close under the eyes: the face reads as one band of features,
+    // not a pair of eyes with a mouth adrift somewhere below them
+    y: C.range(rng, 'y', -.2, -.02),        // a wish — the layout may push it down
+    size: C.range(rng, 'size', .5, .78),       // × eye size, × the style's own mul
+    proud: C.range(rng, 'proud', .08, .2),
+    teeth: C.chance(rng, 'teeth', .6),      // a maw's white strip
+    tongue: C.chance(rng, 'tongue', .45),    // and its warm tongue
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: MOUTH_STYLES },
+    y: { label: 'height', range: [-.8, .1] },
+    size: { label: 'size', range: [.4, 2] },
+    proud: { label: 'relief', range: [0, .5] },
+    teeth: { label: 'teeth', bool: true },
+    tongue: { label: 'tongue', bool: true },
+  }),
+
+  build(add, P, L) {
+    const M = P.mouth;
+    const st = STYLE[M.style];
+    if (!st) return;
+    const r = L.eyeR * M.size * (st.mul ?? 1) * L.mouthFit;
+    const a = L.at(0, L.mouthY);
+    const base = r * M.proud * (st.line ? 1 : .4);
+
+    if (st.line) {
+      add({ type: 'plate', id: 'mouth', 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,
+            d: r * .22, bevel: r * st.tf * .5,
+            proud: base, color: L.ink });
+      // ONE white fang hanging off the line, point down and a little
+      // off-centre — the single tooth is a whole personality
+      if (M.teeth && M.tongue) {
+        add({ type: 'plate', id: 'mouthFang', outline: 'tri',
+              w: r * .16, h: r * .22,
+              p: a.p, n: a.n,
+              d: r * .18, bevel: r * .05,
+              proud: base + r * .05, offset: [r * st.wf * .38, -r * .2],
+              color: L.sclera });
+      }
+      return;
+    }
+
+    // ---- a maw ------------------------------------------------------
+    const w = r * st.wf, h = r * st.hf, d = r * .16;
+    const corner = Math.min(w, h) * .8;
+
+    // the outline: the drawn lip line around everything
+    add({ type: 'plate', id: 'mouth', outline: 'rect',
+          w, h, r: corner,
+          p: a.p, n: a.n, d, bevel: d * .5,
+          proud: base, color: L.ink });
+
+    // the interior, behind the lip line
+    add({ type: 'plate', id: 'mouthMaw', outline: 'rect',
+          w: w * .84, h: h * .8, r: corner * .8,
+          p: a.p, n: a.n, d: d * .8, bevel: d * .3,
+          proud: base + d * .5, color: st.allTeeth ? L.sclera : L.maw });
+
+    if (st.allTeeth) {
+      // the grin: the interior IS the teeth, split by ink bars
+      const bars = w > h * 1.8 ? 3 : 2;
+      for (let i = 0; i < bars; i++) {
+        const fx = (i + 1) / (bars + 1) * 2 - 1;
+        add({ type: 'plate', id: `mouthBar${i}`, outline: 'rect',
+              w: w * .035, h: h * .68, r: w * .03,
+              p: a.p, n: a.n, d: d * .5, bevel: d * .12,
+              proud: base + d * .95, offset: [fx * w * .8, 0],
+              color: L.ink });
+      }
+      // and one horizontal split, upper teeth from lower
+      add({ type: 'plate', id: 'mouthSplit', outline: 'rect',
+            w: w * .8, h: h * .05, r: h * .04,
+            p: a.p, n: a.n, d: d * .5, bevel: d * .12,
+            proud: base + d * .95, offset: [0, -h * .06],
+            color: L.ink });
+      return;
+    }
+
+    if (M.teeth) {
+      // Hanging FROM the top lip, and SPLIT. One white slab in a dark
+      // mouth reads as a sticking plaster however it is placed — what
+      // makes it teeth is the divisions, which is exactly why `grin`
+      // was the best-reading mouth on the sheet. Same trick here.
+      const tw = w * .62, th = h * .3, ty = h * .8 - th;
+      add({ type: 'plate', id: 'mouthTeeth', outline: 'rect',
+            w: tw, h: th, r: th * .16,
+            p: a.p, n: a.n, d: d * .6, bevel: d * .15,
+            proud: base + d * .95, offset: [0, ty],
+            color: L.sclera });
+      for (let i = 0; i < 3; i++) {
+        add({ type: 'plate', id: `mouthTooth${i}`, outline: 'rect',
+              w: tw * .035, h: th * .82, r: tw * .03,
+              p: a.p, n: a.n, d: d * .4, bevel: d * .1,
+              proud: base + d * 1.15, offset: [(i - 1) * tw * .46, ty],
+              color: L.ink });
+      }
+    }
+    if (M.tongue) {
+      add({ type: 'plate', id: 'mouthTongue', outline: 'ellipse',
+            w: w * .42, h: h * .42,
+            p: a.p, n: a.n, d: d * .8, bevel: d * .3,
+            proud: base + d * .8, offset: [0, -h * .52],
+            color: L.warm });
+    }
+  },
+};

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

@@ -0,0 +1,63 @@
+// THE NOSE. Small, central, and the one feature that is sometimes a
+// real lump rather than a plate: a button nose wants to be a ball,
+// because half of what sells it is the highlight sliding around a
+// curve the flat features do not have.
+const STYLE = {
+  none:   null,
+  dot:    { type: 'plate', outline: 'ellipse', wf: .3,  hf: .3 },
+  button: { type: 'solid', wf: .42, hf: .42, sink: .45 },
+  snout:  { type: 'plate', outline: 'rect', wf: .8, hf: .38 },
+  beak:   { type: 'plate', outline: 'tri', wf: .46, hf: .42, flip: true },
+  cat:    { type: 'plate', outline: 'tri', wf: .42, hf: .3, flip: true },
+  heart:  { type: 'plate', outline: 'heart', wf: .38, hf: .34 },
+};
+
+export const NOSE_STYLES = Object.keys(STYLE);
+
+export const Nose = {
+  id: 'nose', label: 'nose', order: 3,
+
+  // Most characters have NO nose. Two eyes and a mouth is the whole face in
+  // the reference, and a nose on every one of them turns a sheet of
+  // characters into a sheet of the same character.
+  gen: (rng, C) => ({
+    style: C.pick(rng, 'style', [['none', 91], ['dot', 3], ['button', 2], ['snout', 1],
+                                 ['cat', 1], ['beak', 1], ['heart', 1]]),
+    bias: C.range(rng, 'bias', -.04, .04),     // off the midpoint the layout publishes
+    size: C.range(rng, 'size', .42, .66),      // × eye size
+    warm: C.chance(rng, 'warm', .35),      // in the palette's warm colour, not ink
+  }),
+
+  meta: () => ({
+    style: { label: 'style', pick: NOSE_STYLES },
+    bias: { label: 'height', range: [-.2, .2] },
+    size: { label: 'size', range: [.3, 1.8] },
+    warm: { label: 'warm tone', bool: true },
+  }),
+
+  build(add, P, L) {
+    const N = P.nose;
+    const st = STYLE[N.style];
+    if (!st) return;
+    // the layout's midpoint between eyes and mouth: a nose cannot
+    // collide with a mouth however either of them is dragged
+    const r = L.eyeR * N.size;
+    const a = L.at(0, L.noseY + N.bias);
+    const color = N.warm ? L.warm : L.ink;
+
+    const base = 0;
+
+    if (st.type === 'solid') {
+      // sunk most of the way in, so it reads as a bump on the face and
+      // not a bead balanced on it
+      add({ type: 'solid', id: 'nose', rx: r * st.wf, ry: r * st.hf, rz: r * st.wf,
+            p: a.p, n: a.n, proud: base - r * st.wf * st.sink, color });
+      return;
+    }
+    add({ type: 'plate', id: 'nose', outline: st.outline, flip: st.flip,
+          w: r * st.wf, h: r * st.hf,
+          p: a.p, n: a.n,
+          d: r * .3, bevel: Math.min(r * .18, r * st.hf * .45),
+          proud: base + r * .12, color });
+  },
+};