@pibbl/core 0.0.1

package/dist/features/particles/lib/compiler.js

@@ -0,0 +1,443 @@
+import { parseParticleColor } from "./color.js";
+import {
+  compileParticleCurve,
+  compileParticleGradient
+} from "./curve.js";
+import {
+  getParticleEffect2DRecord
+} from "./definition-records.js";
+import {
+  compileEmissionSchedule
+} from "./emission.js";
+import { getParticleDescriptorRecord } from "./particle.js";
+import {
+  compileWeightedChoice,
+  hashEmitterName
+} from "./random.js";
+const ParameterTimingMask = Object.freeze({
+  Spawn: 1,
+  Simulation: 2,
+  Render: 4
+});
+const compiled2D = /* @__PURE__ */ new WeakMap();
+function parameterLength(type) {
+  switch (type) {
+    case "number":
+      return 1;
+    case "vector2":
+      return 2;
+    case "color":
+      return 4;
+  }
+}
+function timingMask(timing) {
+  switch (timing) {
+    case "spawn":
+      return ParameterTimingMask.Spawn;
+    case "simulation":
+      return ParameterTimingMask.Simulation;
+    case "render":
+      return ParameterTimingMask.Render;
+  }
+}
+function writeParameterDefault(definition, output) {
+  if (definition.type === "number") output.push(definition.default);
+  else if (definition.type === "color")
+    output.push(...parseParticleColor(definition.default));
+  else output.push(...definition.default);
+}
+function compileParameterLayout(definitions) {
+  const entries = [];
+  const defaults = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const [name, definition] of Object.entries(definitions)) {
+    const entry = Object.freeze({
+      name,
+      type: definition.type,
+      timing: definition.timing,
+      offset: defaults.length,
+      length: parameterLength(definition.type)
+    });
+    entries.push(entry);
+    byName.set(name, entry);
+    writeParameterDefault(definition, defaults);
+  }
+  const spawnMask = new Uint8Array(defaults.length);
+  const simulationMask = new Uint8Array(defaults.length);
+  const renderMask = new Uint8Array(defaults.length);
+  for (const entry of entries) {
+    const mask = entry.timing === "spawn" ? spawnMask : entry.timing === "simulation" ? simulationMask : renderMask;
+    mask.fill(1, entry.offset, entry.offset + entry.length);
+  }
+  return Object.freeze({
+    entries: Object.freeze(entries),
+    defaults: new Float64Array(defaults),
+    spawnMask,
+    simulationMask,
+    renderMask,
+    byName
+  });
+}
+function channelFor(path) {
+  return hashEmitterName(path);
+}
+function compileParameterReference(reference, layout, expectedDimension, path) {
+  const descriptor = getParticleDescriptorRecord(reference);
+  if (descriptor?.type !== "parameter") {
+    throw new TypeError(`Particle ${path} must use particleParameter().`);
+  }
+  const entry = layout.byName.get(descriptor.name);
+  if (entry === void 0) {
+    throw new TypeError(
+      `Particle ${path} references unknown parameter "${descriptor.name}".`
+    );
+  }
+  if (entry.length !== expectedDimension) {
+    throw new TypeError(
+      `Particle ${path} parameter "${descriptor.name}" has ${entry.type} dimension ${entry.length}; expected ${expectedDimension}.`
+    );
+  }
+  return Object.freeze({
+    kind: "parameter",
+    offset: entry.offset,
+    length: expectedDimension,
+    timingMask: timingMask(entry.timing),
+    channel: channelFor(path)
+  });
+}
+function compileScalar(value, layout, path) {
+  const channel = channelFor(path);
+  if (typeof value === "number")
+    return Object.freeze({ kind: "constant", value, channel });
+  const descriptor = getParticleDescriptorRecord(value);
+  switch (descriptor?.type) {
+    case "between":
+      return Object.freeze({
+        kind: "between",
+        min: descriptor.min,
+        max: descriptor.max,
+        channel
+      });
+    case "integer":
+      return Object.freeze({
+        kind: "integer",
+        min: descriptor.min,
+        max: descriptor.max,
+        channel
+      });
+    case "choice": {
+      const choices = descriptor.choices.map(
+        ({ value: choiceValue, weight }) => {
+          if (typeof choiceValue !== "number") {
+            throw new TypeError(
+              `Particle ${path} choice values must be numbers.`
+            );
+          }
+          return { value: choiceValue, weight };
+        }
+      );
+      return Object.freeze({
+        kind: "choice",
+        choice: compileWeightedChoice(choices),
+        channel
+      });
+    }
+    case "parameter":
+      return compileParameterReference(
+        value,
+        layout,
+        1,
+        path
+      );
+    default:
+      throw new TypeError(`Particle ${path} must be a scalar particle value.`);
+  }
+}
+function compileScalarVector2(value, layout, path) {
+  if (!Array.isArray(value)) {
+    return compileParameterReference(
+      value,
+      layout,
+      2,
+      path
+    );
+  }
+  return Object.freeze([
+    compileScalar(value[0], layout, `${path}[0]`),
+    compileScalar(value[1], layout, `${path}[1]`)
+  ]);
+}
+function isScalarVector2(value) {
+  return Array.isArray(value);
+}
+function compileColor(value, layout, path) {
+  const channel = channelFor(path);
+  if (value === void 0) {
+    return Object.freeze({
+      kind: "constant",
+      color: parseParticleColor("white"),
+      channel
+    });
+  }
+  if (typeof value === "string") {
+    return Object.freeze({
+      kind: "constant",
+      color: parseParticleColor(value),
+      channel
+    });
+  }
+  const descriptor = getParticleDescriptorRecord(value);
+  if (descriptor?.type === "parameter") {
+    return compileParameterReference(
+      value,
+      layout,
+      4,
+      path
+    );
+  }
+  if (descriptor?.type !== "choice") {
+    throw new TypeError(
+      `Particle ${path} must be a color or particleChoice().`
+    );
+  }
+  const choices = compileWeightedChoice(
+    descriptor.choices.map((choice) => {
+      if (typeof choice.value !== "string") {
+        throw new TypeError(`Particle ${path} choice values must be colors.`);
+      }
+      return { value: parseParticleColor(choice.value), weight: choice.weight };
+    })
+  );
+  return Object.freeze({
+    kind: "choice",
+    samples: choices.values,
+    cumulativeWeights: choices.cumulativeWeights,
+    totalWeight: choices.totalWeight,
+    channel
+  });
+}
+function compileSwayFrequency(value, layout, path) {
+  if (!Array.isArray(value)) {
+    return compileScalar(value, layout, path);
+  }
+  const min = value[0];
+  const max = value[1];
+  if (!Number.isFinite(min) || !Number.isFinite(max) || min > max) {
+    throw new RangeError(
+      `Particle ${path} range must contain finite values with min at most max; received ${min} through ${max}.`
+    );
+  }
+  return Object.freeze({
+    kind: "between",
+    min,
+    max,
+    channel: channelFor(path)
+  });
+}
+function compileMaximumLifetime(value) {
+  switch (value.kind) {
+    case "constant":
+      return Object.freeze({ kind: "fixed", milliseconds: value.value });
+    case "between":
+    case "integer":
+      return Object.freeze({ kind: "fixed", milliseconds: value.max });
+    case "choice":
+      return Object.freeze({
+        kind: "fixed",
+        milliseconds: Math.max(...value.choice.values)
+      });
+    case "parameter":
+      return Object.freeze({ kind: "parameter", offset: value.offset });
+  }
+}
+function compileSize(value, layout) {
+  if (value === void 0) {
+    return Object.freeze([
+      compileScalar(1, layout, "initial.size[0]"),
+      compileScalar(1, layout, "initial.size[1]")
+    ]);
+  }
+  if (isScalarVector2(value))
+    return compileScalarVector2(value, layout, "initial.size");
+  const descriptor = getParticleDescriptorRecord(value);
+  if (descriptor?.type === "parameter") {
+    const entry = layout.byName.get(descriptor.name);
+    if (entry?.length === 2) {
+      return compileParameterReference(
+        value,
+        layout,
+        2,
+        "initial.size"
+      );
+    }
+  }
+  const scalar = compileScalar(
+    value,
+    layout,
+    "initial.size"
+  );
+  return Object.freeze([scalar, scalar]);
+}
+function compileInitial2D(initial, layout) {
+  return Object.freeze({
+    lifetime: compileScalar(
+      initial.lifetimeMilliseconds,
+      layout,
+      "initial.lifetimeMilliseconds"
+    ),
+    velocity: initial.velocity === void 0 ? Object.freeze([
+      compileScalar(0, layout, "initial.velocity[0]"),
+      compileScalar(0, layout, "initial.velocity[1]")
+    ]) : compileScalarVector2(initial.velocity, layout, "initial.velocity"),
+    size: compileSize(initial.size, layout),
+    rotation: compileScalar(
+      initial.rotationDegrees ?? 0,
+      layout,
+      "initial.rotationDegrees"
+    ),
+    angularVelocity: compileScalar(
+      initial.angularVelocityDegreesPerSecond ?? 0,
+      layout,
+      "initial.angularVelocityDegreesPerSecond"
+    ),
+    color: compileColor(initial.color, layout, "initial.color"),
+    opacity: compileScalar(initial.opacity ?? 1, layout, "initial.opacity")
+  });
+}
+function compileAppearance(appearance) {
+  return Object.freeze({
+    size: appearance?.size === void 0 ? null : compileParticleCurve(appearance.size),
+    rotation: appearance?.rotationDegrees === void 0 ? null : compileParticleCurve(appearance.rotationDegrees),
+    color: appearance?.color === void 0 ? null : compileParticleGradient(appearance.color),
+    opacity: appearance?.opacity === void 0 ? null : compileParticleCurve(appearance.opacity)
+  });
+}
+function compileMotion2D(motion, layout) {
+  return Object.freeze(
+    motion.map((module, index) => {
+      const path = `motion[${index}]`;
+      switch (module.type) {
+        case "acceleration":
+        case "gravity":
+          return Object.freeze({
+            type: module.type,
+            value: compileScalarVector2(module.value, layout, `${path}.value`)
+          });
+        case "drift":
+          return Object.freeze({
+            type: module.type,
+            value: compileScalarVector2(
+              module.velocity,
+              layout,
+              `${path}.velocity`
+            )
+          });
+        case "drag":
+          return Object.freeze({
+            type: module.type,
+            amount: compileScalar(module.amount, layout, `${path}.amount`)
+          });
+        case "radialAcceleration":
+          return Object.freeze({
+            type: module.type,
+            center: module.center,
+            amount: compileScalar(module.amount, layout, `${path}.amount`)
+          });
+        case "orbit":
+          return Object.freeze({
+            type: module.type,
+            center: module.center,
+            degreesPerSecond: compileScalar(
+              module.degreesPerSecond,
+              layout,
+              `${path}.degreesPerSecond`
+            )
+          });
+        case "sway": {
+          return Object.freeze({
+            type: module.type,
+            amplitude: compileScalar(
+              module.amplitude,
+              layout,
+              `${path}.amplitude`
+            ),
+            frequency: compileSwayFrequency(
+              module.frequency,
+              layout,
+              `${path}.frequency`
+            )
+          });
+        }
+        case "angularVelocity":
+          return Object.freeze({
+            type: module.type,
+            degreesPerSecond: compileScalar(
+              module.degreesPerSecond,
+              layout,
+              `${path}.degreesPerSecond`
+            )
+          });
+      }
+    })
+  );
+}
+function executionCapability(supported, reasons = []) {
+  return Object.freeze({ supported, reasons: Object.freeze([...reasons]) });
+}
+function execution2D(record) {
+  return Object.freeze({
+    "flow-canvas": executionCapability(true),
+    "stateless-canvas": executionCapability(
+      record.capabilities.statelessCanvas,
+      record.capabilities.statelessCanvas ? [] : record.capabilities.requiresStateful
+    )
+  });
+}
+function compileEmitter2D(emitter, layout) {
+  const initial = compileInitial2D(emitter.initial, layout);
+  const maximumLifetime = compileMaximumLifetime(initial.lifetime);
+  return Object.freeze({
+    dimension: 2,
+    name: emitter.name,
+    emitterHash: emitter.nameHash,
+    capacity: emitter.capacity,
+    overflow: emitter.overflow ?? "reject-newest",
+    shape: emitter.shape,
+    shapeChannels: Object.freeze([
+      channelFor("shape.sample[0]"),
+      channelFor("shape.sample[1]"),
+      channelFor("shape.sample[2]")
+    ]),
+    initial,
+    motion: compileMotion2D(emitter.motion ?? [], layout),
+    appearance: compileAppearance(emitter.appearance),
+    emission: compileEmissionSchedule(emitter.emission, maximumLifetime),
+    maximumLifetime,
+    renderer: emitter.renderer,
+    bounds: emitter.bounds
+  });
+}
+function compileParticleEffect2D(effect) {
+  const cached = compiled2D.get(effect);
+  if (cached !== void 0) return cached;
+  const record = getParticleEffect2DRecord(effect);
+  const parameterLayout = compileParameterLayout(record.parameters);
+  const plan = Object.freeze({
+    dimension: 2,
+    parameterLayout,
+    emitters: Object.freeze(
+      record.emitters.map(
+        (emitter) => compileEmitter2D(emitter, parameterLayout)
+      )
+    ),
+    execution: execution2D(record)
+  });
+  compiled2D.set(effect, plan);
+  return plan;
+}
+export {
+  ParameterTimingMask,
+  compileParameterReference,
+  compileParticleEffect2D
+};
+//# sourceMappingURL=compiler.js.map

package/dist/features/particles/lib/compiler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/particles/lib/compiler.ts"],
+  "sourcesContent": ["import { parseParticleColor, type ParticleColor } from \"./color.js\";\nimport {\n  compileParticleCurve,\n  compileParticleGradient,\n  type CompiledParticleCurve,\n  type CompiledParticleGradient,\n} from \"./curve.js\";\nimport {\n  getParticleEffect2DRecord,\n  type ParticleEffect2DRecord,\n  type ParticleEmitter2DRecord,\n} from \"./definition-records.js\";\nimport {\n  compileEmissionSchedule,\n  type CompiledEmissionSchedule,\n  type CompiledMaximumLifetime,\n} from \"./emission.js\";\nimport { getParticleDescriptorRecord } from \"./particle.js\";\nimport {\n  compileWeightedChoice,\n  hashEmitterName,\n  type CompiledWeightedChoice,\n} from \"./random.js\";\nimport type {\n  PibblParticleAppearance,\n  PibblParticleEffect2D,\n  PibblParticleInitial2D,\n  PibblParticleMotion2D,\n  PibblParticleParameterDefinition,\n  PibblParticleParameterReference,\n  PibblParticleScalar,\n  PibblParticleShape2D,\n  PibblParticleVector2,\n} from \"./types.js\";\n\nexport const ParameterTimingMask = Object.freeze({\n  Spawn: 1,\n  Simulation: 2,\n  Render: 4,\n} as const);\n\nexport type ParameterTimingMaskValue =\n  (typeof ParameterTimingMask)[keyof typeof ParameterTimingMask];\n\nexport interface CompiledParameterEntry {\n  readonly name: string;\n  readonly type: PibblParticleParameterDefinition[\"type\"];\n  readonly timing: PibblParticleParameterDefinition[\"timing\"];\n  readonly offset: number;\n  readonly length: 1 | 2 | 4;\n}\n\nexport interface CompiledParameterLayout {\n  readonly entries: readonly CompiledParameterEntry[];\n  readonly defaults: Readonly<Float64Array>;\n  readonly spawnMask: Readonly<Uint8Array>;\n  readonly simulationMask: Readonly<Uint8Array>;\n  readonly renderMask: Readonly<Uint8Array>;\n  readonly byName: ReadonlyMap<string, CompiledParameterEntry>;\n}\n\nexport interface CompiledParameterReference<\n  Length extends 1 | 2 | 4 = 1 | 2 | 4,\n> {\n  readonly kind: \"parameter\";\n  readonly offset: number;\n  readonly length: Length;\n  readonly timingMask: ParameterTimingMaskValue;\n  readonly channel: number;\n}\n\nexport type CompiledScalar =\n  | Readonly<{ kind: \"constant\"; value: number; channel: number }>\n  | Readonly<{ kind: \"between\"; min: number; max: number; channel: number }>\n  | Readonly<{ kind: \"integer\"; min: number; max: number; channel: number }>\n  | Readonly<{\n      kind: \"choice\";\n      choice: CompiledWeightedChoice<number>;\n      channel: number;\n    }>\n  | CompiledParameterReference<1>;\n\nexport type CompiledVector2 =\n  readonly [CompiledScalar, CompiledScalar] | CompiledParameterReference<2>;\n\nexport type CompiledColor =\n  | Readonly<{ kind: \"constant\"; color: ParticleColor; channel: number }>\n  | Readonly<{\n      kind: \"choice\";\n      samples: readonly ParticleColor[];\n      cumulativeWeights: readonly number[];\n      totalWeight: number;\n      channel: number;\n    }>\n  | CompiledParameterReference<4>;\n\nexport interface CompiledAppearance {\n  readonly size: CompiledParticleCurve | null;\n  readonly rotation: CompiledParticleCurve | null;\n  readonly color: CompiledParticleGradient | null;\n  readonly opacity: CompiledParticleCurve | null;\n}\n\nexport interface CompiledInitial2D {\n  readonly lifetime: CompiledScalar;\n  readonly velocity: CompiledVector2;\n  readonly size: CompiledVector2;\n  readonly rotation: CompiledScalar;\n  readonly angularVelocity: CompiledScalar;\n  readonly color: CompiledColor;\n  readonly opacity: CompiledScalar;\n}\n\nexport type CompiledMotion2D =\n  | Readonly<{\n      type: \"acceleration\" | \"gravity\" | \"drift\";\n      value: CompiledVector2;\n    }>\n  | Readonly<{ type: \"drag\"; amount: CompiledScalar }>\n  | Readonly<{\n      type: \"radialAcceleration\";\n      center: readonly [number, number];\n      amount: CompiledScalar;\n    }>\n  | Readonly<{\n      type: \"orbit\";\n      center: readonly [number, number];\n      degreesPerSecond: CompiledScalar;\n    }>\n  | Readonly<{\n      type: \"sway\";\n      amplitude: CompiledScalar;\n      frequency: CompiledScalar;\n    }>\n  | Readonly<{ type: \"angularVelocity\"; degreesPerSecond: CompiledScalar }>;\n\nexport interface CompiledEmitter2D {\n  readonly dimension: 2;\n  readonly name: string;\n  readonly emitterHash: number;\n  readonly capacity: number;\n  readonly overflow: \"reject-newest\" | \"recycle-oldest\";\n  readonly shape: PibblParticleShape2D;\n  readonly shapeChannels: readonly [number, number, number];\n  readonly initial: CompiledInitial2D;\n  readonly motion: readonly CompiledMotion2D[];\n  readonly appearance: CompiledAppearance;\n  readonly emission: CompiledEmissionSchedule;\n  readonly maximumLifetime: CompiledMaximumLifetime;\n  readonly renderer: ParticleEmitter2DRecord[\"renderer\"];\n  readonly bounds: ParticleEmitter2DRecord[\"bounds\"];\n}\n\nexport interface CompiledExecutionCapability {\n  readonly supported: boolean;\n  readonly reasons: readonly string[];\n}\n\nexport interface CompiledExecutionCapabilities {\n  readonly \"stateless-canvas\": CompiledExecutionCapability;\n  readonly \"flow-canvas\": CompiledExecutionCapability;\n}\n\nexport interface CompiledEffect2D {\n  readonly dimension: 2;\n  readonly parameterLayout: CompiledParameterLayout;\n  readonly emitters: readonly CompiledEmitter2D[];\n  readonly execution: CompiledExecutionCapabilities;\n}\n\nconst compiled2D = new WeakMap<PibblParticleEffect2D, CompiledEffect2D>();\n\nfunction parameterLength(\n  type: PibblParticleParameterDefinition[\"type\"],\n): 1 | 2 | 4 {\n  switch (type) {\n    case \"number\":\n      return 1;\n    case \"vector2\":\n      return 2;\n    case \"color\":\n      return 4;\n  }\n}\n\nfunction timingMask(\n  timing: PibblParticleParameterDefinition[\"timing\"],\n): ParameterTimingMaskValue {\n  switch (timing) {\n    case \"spawn\":\n      return ParameterTimingMask.Spawn;\n    case \"simulation\":\n      return ParameterTimingMask.Simulation;\n    case \"render\":\n      return ParameterTimingMask.Render;\n  }\n}\n\nfunction writeParameterDefault(\n  definition: PibblParticleParameterDefinition,\n  output: number[],\n): void {\n  if (definition.type === \"number\") output.push(definition.default);\n  else if (definition.type === \"color\")\n    output.push(...parseParticleColor(definition.default));\n  else output.push(...definition.default);\n}\n\nfunction compileParameterLayout(\n  definitions: ParticleEffect2DRecord[\"parameters\"],\n): CompiledParameterLayout {\n  const entries: CompiledParameterEntry[] = [];\n  const defaults: number[] = [];\n  const byName = new Map<string, CompiledParameterEntry>();\n  for (const [name, definition] of Object.entries(definitions)) {\n    const entry = Object.freeze({\n      name,\n      type: definition.type,\n      timing: definition.timing,\n      offset: defaults.length,\n      length: parameterLength(definition.type),\n    });\n    entries.push(entry);\n    byName.set(name, entry);\n    writeParameterDefault(definition, defaults);\n  }\n  const spawnMask = new Uint8Array(defaults.length);\n  const simulationMask = new Uint8Array(defaults.length);\n  const renderMask = new Uint8Array(defaults.length);\n  for (const entry of entries) {\n    const mask =\n      entry.timing === \"spawn\"\n        ? spawnMask\n        : entry.timing === \"simulation\"\n          ? simulationMask\n          : renderMask;\n    mask.fill(1, entry.offset, entry.offset + entry.length);\n  }\n  return Object.freeze({\n    entries: Object.freeze(entries),\n    defaults: new Float64Array(defaults),\n    spawnMask,\n    simulationMask,\n    renderMask,\n    byName,\n  });\n}\n\nfunction channelFor(path: string): number {\n  return hashEmitterName(path);\n}\n\nexport function compileParameterReference<Length extends 1 | 2 | 4>(\n  reference: PibblParticleParameterReference<string>,\n  layout: CompiledParameterLayout,\n  expectedDimension: Length,\n  path: string,\n): CompiledParameterReference<Length> {\n  const descriptor = getParticleDescriptorRecord(reference);\n  if (descriptor?.type !== \"parameter\") {\n    throw new TypeError(`Particle ${path} must use particleParameter().`);\n  }\n  const entry = layout.byName.get(descriptor.name);\n  if (entry === undefined) {\n    throw new TypeError(\n      `Particle ${path} references unknown parameter \"${descriptor.name}\".`,\n    );\n  }\n  if (entry.length !== expectedDimension) {\n    throw new TypeError(\n      `Particle ${path} parameter \"${descriptor.name}\" has ${entry.type} dimension ${entry.length}; expected ${expectedDimension}.`,\n    );\n  }\n  return Object.freeze({\n    kind: \"parameter\",\n    offset: entry.offset,\n    length: expectedDimension,\n    timingMask: timingMask(entry.timing),\n    channel: channelFor(path),\n  });\n}\n\nfunction compileScalar(\n  value: PibblParticleScalar,\n  layout: CompiledParameterLayout,\n  path: string,\n): CompiledScalar {\n  const channel = channelFor(path);\n  if (typeof value === \"number\")\n    return Object.freeze({ kind: \"constant\", value, channel });\n  const descriptor = getParticleDescriptorRecord(value);\n  switch (descriptor?.type) {\n    case \"between\":\n      return Object.freeze({\n        kind: \"between\",\n        min: descriptor.min,\n        max: descriptor.max,\n        channel,\n      });\n    case \"integer\":\n      return Object.freeze({\n        kind: \"integer\",\n        min: descriptor.min,\n        max: descriptor.max,\n        channel,\n      });\n    case \"choice\": {\n      const choices = descriptor.choices.map(\n        ({ value: choiceValue, weight }) => {\n          if (typeof choiceValue !== \"number\") {\n            throw new TypeError(\n              `Particle ${path} choice values must be numbers.`,\n            );\n          }\n          return { value: choiceValue, weight };\n        },\n      );\n      return Object.freeze({\n        kind: \"choice\",\n        choice: compileWeightedChoice(choices),\n        channel,\n      });\n    }\n    case \"parameter\":\n      return compileParameterReference(\n        value as PibblParticleParameterReference<string>,\n        layout,\n        1,\n        path,\n      );\n    default:\n      throw new TypeError(`Particle ${path} must be a scalar particle value.`);\n  }\n}\n\nfunction compileScalarVector2(\n  value: PibblParticleVector2,\n  layout: CompiledParameterLayout,\n  path: string,\n): CompiledVector2 {\n  if (!Array.isArray(value)) {\n    return compileParameterReference(\n      value as PibblParticleParameterReference<string>,\n      layout,\n      2,\n      path,\n    );\n  }\n  return Object.freeze([\n    compileScalar(value[0], layout, `${path}[0]`),\n    compileScalar(value[1], layout, `${path}[1]`),\n  ] as const);\n}\n\nfunction isScalarVector2(\n  value: unknown,\n): value is readonly [PibblParticleScalar, PibblParticleScalar] {\n  return Array.isArray(value);\n}\n\nfunction compileColor(\n  value: PibblParticleInitial2D[\"color\"],\n  layout: CompiledParameterLayout,\n  path: string,\n): CompiledColor {\n  const channel = channelFor(path);\n  if (value === undefined) {\n    return Object.freeze({\n      kind: \"constant\",\n      color: parseParticleColor(\"white\"),\n      channel,\n    });\n  }\n  if (typeof value === \"string\") {\n    return Object.freeze({\n      kind: \"constant\",\n      color: parseParticleColor(value),\n      channel,\n    });\n  }\n  const descriptor = getParticleDescriptorRecord(value);\n  if (descriptor?.type === \"parameter\") {\n    return compileParameterReference(\n      value as PibblParticleParameterReference<string>,\n      layout,\n      4,\n      path,\n    );\n  }\n  if (descriptor?.type !== \"choice\") {\n    throw new TypeError(\n      `Particle ${path} must be a color or particleChoice().`,\n    );\n  }\n  const choices = compileWeightedChoice(\n    descriptor.choices.map((choice) => {\n      if (typeof choice.value !== \"string\") {\n        throw new TypeError(`Particle ${path} choice values must be colors.`);\n      }\n      return { value: parseParticleColor(choice.value), weight: choice.weight };\n    }),\n  );\n  return Object.freeze({\n    kind: \"choice\",\n    samples: choices.values,\n    cumulativeWeights: choices.cumulativeWeights,\n    totalWeight: choices.totalWeight,\n    channel,\n  });\n}\n\nfunction compileSwayFrequency(\n  value: PibblParticleScalar | readonly [number, number],\n  layout: CompiledParameterLayout,\n  path: string,\n): CompiledScalar {\n  if (!Array.isArray(value)) {\n    return compileScalar(value as PibblParticleScalar, layout, path);\n  }\n  const min = value[0]!;\n  const max = value[1]!;\n  if (!Number.isFinite(min) || !Number.isFinite(max) || min > max) {\n    throw new RangeError(\n      `Particle ${path} range must contain finite values with min at most max; received ${min} through ${max}.`,\n    );\n  }\n  return Object.freeze({\n    kind: \"between\",\n    min,\n    max,\n    channel: channelFor(path),\n  });\n}\n\nfunction compileMaximumLifetime(\n  value: CompiledScalar,\n): CompiledMaximumLifetime {\n  switch (value.kind) {\n    case \"constant\":\n      return Object.freeze({ kind: \"fixed\", milliseconds: value.value });\n    case \"between\":\n    case \"integer\":\n      return Object.freeze({ kind: \"fixed\", milliseconds: value.max });\n    case \"choice\":\n      return Object.freeze({\n        kind: \"fixed\",\n        milliseconds: Math.max(...value.choice.values),\n      });\n    case \"parameter\":\n      return Object.freeze({ kind: \"parameter\", offset: value.offset });\n  }\n}\n\nfunction compileSize(\n  value: PibblParticleInitial2D[\"size\"],\n  layout: CompiledParameterLayout,\n): CompiledVector2 {\n  if (value === undefined) {\n    return Object.freeze([\n      compileScalar(1, layout, \"initial.size[0]\"),\n      compileScalar(1, layout, \"initial.size[1]\"),\n    ] as const);\n  }\n  if (isScalarVector2(value))\n    return compileScalarVector2(value, layout, \"initial.size\");\n  const descriptor = getParticleDescriptorRecord(value);\n  if (descriptor?.type === \"parameter\") {\n    const entry = layout.byName.get(descriptor.name);\n    if (entry?.length === 2) {\n      return compileParameterReference(\n        value as PibblParticleParameterReference<string>,\n        layout,\n        2,\n        \"initial.size\",\n      );\n    }\n  }\n  const scalar = compileScalar(\n    value as PibblParticleScalar,\n    layout,\n    \"initial.size\",\n  );\n  return Object.freeze([scalar, scalar] as const);\n}\n\nfunction compileInitial2D(\n  initial: PibblParticleInitial2D,\n  layout: CompiledParameterLayout,\n): CompiledInitial2D {\n  return Object.freeze({\n    lifetime: compileScalar(\n      initial.lifetimeMilliseconds,\n      layout,\n      \"initial.lifetimeMilliseconds\",\n    ),\n    velocity:\n      initial.velocity === undefined\n        ? Object.freeze([\n            compileScalar(0, layout, \"initial.velocity[0]\"),\n            compileScalar(0, layout, \"initial.velocity[1]\"),\n          ] as const)\n        : compileScalarVector2(initial.velocity, layout, \"initial.velocity\"),\n    size: compileSize(initial.size, layout),\n    rotation: compileScalar(\n      initial.rotationDegrees ?? 0,\n      layout,\n      \"initial.rotationDegrees\",\n    ),\n    angularVelocity: compileScalar(\n      initial.angularVelocityDegreesPerSecond ?? 0,\n      layout,\n      \"initial.angularVelocityDegreesPerSecond\",\n    ),\n    color: compileColor(initial.color, layout, \"initial.color\"),\n    opacity: compileScalar(initial.opacity ?? 1, layout, \"initial.opacity\"),\n  });\n}\n\nfunction compileAppearance(\n  appearance: PibblParticleAppearance | undefined,\n): CompiledAppearance {\n  return Object.freeze({\n    size:\n      appearance?.size === undefined\n        ? null\n        : compileParticleCurve(appearance.size),\n    rotation:\n      appearance?.rotationDegrees === undefined\n        ? null\n        : compileParticleCurve(appearance.rotationDegrees),\n    color:\n      appearance?.color === undefined\n        ? null\n        : compileParticleGradient(appearance.color),\n    opacity:\n      appearance?.opacity === undefined\n        ? null\n        : compileParticleCurve(appearance.opacity),\n  });\n}\n\nfunction compileMotion2D(\n  motion: readonly PibblParticleMotion2D[],\n  layout: CompiledParameterLayout,\n): readonly CompiledMotion2D[] {\n  return Object.freeze(\n    motion.map((module, index): CompiledMotion2D => {\n      const path = `motion[${index}]`;\n      switch (module.type) {\n        case \"acceleration\":\n        case \"gravity\":\n          return Object.freeze({\n            type: module.type,\n            value: compileScalarVector2(module.value, layout, `${path}.value`),\n          });\n        case \"drift\":\n          return Object.freeze({\n            type: module.type,\n            value: compileScalarVector2(\n              module.velocity,\n              layout,\n              `${path}.velocity`,\n            ),\n          });\n        case \"drag\":\n          return Object.freeze({\n            type: module.type,\n            amount: compileScalar(module.amount, layout, `${path}.amount`),\n          });\n        case \"radialAcceleration\":\n          return Object.freeze({\n            type: module.type,\n            center: module.center,\n            amount: compileScalar(module.amount, layout, `${path}.amount`),\n          });\n        case \"orbit\":\n          return Object.freeze({\n            type: module.type,\n            center: module.center,\n            degreesPerSecond: compileScalar(\n              module.degreesPerSecond,\n              layout,\n              `${path}.degreesPerSecond`,\n            ),\n          });\n        case \"sway\": {\n          return Object.freeze({\n            type: module.type,\n            amplitude: compileScalar(\n              module.amplitude,\n              layout,\n              `${path}.amplitude`,\n            ),\n            frequency: compileSwayFrequency(\n              module.frequency,\n              layout,\n              `${path}.frequency`,\n            ),\n          });\n        }\n        case \"angularVelocity\":\n          return Object.freeze({\n            type: module.type,\n            degreesPerSecond: compileScalar(\n              module.degreesPerSecond,\n              layout,\n              `${path}.degreesPerSecond`,\n            ),\n          });\n      }\n    }),\n  );\n}\n\nfunction executionCapability(\n  supported: boolean,\n  reasons: readonly string[] = [],\n): CompiledExecutionCapability {\n  return Object.freeze({ supported, reasons: Object.freeze([...reasons]) });\n}\n\nfunction execution2D(\n  record: ParticleEffect2DRecord,\n): CompiledExecutionCapabilities {\n  return Object.freeze({\n    \"flow-canvas\": executionCapability(true),\n    \"stateless-canvas\": executionCapability(\n      record.capabilities.statelessCanvas,\n      record.capabilities.statelessCanvas\n        ? []\n        : record.capabilities.requiresStateful,\n    ),\n  });\n}\n\nfunction compileEmitter2D(\n  emitter: ParticleEmitter2DRecord,\n  layout: CompiledParameterLayout,\n): CompiledEmitter2D {\n  const initial = compileInitial2D(emitter.initial, layout);\n  const maximumLifetime = compileMaximumLifetime(initial.lifetime);\n  return Object.freeze({\n    dimension: 2,\n    name: emitter.name,\n    emitterHash: emitter.nameHash,\n    capacity: emitter.capacity,\n    overflow: emitter.overflow ?? \"reject-newest\",\n    shape: emitter.shape,\n    shapeChannels: Object.freeze([\n      channelFor(\"shape.sample[0]\"),\n      channelFor(\"shape.sample[1]\"),\n      channelFor(\"shape.sample[2]\"),\n    ] as const),\n    initial,\n    motion: compileMotion2D(emitter.motion ?? [], layout),\n    appearance: compileAppearance(emitter.appearance),\n    emission: compileEmissionSchedule(emitter.emission, maximumLifetime),\n    maximumLifetime,\n    renderer: emitter.renderer,\n    bounds: emitter.bounds,\n  });\n}\n\nexport function compileParticleEffect2D(\n  effect: PibblParticleEffect2D,\n): CompiledEffect2D {\n  const cached = compiled2D.get(effect);\n  if (cached !== undefined) return cached;\n  const record = getParticleEffect2DRecord(effect);\n  const parameterLayout = compileParameterLayout(record.parameters);\n  const plan = Object.freeze({\n    dimension: 2 as const,\n    parameterLayout,\n    emitters: Object.freeze(\n      record.emitters.map((emitter) =>\n        compileEmitter2D(emitter, parameterLayout),\n      ),\n    ),\n    execution: execution2D(record),\n  });\n  compiled2D.set(effect, plan);\n  return plan;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/particles/lib/curve.d.ts

@@ -0,0 +1,19 @@
+import type { PibblEasing } from "@pibbl/core";
+import type { PibblParticleCurve, PibblParticleCurveValue, PibblParticleGradient } from "./types.js";
+export declare const PARTICLE_CURVE_POINT_COUNT = 257;
+export interface CompiledParticleCurve {
+    readonly dimension: 1 | 2;
+    readonly pointCount: 257;
+    readonly samples: readonly number[];
+}
+export interface CompiledParticleGradient {
+    readonly pointCount: 257;
+    readonly samples: readonly number[];
+    readonly cssSamples: readonly string[];
+}
+export declare function compileEasingTable(easing?: PibblEasing): readonly number[];
+export declare function sampleEasingTable(samples: readonly number[], progress: number): number;
+export declare function compileParticleCurve(descriptor: PibblParticleCurve<PibblParticleCurveValue>): CompiledParticleCurve;
+export declare function sampleParticleCurve(curve: CompiledParticleCurve, normalizedAge: number, component: number): number;
+export declare function compileParticleGradient(descriptor: PibblParticleGradient): CompiledParticleGradient;
+export declare function sampleParticleGradient(gradient: CompiledParticleGradient, normalizedAge: number, output: Float64Array, offset: number): void;

package/dist/features/particles/lib/curve.js

@@ -0,0 +1,129 @@
+import { parseParticleColor } from "./color.js";
+import { getParticleDescriptorRecord } from "./particle.js";
+const PARTICLE_CURVE_POINT_COUNT = 257;
+const PARTICLE_CURVE_SEGMENTS = PARTICLE_CURVE_POINT_COUNT - 1;
+function clampProgress(progress) {
+  return Math.min(1, Math.max(0, progress));
+}
+function compileEasingTable(easing) {
+  const samples = [];
+  for (let index = 0; index < PARTICLE_CURVE_POINT_COUNT; index += 1) {
+    const progress = index / PARTICLE_CURVE_SEGMENTS;
+    const value = easing === void 0 ? progress : easing(progress);
+    if (!Number.isFinite(value)) {
+      throw new RangeError(
+        `Particle curve easing must return finite samples; received ${String(value)} at ${progress}.`
+      );
+    }
+    samples.push(value);
+  }
+  return Object.freeze(samples);
+}
+function sampleEasingTable(samples, progress) {
+  const scaled = clampProgress(progress) * PARTICLE_CURVE_SEGMENTS;
+  const lower = Math.floor(scaled);
+  if (lower >= PARTICLE_CURVE_SEGMENTS)
+    return samples[PARTICLE_CURVE_SEGMENTS];
+  const fraction = scaled - lower;
+  const from = samples[lower];
+  return from + (samples[lower + 1] - from) * fraction;
+}
+function findSegment(keys, time) {
+  let index = 0;
+  while (index + 1 < keys.length - 1 && time > keys[index + 1][0]) index += 1;
+  return index;
+}
+function segmentProgress(keys, segment, time) {
+  const from = keys[segment][0];
+  const to = keys[segment + 1][0];
+  return to === from ? 1 : (time - from) / (to - from);
+}
+function curveComponent(value, component) {
+  return typeof value === "number" ? value : value[component];
+}
+function compileParticleCurve(descriptor) {
+  const record = getParticleDescriptorRecord(descriptor);
+  if (record?.type !== "curve") {
+    throw new TypeError("Expected a curve created by particleCurve().");
+  }
+  const dimension = typeof record.keys[0][1] === "number" ? 1 : 2;
+  const easing = compileEasingTable(record.options?.easing);
+  const samples = [];
+  for (let index = 0; index < PARTICLE_CURVE_POINT_COUNT; index += 1) {
+    const time = index / PARTICLE_CURVE_SEGMENTS;
+    const segment = findSegment(record.keys, time);
+    const from = record.keys[segment][1];
+    const to = record.keys[segment + 1][1];
+    const progress = sampleEasingTable(
+      easing,
+      segmentProgress(record.keys, segment, time)
+    );
+    for (let component = 0; component < dimension; component += 1) {
+      const start = curveComponent(from, component);
+      samples.push(start + (curveComponent(to, component) - start) * progress);
+    }
+  }
+  return Object.freeze({
+    dimension,
+    pointCount: PARTICLE_CURVE_POINT_COUNT,
+    samples: Object.freeze(samples)
+  });
+}
+function sampleParticleCurve(curve, normalizedAge, component) {
+  const scaled = clampProgress(normalizedAge) * PARTICLE_CURVE_SEGMENTS;
+  const lower = Math.floor(scaled);
+  const lowerValue = curve.samples[lower * curve.dimension + component];
+  if (lower >= PARTICLE_CURVE_SEGMENTS) return lowerValue;
+  const fraction = scaled - lower;
+  const upperValue = curve.samples[(lower + 1) * curve.dimension + component];
+  return lowerValue + (upperValue - lowerValue) * fraction;
+}
+function compileParticleGradient(descriptor) {
+  const record = getParticleDescriptorRecord(descriptor);
+  if (record?.type !== "gradient") {
+    throw new TypeError("Expected a gradient created by particleGradient().");
+  }
+  const easing = compileEasingTable(record.options?.easing);
+  const samples = [];
+  const cssSamples = [];
+  for (let index = 0; index < PARTICLE_CURVE_POINT_COUNT; index += 1) {
+    const time = index / PARTICLE_CURVE_SEGMENTS;
+    const segment = findSegment(record.keys, time);
+    const from = parseParticleColor(record.keys[segment][1]);
+    const to = parseParticleColor(record.keys[segment + 1][1]);
+    const progress = sampleEasingTable(
+      easing,
+      segmentProgress(record.keys, segment, time)
+    );
+    const red = clampProgress(from[0] + (to[0] - from[0]) * progress);
+    const green = clampProgress(from[1] + (to[1] - from[1]) * progress);
+    const blue = clampProgress(from[2] + (to[2] - from[2]) * progress);
+    const alpha = clampProgress(from[3] + (to[3] - from[3]) * progress);
+    samples.push(red, green, blue, alpha);
+    cssSamples.push(
+      `rgba(${red * 255} ${green * 255} ${blue * 255} / ${alpha})`
+    );
+  }
+  return Object.freeze({
+    pointCount: PARTICLE_CURVE_POINT_COUNT,
+    samples: Object.freeze(samples),
+    cssSamples: Object.freeze(cssSamples)
+  });
+}
+function sampleParticleGradient(gradient, normalizedAge, output, offset) {
+  const index = Math.round(clampProgress(normalizedAge) * PARTICLE_CURVE_SEGMENTS) * 4;
+  output[offset] = gradient.samples[index];
+  output[offset + 1] = gradient.samples[index + 1];
+  output[offset + 2] = gradient.samples[index + 2];
+  output[offset + 3] = gradient.samples[index + 3];
+}
+export {
+  PARTICLE_CURVE_POINT_COUNT,
+  compileEasingTable,
+  compileParticleCurve,
+  compileParticleGradient,
+  sampleEasingTable,
+  sampleParticleCurve,
+  sampleParticleGradient
+};
+//# sourceMappingURL=curve.js.map