oddlyalive 0.2.0-alpha.2

package/src/rigid-scene.js

@@ -0,0 +1,223 @@
+import { assertFiniteNumber } from "./scene.js";
+
+const DEFAULT_RIGID_SCENE = {
+  version: 1,
+  type: "rigid-balls",
+  name: "Ball Lab",
+  seed: 21,
+  canvas: {
+    width: 960,
+    height: 540
+  },
+  timing: {
+    duration: 6.4,
+    fps: 60,
+    substeps: 4,
+    preRoll: 0
+  },
+  world: {
+    gravity: 920,
+    airDrag: 0.08,
+    floorY: 456,
+    left: 84,
+    right: 876,
+    groundFriction: 1.8
+  },
+  bodies: [
+    {
+      id: "baseball",
+      kind: "baseball",
+      label: "BASEBALL",
+      x: 250,
+      y: 104,
+      radius: 29,
+      mass: 0.145,
+      restitution: 0.52,
+      friction: 0.38,
+      vx: 34,
+      vy: 0,
+      angle: -8,
+      angularVelocity: 1.2,
+      color: "#f4efe4"
+    },
+    {
+      id: "basketball",
+      kind: "basketball",
+      label: "BASKETBALL",
+      x: 480,
+      y: 72,
+      radius: 48,
+      mass: 0.625,
+      restitution: 0.76,
+      friction: 0.58,
+      vx: -18,
+      vy: 0,
+      angle: 4,
+      angularVelocity: -0.5,
+      color: "#e66b2d"
+    },
+    {
+      id: "football",
+      kind: "football",
+      label: "FOOTBALL",
+      x: 710,
+      y: 124,
+      radius: 39,
+      mass: 0.43,
+      restitution: 0.63,
+      friction: 0.5,
+      vx: -42,
+      vy: 0,
+      angle: 11,
+      angularVelocity: 0.8,
+      color: "#f6f3e9"
+    }
+  ],
+  impulses: []
+};
+
+function mergeSection(base, incoming) {
+  return { ...base, ...(incoming ?? {}) };
+}
+
+export function createRigidBallsScene(overrides = {}) {
+  return {
+    ...DEFAULT_RIGID_SCENE,
+    ...overrides,
+    canvas: mergeSection(DEFAULT_RIGID_SCENE.canvas, overrides.canvas),
+    timing: mergeSection(DEFAULT_RIGID_SCENE.timing, overrides.timing),
+    world: mergeSection(DEFAULT_RIGID_SCENE.world, overrides.world),
+    bodies:
+      overrides.bodies?.map((body) => ({ ...body })) ??
+      DEFAULT_RIGID_SCENE.bodies.map((body) => ({ ...body })),
+    impulses:
+      overrides.impulses?.map((impulse) => ({ ...impulse })) ??
+      DEFAULT_RIGID_SCENE.impulses.map((impulse) => ({ ...impulse }))
+  };
+}
+
+export function validateRigidBallsScene(input) {
+  const scene = createRigidBallsScene(input);
+  if (scene.version !== 1) {
+    throw new RangeError(`Unsupported scene version: ${scene.version}`);
+  }
+  if (scene.type !== "rigid-balls") {
+    throw new TypeError(`Unsupported rigid scene type: ${scene.type}`);
+  }
+
+  assertFiniteNumber(scene.seed, "seed");
+  assertFiniteNumber(scene.canvas.width, "canvas.width", { minimum: 64 });
+  assertFiniteNumber(scene.canvas.height, "canvas.height", { minimum: 64 });
+  assertFiniteNumber(scene.timing.duration, "timing.duration", {
+    minimum: 0.1,
+    maximum: 60
+  });
+  assertFiniteNumber(scene.timing.fps, "timing.fps", {
+    minimum: 1,
+    maximum: 240
+  });
+  assertFiniteNumber(scene.timing.substeps, "timing.substeps", {
+    minimum: 1,
+    maximum: 16
+  });
+  assertFiniteNumber(scene.timing.preRoll, "timing.preRoll", {
+    minimum: 0,
+    maximum: 30
+  });
+  if (!Number.isInteger(scene.timing.fps) || !Number.isInteger(scene.timing.substeps)) {
+    throw new TypeError("timing.fps and timing.substeps must be integers.");
+  }
+
+  for (const key of [
+    "gravity",
+    "airDrag",
+    "floorY",
+    "left",
+    "right",
+    "groundFriction"
+  ]) {
+    assertFiniteNumber(scene.world[key], `world.${key}`);
+  }
+  if (
+    scene.world.airDrag < 0 ||
+    scene.world.groundFriction < 0
+  ) {
+    throw new RangeError("world drag and friction values cannot be negative.");
+  }
+  if (scene.world.left >= scene.world.right) {
+    throw new RangeError("world.left must be less than world.right.");
+  }
+  if (!Array.isArray(scene.bodies) || scene.bodies.length === 0) {
+    throw new TypeError("bodies must contain at least one rigid body.");
+  }
+  if (scene.bodies.length > 64) {
+    throw new RangeError("The alpha supports at most 64 rigid bodies.");
+  }
+
+  const ids = new Set();
+  scene.bodies.forEach((body, index) => {
+    if (typeof body.id !== "string" || body.id.length === 0) {
+      throw new TypeError(`bodies[${index}].id must be a non-empty string.`);
+    }
+    if (typeof body.kind !== "string" || body.kind.length === 0) {
+      throw new TypeError(`bodies[${index}].kind must be a non-empty string.`);
+    }
+    if (typeof body.color !== "string" || body.color.length === 0) {
+      throw new TypeError(`bodies[${index}].color must be a non-empty string.`);
+    }
+    if (ids.has(body.id)) {
+      throw new RangeError(`Duplicate rigid body id: ${body.id}`);
+    }
+    ids.add(body.id);
+    for (const key of [
+      "x",
+      "y",
+      "radius",
+      "mass",
+      "restitution",
+      "friction",
+      "vx",
+      "vy",
+      "angle",
+      "angularVelocity"
+    ]) {
+      assertFiniteNumber(body[key], `bodies[${index}].${key}`);
+    }
+    if (body.radius <= 0 || body.mass <= 0) {
+      throw new RangeError(`bodies[${index}] radius and mass must be positive.`);
+    }
+    if (body.restitution < 0 || body.restitution > 1) {
+      throw new RangeError(`bodies[${index}].restitution must be between 0 and 1.`);
+    }
+    if (body.friction < 0 || body.friction > 1) {
+      throw new RangeError(`bodies[${index}].friction must be between 0 and 1.`);
+    }
+  });
+
+  let previousTime = -Infinity;
+  scene.impulses.forEach((impulse, index) => {
+    assertFiniteNumber(impulse.time, `impulses[${index}].time`);
+    assertFiniteNumber(impulse.impulseX, `impulses[${index}].impulseX`);
+    assertFiniteNumber(impulse.impulseY, `impulses[${index}].impulseY`);
+    assertFiniteNumber(
+      impulse.angularImpulse ?? 0,
+      `impulses[${index}].angularImpulse`
+    );
+    if (!ids.has(impulse.body)) {
+      throw new RangeError(`impulses[${index}] references unknown body ${impulse.body}.`);
+    }
+    if (impulse.time < 0 || impulse.time > scene.timing.duration) {
+      throw new RangeError(
+        `impulses[${index}].time must fall within the scene duration.`
+      );
+    }
+    if (impulse.time < previousTime) {
+      throw new RangeError("impulses must be ordered by time.");
+    }
+    previousTime = impulse.time;
+  });
+
+  return scene;
+}
+
+export const defaultRigidBallsScene = createRigidBallsScene();

package/src/scene-registry.js

@@ -0,0 +1,17 @@
+import { validateRigidBallsScene } from "./rigid-scene.js";
+import { validateStrandScene } from "./scene.js";
+import { validateSurfaceWaveScene } from "./wave-scene.js";
+
+export function validateScene(input) {
+  switch (input?.type) {
+    case "strand-field":
+    case undefined:
+      return validateStrandScene(input);
+    case "rigid-balls":
+      return validateRigidBallsScene(input);
+    case "surface-wave":
+      return validateSurfaceWaveScene(input);
+    default:
+      throw new TypeError(`Unsupported scene type: ${input?.type}`);
+  }
+}

package/src/scene.js

@@ -0,0 +1,206 @@
+const DEFAULT_TOUCH_PATH = [
+  { time: 0.48, x: -60, y: 326, pressure: 0 },
+  { time: 0.59, x: 30, y: 329, pressure: 0.3 },
+  { time: 0.74, x: 265, y: 338, pressure: 0.86 },
+  { time: 1.08, x: 402, y: 360, pressure: 1 },
+  { time: 1.48, x: 565, y: 386, pressure: 0.98 },
+  { time: 1.88, x: 805, y: 397, pressure: 1 },
+  { time: 2.14, x: 914, y: 376, pressure: 0.97 },
+  { time: 2.28, x: 944, y: 367, pressure: 0.94 },
+  { time: 2.44, x: 906, y: 376, pressure: 0.96 },
+  { time: 2.7, x: 800, y: 408, pressure: 0.92 },
+  { time: 3, x: 665, y: 424, pressure: 0.8 },
+  { time: 3.29, x: 520, y: 416, pressure: 0.61 },
+  { time: 3.58, x: 390, y: 392, pressure: 0.34 },
+  { time: 3.84, x: 250, y: 370, pressure: 0.12 },
+  { time: 4.08, x: 120, y: 356, pressure: 0.03 },
+  { time: 4.32, x: 40, y: 351, pressure: 0 }
+];
+
+const DEFAULT_SCENE = {
+  version: 1,
+  type: "strand-field",
+  name: "String Touch",
+  seed: 11,
+  canvas: {
+    width: 960,
+    height: 540
+  },
+  timing: {
+    duration: 6.4,
+    fps: 60,
+    substeps: 4,
+    preRoll: 2
+  },
+  field: {
+    columns: 23,
+    rows: 16,
+    originX: 330,
+    originY: 112,
+    spacingX: 24,
+    spacingY: 20
+  },
+  material: {
+    gravity: 480,
+    linearDrag: 0.92,
+    quadraticDrag: 0.0023,
+    lengthCompliance: 0.0000011,
+    compressionCompliance: 0.00052,
+    bendCompliance: 0.00062,
+    maxStretch: 1.045
+  },
+  contact: {
+    radiusX: 53,
+    radiusY: 33,
+    maxStaticGrip: 8,
+    captureStartRow: 6,
+    captureEndRow: 14
+  },
+  gesture: {
+    type: "touch-path",
+    points: DEFAULT_TOUCH_PATH
+  },
+  payload: {
+    text: "ODDLY ALIVE  •  MAKE ANYTHING FEEL ALIVE  •  ",
+    fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+    fontSize: 12
+  },
+  render: {
+    background: "#f0e7d3",
+    ink: "#20201d",
+    accent: "#ec5b36",
+    filament: "rgba(32, 32, 29, 0.34)"
+  }
+};
+
+function mergeSection(base, incoming) {
+  return { ...base, ...(incoming ?? {}) };
+}
+
+export function createStringTouchScene(overrides = {}) {
+  return {
+    ...DEFAULT_SCENE,
+    ...overrides,
+    canvas: mergeSection(DEFAULT_SCENE.canvas, overrides.canvas),
+    timing: mergeSection(DEFAULT_SCENE.timing, overrides.timing),
+    field: mergeSection(DEFAULT_SCENE.field, overrides.field),
+    material: mergeSection(DEFAULT_SCENE.material, overrides.material),
+    contact: mergeSection(DEFAULT_SCENE.contact, overrides.contact),
+    gesture: {
+      ...DEFAULT_SCENE.gesture,
+      ...(overrides.gesture ?? {}),
+      points:
+        overrides.gesture?.points?.map((point) => ({ ...point })) ??
+        DEFAULT_TOUCH_PATH.map((point) => ({ ...point }))
+    },
+    payload: mergeSection(DEFAULT_SCENE.payload, overrides.payload),
+    render: mergeSection(DEFAULT_SCENE.render, overrides.render)
+  };
+}
+
+export function assertFiniteNumber(value, path, { minimum, maximum } = {}) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${path} must be a finite number.`);
+  }
+  if (minimum !== undefined && value < minimum) {
+    throw new RangeError(`${path} must be at least ${minimum}.`);
+  }
+  if (maximum !== undefined && value > maximum) {
+    throw new RangeError(`${path} must be at most ${maximum}.`);
+  }
+}
+
+export function validateStrandScene(input) {
+  const scene = createStringTouchScene(input);
+  if (scene.version !== 1) {
+    throw new RangeError(`Unsupported scene version: ${scene.version}`);
+  }
+  if (scene.type !== "strand-field") {
+    throw new TypeError(`Unsupported scene type: ${scene.type}`);
+  }
+
+  assertFiniteNumber(scene.seed, "seed");
+  assertFiniteNumber(scene.canvas.width, "canvas.width", { minimum: 64 });
+  assertFiniteNumber(scene.canvas.height, "canvas.height", { minimum: 64 });
+  assertFiniteNumber(scene.timing.duration, "timing.duration", {
+    minimum: 0.1,
+    maximum: 60
+  });
+  assertFiniteNumber(scene.timing.fps, "timing.fps", {
+    minimum: 1,
+    maximum: 240
+  });
+  assertFiniteNumber(scene.timing.substeps, "timing.substeps", {
+    minimum: 1,
+    maximum: 16
+  });
+  assertFiniteNumber(scene.field.columns, "field.columns", {
+    minimum: 1,
+    maximum: 128
+  });
+  assertFiniteNumber(scene.field.rows, "field.rows", {
+    minimum: 3,
+    maximum: 128
+  });
+  assertFiniteNumber(scene.material.maxStretch, "material.maxStretch", {
+    minimum: 1,
+    maximum: 1.5
+  });
+  assertFiniteNumber(
+    scene.contact.maxStaticGrip,
+    "contact.maxStaticGrip",
+    { minimum: 1, maximum: scene.field.columns }
+  );
+
+  if (!Number.isInteger(scene.field.columns) || !Number.isInteger(scene.field.rows)) {
+    throw new TypeError("field.columns and field.rows must be integers.");
+  }
+  if (!Number.isInteger(scene.timing.fps) || !Number.isInteger(scene.timing.substeps)) {
+    throw new TypeError("timing.fps and timing.substeps must be integers.");
+  }
+  if (!Array.isArray(scene.gesture.points) || scene.gesture.points.length < 2) {
+    throw new TypeError("gesture.points must contain at least two points.");
+  }
+
+  let previousTime = -Infinity;
+  scene.gesture.points.forEach((point, index) => {
+    assertFiniteNumber(point.time, `gesture.points[${index}].time`);
+    assertFiniteNumber(point.x, `gesture.points[${index}].x`);
+    assertFiniteNumber(point.y, `gesture.points[${index}].y`);
+    assertFiniteNumber(point.pressure, `gesture.points[${index}].pressure`, {
+      minimum: 0,
+      maximum: 1
+    });
+    if (point.time <= previousTime) {
+      throw new RangeError("gesture.points must be strictly ordered by time.");
+    }
+    previousTime = point.time;
+  });
+
+  if (scene.contact.captureStartRow < 0) {
+    throw new RangeError("contact.captureStartRow cannot be negative.");
+  }
+  scene.contact.captureEndRow = Math.min(
+    scene.field.rows - 1,
+    scene.contact.captureEndRow
+  );
+  if (scene.contact.captureStartRow > scene.contact.captureEndRow) {
+    throw new RangeError(
+      "contact.captureStartRow must not exceed contact.captureEndRow."
+    );
+  }
+  if (typeof scene.payload.text !== "string" || scene.payload.text.length === 0) {
+    throw new TypeError("payload.text must be a non-empty string.");
+  }
+  if (scene.payload.terminalMass !== undefined) {
+    assertFiniteNumber(scene.payload.terminalMass, "payload.terminalMass", {
+      minimum: 0.1,
+      maximum: 50
+    });
+  }
+
+  return scene;
+}
+
+export const validateScene = validateStrandScene;
+export const defaultStringTouchScene = createStringTouchScene();

package/src/state-hash.js

@@ -0,0 +1,17 @@
+export function createStateHasher() {
+  let hash = 0x811c9dc5;
+  return {
+    add(value) {
+      const rounded = Math.round(value * 1000);
+      hash ^= rounded & 0xff;
+      hash = Math.imul(hash, 0x01000193);
+      hash ^= (rounded >>> 8) & 0xff;
+      hash = Math.imul(hash, 0x01000193);
+      hash ^= (rounded >>> 16) & 0xff;
+      hash = Math.imul(hash, 0x01000193);
+    },
+    digest() {
+      return (hash >>> 0).toString(16).padStart(8, "0");
+    }
+  };
+}