@codincod/ornament 0.0.0-stage → 0.1.0

package/src/paint/specimen.ts

@@ -0,0 +1,300 @@
+/**
+ * One animal, alone, with the water held close enough to see it.
+ *
+ * A sea is drawn to be a sea: an animal in it is a few percent of the box
+ * across, because that is what a fish at eight metres actually looks like and
+ * `sizes.ts` is not going to lie about it for the sake of a nice picture. That
+ * is right for a background and useless for a plate, and a plate is what finds
+ * drawing faults. At the weight ornament ships at, a wreck that is upside down
+ * and a wreck that is working look identical.
+ *
+ * So a specimen is not a bigger animal. It is the same animal in the same
+ * water, with the camera brought in until it fills the frame, and `look` is
+ * where to point it. Nothing about the drawing changes, which is the whole
+ * value: a fault seen here is a fault the sea has.
+ *
+ * ## Why the water is bigger than the box it is shown in
+ *
+ * Because the animal has to have somewhere to be. A fish given a box the size
+ * of the view spends its life against an edge it can feel; given room, it swims
+ * about its business and the camera follows. What is shown is a window on a
+ * water that carries on past it.
+ */
+import type { Presence } from "../biome.ts"
+import { createCephalopods } from "../cephalopods.ts"
+import { createJellies, type JellyKind } from "../jellies.ts"
+import { createPuffers, type Puffers } from "../puffers.ts"
+import { createSeabed } from "../seabed.ts"
+import { createShoal, type Kind as FishKind } from "../shoal.ts"
+import { createWalkers } from "../walkers.ts"
+import { paintInklings, paintJellies, paintPuffers, paintShoal, paintWalkers } from "./life.ts"
+import { Pen } from "./pen.ts"
+import type { Box } from "./sky.ts"
+
+/**
+ * The ones the design system shows, one from each family that stays in frame.
+ *
+ * The animals that cross rather than live here are deliberately not among
+ * them. A shark keeps a rest between crossings measured in minutes, so a plate
+ * of one is a plate of empty water for most of the time somebody is looking at
+ * it, and a shark wound on until it is there is a shark on a treadmill.
+ */
+export type Kind = "crab" | "jellyfish" | "octopus" | "pufferfish" | "swordfish"
+
+export const KINDS: readonly Kind[] = ["swordfish", "jellyfish", "octopus", "crab", "pufferfish"]
+
+/** What each one is, for a page that has to say. */
+export const GLOSS: Readonly<Record<Kind, string>> = {
+  crab: "It goes where it decides to go, and the current has no say in it.",
+  jellyfish: "A moon jelly, which gets a second push out of its own refill.",
+  octopus: "The only thing down there with a repertoire rather than a rhythm.",
+  pufferfish: "It is a fish until something crowds it, and then it is a ball of spines.",
+  swordfish: "A billfish over a reef is a visitor from the water beyond it.",
+}
+
+/**
+ * How much bigger the water is than the window on it.
+ *
+ * Enough that the animal is never against a wall, and no more: everything in
+ * this water is stepped whether it is in the frame or not, so room is paid for
+ * every frame.
+ */
+const ROOM = 5
+
+/** How many numbers a plate's frame is given. One animal is not a sea. */
+const BLOCK = 1 << 16
+
+/** How much of the window the animal is meant to take up. */
+const FILLS = 0.72
+
+/**
+ * How far a drawing actually reaches, against the size the animal reports.
+ *
+ * An animal's size is the size of the animal, and a drawing of one is bigger
+ * than that in every case where something trails: an octopus is measured across
+ * its head and drawn with two head-lengths of arms under it, a crab is measured
+ * across its shell and stands on legs half again as wide, a pufferfish is
+ * measured deflated and spends its interesting seconds twice that with its
+ * spines out, and a moon jelly is a bell with a curtain hanging off it. `drop`
+ * is the other half of the same fact, because none of it trails evenly: what
+ * hangs, hangs downwards, so the middle of the drawing is below the middle of
+ * the animal.
+ *
+ * It is only ever a plate's business. A sea draws these at the size they are
+ * and never has to frame one.
+ */
+const REACH: Readonly<Record<Kind, { drop: number; wide: number }>> = {
+  crab: { drop: 0.06, wide: 2.05 },
+  jellyfish: { drop: 0.34, wide: 1.6 },
+  octopus: { drop: 0.28, wide: 1.9 },
+  pufferfish: { drop: 0, wide: 2.15 },
+  swordfish: { drop: 0, wide: 1.15 },
+}
+
+/**
+ * What crowds the pufferfish, and how often.
+ *
+ * A pufferfish at rest is a slightly lumpy fish sculling about, and the drawing
+ * worth judging is the other one. In a sea the thing that comes near is a shark
+ * or a hull; on a plate it is whoever is looking, so that is what this is:
+ * something several times the animal's size, with its whole attention on it,
+ * leaning in for a few seconds out of every `every` and going away again.
+ *
+ * It is the one thing on a plate that is not in the water. It is there because
+ * the drawing this plate exists to show is the ball of spines, and the animal
+ * will not make one to order: it swells at what the water is doing, and a plate
+ * with nothing in it is a plate of water doing nothing.
+ */
+const LOOKING = { every: 24, menace: 1, near: 3, size: 3 }
+
+/** How light it is on a plate. */
+const DAYLIGHT = 1
+
+/** How many numbers stand in front of a frame's count; see `frame.ts`. */
+const HEAD = 6
+
+export interface PlateOptions {
+  height: number
+  seed?: number
+  width: number
+}
+
+export interface Plate {
+  /** The window's own size, which is not the water's. */
+  readonly box: Box
+  readonly geometry: Float32Array
+  /** Where to point the camera, and how far in. */
+  look(): { scale: number; x: number; y: number }
+  over(): number
+  step(seconds: number): void
+  wind(seconds: number): void
+}
+
+/**
+ * A plate of one animal.
+ *
+ * Everything it does not need is left out rather than made and ignored. A crab
+ * and an octopus need a floor, because neither of them is ever off it. Nothing
+ * else here has a bed at all, and a jellyfish in open water is a jellyfish.
+ */
+export function createPlate(kind: Kind, options: PlateOptions): Plate {
+  const box = { height: options.height, width: options.width }
+  const water = { height: box.height * ROOM, width: box.width * ROOM }
+  const seed = options.seed ?? 1
+  const geometry = new Float32Array(BLOCK)
+
+  const grounded = kind === "crab" || kind === "octopus" || kind === "pufferfish"
+  const seabed = grounded ? createSeabed({ ...water, cliffs: 0, ranges: 1, seed, stones: 0 }) : null
+
+  const shoal =
+    kind === "swordfish"
+      ? createShoal({
+          count: 1,
+          cruise: 0.5,
+          height: water.height,
+          seed,
+          species: { swordfish: 1 } as Partial<Record<FishKind, number>>,
+          width: water.width,
+        })
+      : null
+
+  const jellies =
+    kind === "jellyfish"
+      ? createJellies({
+          count: 1,
+          height: water.height,
+          kinds: ["moon"] as readonly JellyKind[],
+          seed,
+          width: water.width,
+        })
+      : null
+
+  const inklings =
+    kind === "octopus" && seabed
+      ? createCephalopods({
+          floor: seabed.floorAt,
+          height: water.height,
+          octopuses: 1,
+          seed,
+          squids: 0,
+          width: water.width,
+        })
+      : null
+
+  let watched = 0
+
+  const looking = (): readonly Presence[] => {
+    const one = puffers?.puffers[0]
+    if (!one || watched % LOOKING.every > LOOKING.near) return []
+    return [
+      {
+        depth: one.depth,
+        menace: LOOKING.menace,
+        size: one.size * LOOKING.size,
+        x: one.x,
+        y: one.y,
+      },
+    ]
+  }
+
+  const puffers: Puffers | null =
+    kind === "pufferfish" && seabed
+      ? createPuffers({
+          about: looking,
+          count: 1,
+          floor: seabed.floorAt,
+          height: water.height,
+          seed,
+          width: water.width,
+        })
+      : null
+
+  const walkers =
+    kind === "crab" && seabed
+      ? createWalkers({
+          crabs: 1,
+          floor: seabed.floorAt,
+          seed,
+          starfish: 0,
+          width: water.width,
+        })
+      : null
+
+  /**
+   * Where the animal is, kept from the last frame it was in.
+   *
+   * A camera that snapped back to the middle of the water whenever the animal
+   * was between two states would be a camera nobody could watch. The last known
+   * place is a better answer than the middle, and it is always nearly right.
+   */
+  let held = { x: water.width / 2, y: water.height / 2 }
+  let across = box.width / 6
+
+  const find = () => {
+    const one =
+      shoal?.fish[0] ??
+      jellies?.jellies[0] ??
+      inklings?.octopuses[0] ??
+      puffers?.puffers[0] ??
+      walkers?.walkers[0]
+    if (!one) return
+
+    held = { x: one.x, y: one.y }
+    if (one.size > 0) across = one.size
+  }
+
+  return {
+    box,
+
+    geometry,
+
+    look() {
+      find()
+      const reach = REACH[kind]
+      const drawn = Math.max(1, across * reach.wide)
+      return {
+        scale: (Math.min(box.height, box.width) * FILLS) / drawn,
+        x: held.x,
+        y: held.y + across * reach.drop,
+      }
+    },
+
+    over(): number {
+      // The same six numbers a sea puts in front of its frame, so one reader
+      // walks either. A plate is not held by anybody: it is a drawing being
+      // looked at, and a drawing that wandered would be a drawing on a boat.
+      geometry[0] = 0
+      geometry[1] = 0
+      geometry[2] = 0
+      geometry[3] = 1
+      geometry[4] = 0
+      geometry[5] = DAYLIGHT
+
+      const pen = new Pen(geometry, HEAD)
+      if (shoal) paintShoal(pen, shoal)
+      // A plate is looked at rather than glanced past, so it is drawn in full
+      // daylight whatever the hour: everything in this water is the theme's own
+      // ink either way, and what the hour changes is a wash over the top, which
+      // on a plate is something to squint through.
+      if (jellies) paintJellies(pen, jellies, DAYLIGHT)
+      if (inklings) paintInklings(pen, inklings)
+      if (puffers) paintPuffers(pen, puffers)
+      if (walkers) paintWalkers(pen, walkers)
+      return pen.close()
+    },
+
+    step(seconds: number): void {
+      shoal?.step(seconds, null, null)
+      jellies?.step(seconds, null)
+      inklings?.step(seconds, null)
+      watched += seconds
+      puffers?.step(seconds)
+      walkers?.step(seconds)
+    },
+
+    wind(seconds: number): void {
+      const step = 1 / 10
+      for (let at = 0; at < Math.round(Math.max(0, seconds) / step); at++) this.step(step)
+    },
+  }
+}

package/src/paint/trace.ts

@@ -0,0 +1,164 @@
+/**
+ * A drawing, walked.
+ *
+ * The ornament writes its animals and its wreckage as paths, because that is
+ * what a browser and Qt both take: a string of moves and curves. This renderer
+ * takes triangles, so somewhere between the two the curves have to become
+ * points, and here is the cheapest place for it to happen. The alternative is a
+ * path parser on the other side of the wire and a string squeezed through an
+ * array of floats to reach it.
+ *
+ * Absolute commands only, and only the four the ornament writes: a move, a
+ * line, a cubic and a quadratic, with a close. Nothing here guesses at the rest
+ * of SVG. If a drawing ever grows an arc, this will draw it as the chord and
+ * somebody will see it.
+ */
+import type { Point } from "./pen.ts"
+
+/**
+ * How fine a curve is cut, as a share of how big the whole drawing is.
+ *
+ * A share rather than a length, and that is the whole of the change this file
+ * once needed. The drawings in this ornament are not written at one scale: a
+ * fish is about forty units nose to tail and an octopus is written about the
+ * origin at less than one, and both are stood at whatever size they are
+ * actually drawn. Cut to a fixed length, the fish came out smooth and the
+ * octopus came out as a heptagon with legs, and nothing said so until one was
+ * magnified on a plate.
+ *
+ * So a curve is cut against the drawing it belongs to. The steps are still
+ * counted against how far the curve actually runs, because a long sweep down a
+ * whale's back and the notch in a tail fin are the same command and want a
+ * different number of pieces.
+ */
+const STEP = 0.035
+const MOST = 24
+
+/** What one path came to, kept, since a fish is the same drawing as the fish
+ *  beating beside it and there are only so many steps in a beat. */
+const walked = new Map<string, Point[][]>()
+
+export function trace(d: string): Point[][] {
+  const held = walked.get(d)
+  if (held) return held
+
+  const cut = walk(d)
+  walked.set(d, cut)
+  return cut
+}
+
+/**
+ * How big the drawing is, off the numbers in it.
+ *
+ * The furthest any coordinate gets from the origin, which is a bound on the
+ * drawing rather than its size. It is read off the string because it has to be
+ * known before the walk it decides the fineness of, and because every drawing
+ * in this ornament is written about its own middle, where the two are close
+ * enough.
+ */
+function span(d: string): number {
+  let widest = 0
+  const numbers = d.match(/-?\d*\.?\d+(?:e-?\d+)?/g)
+  if (!numbers) return 1
+  for (const one of numbers) widest = Math.max(widest, Math.abs(Number(one)))
+  return Math.max(widest, 0.001)
+}
+
+function walk(d: string): Point[][] {
+  const step = span(d) * STEP
+  const parts: Point[][] = []
+  let here: Point[] = []
+  let at = { x: 0, y: 0 }
+  let start = { x: 0, y: 0 }
+
+  const tokens = d.match(/[MLCQZmlcqz]|-?\d*\.?\d+(?:e-?\d+)?/g) ?? []
+  let read = 0
+  const number = () => Number(tokens[read++])
+
+  while (read < tokens.length) {
+    const command = tokens[read++]
+
+    if (command === "M" || command === "m") {
+      if (here.length > 1) parts.push(here)
+      here = []
+      at = { x: number(), y: number() }
+      start = at
+      here.push(at)
+      continue
+    }
+
+    if (command === "L" || command === "l") {
+      at = { x: number(), y: number() }
+      here.push(at)
+      continue
+    }
+
+    if (command === "C" || command === "c") {
+      const one = { x: number(), y: number() }
+      const two = { x: number(), y: number() }
+      const end = { x: number(), y: number() }
+      cubic(here, at, one, two, end, step)
+      at = end
+      continue
+    }
+
+    if (command === "Q" || command === "q") {
+      const hold = { x: number(), y: number() }
+      const end = { x: number(), y: number() }
+      quadratic(here, at, hold, end, step)
+      at = end
+      continue
+    }
+
+    if (command === "Z" || command === "z") {
+      if (here.length > 1) parts.push(here)
+      here = []
+      at = start
+      continue
+    }
+
+    // A number where a command was expected is a repeat of the last one, which
+    // the ornament does not write. Skipping it is better than reading the rest
+    // of the drawing off by one.
+  }
+
+  if (here.length > 1) parts.push(here)
+  return parts
+}
+
+/** How many pieces a curve of this reach is worth cutting into. */
+function pieces(reach: number, step: number): number {
+  return Math.max(2, Math.min(MOST, Math.ceil(reach / step)))
+}
+
+function cubic(into: Point[], from: Point, one: Point, two: Point, end: Point, step: number): void {
+  const reach =
+    Math.hypot(one.x - from.x, one.y - from.y) +
+    Math.hypot(two.x - one.x, two.y - one.y) +
+    Math.hypot(end.x - two.x, end.y - two.y)
+  const steps = pieces(reach, step)
+
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps
+    const u = 1 - t
+    into.push({
+      x: u * u * u * from.x + 3 * u * u * t * one.x + 3 * u * t * t * two.x + t * t * t * end.x,
+      y: u * u * u * from.y + 3 * u * u * t * one.y + 3 * u * t * t * two.y + t * t * t * end.y,
+    })
+  }
+}
+
+function quadratic(into: Point[], from: Point, hold: Point, end: Point, step: number): void {
+  const reach =
+    Math.hypot(hold.x - from.x, hold.y - from.y) + Math.hypot(end.x - hold.x, end.y - hold.y)
+  const steps = pieces(reach, step)
+
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps
+    const u = 1 - t
+    into.push({
+      x: u * u * from.x + 2 * u * t * hold.x + t * t * end.x,
+      y: u * u * from.y + 2 * u * t * hold.y + t * t * end.y,
+    })
+  }
+}