@pibbl/core 0.0.1

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

@@ -0,0 +1,397 @@
+import { sampleParticleCurve, sampleParticleGradient } from "./curve.js";
+import { sampleBetween, sampleInteger, sampleUnit } from "./random.js";
+const TAU = Math.PI * 2;
+let particleSamples = 0;
+const sampleArrayAllocations = 0;
+const sampleObjectAllocations = 0;
+function particleSamplerPerformanceSnapshot() {
+  return Object.freeze({
+    samples: particleSamples,
+    sampleArrayAllocations,
+    sampleObjectAllocations
+  });
+}
+var Particle2DRegister = /* @__PURE__ */ ((Particle2DRegister2) => {
+  Particle2DRegister2[Particle2DRegister2["Live"] = 0] = "Live";
+  Particle2DRegister2[Particle2DRegister2["X"] = 1] = "X";
+  Particle2DRegister2[Particle2DRegister2["Y"] = 2] = "Y";
+  Particle2DRegister2[Particle2DRegister2["VelocityX"] = 3] = "VelocityX";
+  Particle2DRegister2[Particle2DRegister2["VelocityY"] = 4] = "VelocityY";
+  Particle2DRegister2[Particle2DRegister2["SizeX"] = 5] = "SizeX";
+  Particle2DRegister2[Particle2DRegister2["SizeY"] = 6] = "SizeY";
+  Particle2DRegister2[Particle2DRegister2["Rotation"] = 7] = "Rotation";
+  Particle2DRegister2[Particle2DRegister2["Red"] = 8] = "Red";
+  Particle2DRegister2[Particle2DRegister2["Green"] = 9] = "Green";
+  Particle2DRegister2[Particle2DRegister2["Blue"] = 10] = "Blue";
+  Particle2DRegister2[Particle2DRegister2["Alpha"] = 11] = "Alpha";
+  Particle2DRegister2[Particle2DRegister2["AtlasFrame"] = 12] = "AtlasFrame";
+  return Particle2DRegister2;
+})(Particle2DRegister || {});
+function scalar(value, birth, emitterHash, parameters) {
+  switch (value.kind) {
+    case "constant":
+      return value.value;
+    case "between":
+      return sampleBetween(
+        sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel),
+        value.min,
+        value.max
+      );
+    case "integer":
+      return sampleInteger(
+        sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel),
+        value.min,
+        value.max
+      );
+    case "choice": {
+      const target = sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel) * value.choice.totalWeight;
+      for (let index = 0; index < value.choice.cumulativeWeights.length; index += 1) {
+        if (target < value.choice.cumulativeWeights[index]) {
+          return value.choice.values[index];
+        }
+      }
+      return value.choice.values[value.choice.values.length - 1];
+    }
+    case "parameter":
+      return parameters[value.offset];
+  }
+}
+function vectorComponent(value, component, birth, emitterHash, parameters) {
+  if (Array.isArray(value)) {
+    return scalar(value[component], birth, emitterHash, parameters);
+  }
+  return parameters[value.offset + component];
+}
+function color(value, birth, emitterHash, parameters, output, offset) {
+  if (value.kind === "constant") {
+    output[offset] = value.color[0];
+    output[offset + 1] = value.color[1];
+    output[offset + 2] = value.color[2];
+    output[offset + 3] = value.color[3];
+    return;
+  }
+  if (value.kind === "parameter") {
+    output[offset] = parameters[value.offset];
+    output[offset + 1] = parameters[value.offset + 1];
+    output[offset + 2] = parameters[value.offset + 2];
+    output[offset + 3] = parameters[value.offset + 3];
+    return;
+  }
+  const target = sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel) * value.totalWeight;
+  let selected = value.samples.length - 1;
+  for (let index = 0; index < value.cumulativeWeights.length; index += 1) {
+    if (target < value.cumulativeWeights[index]) {
+      selected = index;
+      break;
+    }
+  }
+  const selectedColor = value.samples[selected];
+  output[offset] = selectedColor[0];
+  output[offset + 1] = selectedColor[1];
+  output[offset + 2] = selectedColor[2];
+  output[offset + 3] = selectedColor[3];
+}
+function sampleCircleRadius(unit, radius) {
+  return Math.sqrt(unit) * radius;
+}
+function sampleShape2D(shape, unit0, unit1, _unit2, output, offset) {
+  switch (shape.type) {
+    case "point":
+      output[offset] = shape.position?.[0] ?? 0;
+      output[offset + 1] = shape.position?.[1] ?? 0;
+      return;
+    case "line":
+      output[offset] = shape.from[0] + (shape.to[0] - shape.from[0]) * unit0;
+      output[offset + 1] = shape.from[1] + (shape.to[1] - shape.from[1]) * unit0;
+      return;
+    case "rectangle": {
+      if (shape.sample === "interior") {
+        output[offset] = (unit0 - 0.5) * shape.width;
+        output[offset + 1] = (unit1 - 0.5) * shape.height;
+        return;
+      }
+      let distance = unit0 * 2 * (shape.width + shape.height);
+      if (distance < shape.width) {
+        output[offset] = -shape.width / 2 + distance;
+        output[offset + 1] = -shape.height / 2;
+        return;
+      }
+      distance -= shape.width;
+      if (distance < shape.height) {
+        output[offset] = shape.width / 2;
+        output[offset + 1] = -shape.height / 2 + distance;
+        return;
+      }
+      distance -= shape.height;
+      if (distance < shape.width) {
+        output[offset] = shape.width / 2 - distance;
+        output[offset + 1] = shape.height / 2;
+        return;
+      }
+      output[offset] = -shape.width / 2;
+      output[offset + 1] = shape.height / 2 - (distance - shape.width);
+      return;
+    }
+    case "circle": {
+      const radius = shape.sample === "interior" ? sampleCircleRadius(unit0, shape.radius) : shape.radius;
+      const angle = unit1 * TAU;
+      output[offset] = Math.cos(angle) * radius;
+      output[offset + 1] = Math.sin(angle) * radius;
+      return;
+    }
+    case "ring": {
+      const innerSquared = shape.innerRadius * shape.innerRadius;
+      const radius = Math.sqrt(
+        innerSquared + unit0 * (shape.outerRadius * shape.outerRadius - innerSquared)
+      );
+      const angle = unit1 * TAU;
+      output[offset] = Math.cos(angle) * radius;
+      output[offset + 1] = Math.sin(angle) * radius;
+      return;
+    }
+  }
+}
+function sampleEmitterShape2D(plan, birth, output) {
+  sampleShape2D(
+    plan.shape,
+    sampleUnit(
+      birth.seed,
+      plan.emitterHash,
+      birth.ordinal,
+      plan.shapeChannels[0]
+    ),
+    sampleUnit(
+      birth.seed,
+      plan.emitterHash,
+      birth.ordinal,
+      plan.shapeChannels[1]
+    ),
+    sampleUnit(
+      birth.seed,
+      plan.emitterHash,
+      birth.ordinal,
+      plan.shapeChannels[2]
+    ),
+    output,
+    1 /* X */
+  );
+}
+function sampleParticle2D(plan, birth, effectTimeMilliseconds, parameters, output) {
+  particleSamples += 1;
+  const ageMilliseconds = effectTimeMilliseconds - birth.birthTimeMilliseconds;
+  const lifetimeMilliseconds = scalar(
+    plan.initial.lifetime,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  if (ageMilliseconds < 0 || ageMilliseconds >= lifetimeMilliseconds) {
+    output[0 /* Live */] = 0;
+    return false;
+  }
+  const ageSeconds = ageMilliseconds / 1e3;
+  const normalizedAge = ageMilliseconds / lifetimeMilliseconds;
+  output[0 /* Live */] = 1;
+  sampleEmitterShape2D(plan, birth, output);
+  const originX = output[1 /* X */];
+  const originY = output[2 /* Y */];
+  const initialVelocityX = vectorComponent(
+    plan.initial.velocity,
+    0,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  const initialVelocityY = vectorComponent(
+    plan.initial.velocity,
+    1,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  let accelerationX = 0;
+  let accelerationY = 0;
+  let driftX = 0;
+  let driftY = 0;
+  let drag = 0;
+  let swayX = 0;
+  let swayVelocityX = 0;
+  let angularVelocity = scalar(
+    plan.initial.angularVelocity,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  let orbitCenterX = 0;
+  let orbitCenterY = 0;
+  let orbitDegrees = 0;
+  let hasOrbit = false;
+  for (let moduleIndex = 0; moduleIndex < plan.motion.length; moduleIndex += 1) {
+    const module = plan.motion[moduleIndex];
+    switch (module.type) {
+      case "acceleration":
+      case "gravity":
+        accelerationX += vectorComponent(
+          module.value,
+          0,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        accelerationY += vectorComponent(
+          module.value,
+          1,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        break;
+      case "drift":
+        driftX += vectorComponent(
+          module.value,
+          0,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        driftY += vectorComponent(
+          module.value,
+          1,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        break;
+      case "drag":
+        drag += scalar(module.amount, birth, plan.emitterHash, parameters);
+        break;
+      case "radialAcceleration": {
+        const dx = originX - module.center[0];
+        const dy = originY - module.center[1];
+        const length = Math.hypot(dx, dy);
+        if (length !== 0) {
+          const amount = scalar(
+            module.amount,
+            birth,
+            plan.emitterHash,
+            parameters
+          );
+          accelerationX += dx / length * amount;
+          accelerationY += dy / length * amount;
+        }
+        break;
+      }
+      case "orbit":
+        hasOrbit = true;
+        orbitCenterX = module.center[0];
+        orbitCenterY = module.center[1];
+        orbitDegrees = scalar(
+          module.degreesPerSecond,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        break;
+      case "sway": {
+        const amplitude = scalar(
+          module.amplitude,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        const frequency = scalar(
+          module.frequency,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        const angularFrequency = TAU * frequency;
+        swayX += amplitude * Math.sin(angularFrequency * ageSeconds);
+        swayVelocityX += amplitude * angularFrequency * Math.cos(angularFrequency * ageSeconds);
+        break;
+      }
+      case "angularVelocity":
+        angularVelocity += scalar(
+          module.degreesPerSecond,
+          birth,
+          plan.emitterHash,
+          parameters
+        );
+        break;
+    }
+  }
+  const dragDecay = drag === 0 ? 1 : Math.exp(-drag * ageSeconds);
+  const dragIntegral = drag === 0 ? ageSeconds : (1 - dragDecay) / drag;
+  let x = originX + initialVelocityX * dragIntegral + driftX * ageSeconds + 0.5 * accelerationX * ageSeconds * ageSeconds + swayX;
+  let y = originY + initialVelocityY * dragIntegral + driftY * ageSeconds + 0.5 * accelerationY * ageSeconds * ageSeconds;
+  let velocityX = initialVelocityX * dragDecay + driftX + accelerationX * ageSeconds + swayVelocityX;
+  let velocityY = initialVelocityY * dragDecay + driftY + accelerationY * ageSeconds;
+  if (hasOrbit) {
+    const radians = orbitDegrees * ageSeconds * Math.PI / 180;
+    const radiansPerSecond = orbitDegrees * Math.PI / 180;
+    const cosine = Math.cos(radians);
+    const sine = Math.sin(radians);
+    const dx = x - orbitCenterX;
+    const dy = y - orbitCenterY;
+    const rotatedVelocityX = velocityX * cosine - velocityY * sine;
+    const rotatedVelocityY = velocityX * sine + velocityY * cosine;
+    x = orbitCenterX + dx * cosine - dy * sine;
+    y = orbitCenterY + dx * sine + dy * cosine;
+    velocityX = rotatedVelocityX - radiansPerSecond * (y - orbitCenterY);
+    velocityY = rotatedVelocityY + radiansPerSecond * (x - orbitCenterX);
+  }
+  output[1 /* X */] = x;
+  output[2 /* Y */] = y;
+  output[3 /* VelocityX */] = velocityX;
+  output[4 /* VelocityY */] = velocityY;
+  const initialSizeX = vectorComponent(
+    plan.initial.size,
+    0,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  const initialSizeY = vectorComponent(
+    plan.initial.size,
+    1,
+    birth,
+    plan.emitterHash,
+    parameters
+  );
+  output[5 /* SizeX */] = plan.appearance.size === null ? initialSizeX : sampleParticleCurve(plan.appearance.size, normalizedAge, 0);
+  output[6 /* SizeY */] = plan.appearance.size === null ? initialSizeY : sampleParticleCurve(
+    plan.appearance.size,
+    normalizedAge,
+    plan.appearance.size.dimension === 1 ? 0 : 1
+  );
+  const initialRotation = scalar(plan.initial.rotation, birth, plan.emitterHash, parameters) + angularVelocity * ageSeconds;
+  output[7 /* Rotation */] = plan.appearance.rotation === null ? initialRotation : sampleParticleCurve(plan.appearance.rotation, normalizedAge, 0);
+  color(
+    plan.initial.color,
+    birth,
+    plan.emitterHash,
+    parameters,
+    output,
+    8 /* Red */
+  );
+  if (plan.appearance.color !== null) {
+    sampleParticleGradient(
+      plan.appearance.color,
+      normalizedAge,
+      output,
+      8 /* Red */
+    );
+  }
+  const opacity = plan.appearance.opacity === null ? scalar(plan.initial.opacity, birth, plan.emitterHash, parameters) : sampleParticleCurve(plan.appearance.opacity, normalizedAge, 0);
+  output[11 /* Alpha */] *= opacity;
+  output[12 /* AtlasFrame */] = 0;
+  return true;
+}
+export {
+  Particle2DRegister,
+  particleSamplerPerformanceSnapshot,
+  sampleCircleRadius,
+  sampleParticle2D,
+  sampleShape2D
+};
+//# sourceMappingURL=sample.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/particles/lib/sample.ts"],
+  "sourcesContent": ["import type {\n  CompiledColor,\n  CompiledEmitter2D,\n  CompiledScalar,\n  CompiledVector2,\n} from \"./compiler.js\";\nimport { sampleParticleCurve, sampleParticleGradient } from \"./curve.js\";\nimport { sampleBetween, sampleInteger, sampleUnit } from \"./random.js\";\nimport type { PibblParticleShape2D } from \"./types.js\";\n\nconst TAU = Math.PI * 2;\nlet particleSamples = 0;\nconst sampleArrayAllocations = 0;\nconst sampleObjectAllocations = 0;\n\nexport interface ParticleSamplerPerformanceSnapshot {\n  readonly samples: number;\n  readonly sampleArrayAllocations: number;\n  readonly sampleObjectAllocations: number;\n}\n\n/** @internal Deterministic structural counters for the particle hot loop. */\nexport function particleSamplerPerformanceSnapshot(): ParticleSamplerPerformanceSnapshot {\n  return Object.freeze({\n    samples: particleSamples,\n    sampleArrayAllocations,\n    sampleObjectAllocations,\n  });\n}\n\nexport const enum Particle2DRegister {\n  Live,\n  X,\n  Y,\n  VelocityX,\n  VelocityY,\n  SizeX,\n  SizeY,\n  Rotation,\n  Red,\n  Green,\n  Blue,\n  Alpha,\n  AtlasFrame,\n}\n\nexport interface ParticleBirthView {\n  readonly seed: number;\n  readonly ordinal: number;\n  readonly birthTimeMilliseconds: number;\n}\n\nfunction scalar(\n  value: CompiledScalar,\n  birth: ParticleBirthView,\n  emitterHash: number,\n  parameters: Readonly<Float64Array>,\n): number {\n  switch (value.kind) {\n    case \"constant\":\n      return value.value;\n    case \"between\":\n      return sampleBetween(\n        sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel),\n        value.min,\n        value.max,\n      );\n    case \"integer\":\n      return sampleInteger(\n        sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel),\n        value.min,\n        value.max,\n      );\n    case \"choice\": {\n      const target =\n        sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel) *\n        value.choice.totalWeight;\n      for (\n        let index = 0;\n        index < value.choice.cumulativeWeights.length;\n        index += 1\n      ) {\n        if (target < value.choice.cumulativeWeights[index]!) {\n          return value.choice.values[index]!;\n        }\n      }\n      return value.choice.values[value.choice.values.length - 1]!;\n    }\n    case \"parameter\":\n      return parameters[value.offset]!;\n  }\n}\n\nfunction vectorComponent(\n  value: CompiledVector2,\n  component: number,\n  birth: ParticleBirthView,\n  emitterHash: number,\n  parameters: Readonly<Float64Array>,\n): number {\n  if (Array.isArray(value)) {\n    return scalar(value[component]!, birth, emitterHash, parameters);\n  }\n  return parameters[(value as { readonly offset: number }).offset + component]!;\n}\n\nfunction color(\n  value: CompiledColor,\n  birth: ParticleBirthView,\n  emitterHash: number,\n  parameters: Readonly<Float64Array>,\n  output: Float64Array,\n  offset: number,\n): void {\n  if (value.kind === \"constant\") {\n    output[offset] = value.color[0];\n    output[offset + 1] = value.color[1];\n    output[offset + 2] = value.color[2];\n    output[offset + 3] = value.color[3];\n    return;\n  }\n  if (value.kind === \"parameter\") {\n    output[offset] = parameters[value.offset]!;\n    output[offset + 1] = parameters[value.offset + 1]!;\n    output[offset + 2] = parameters[value.offset + 2]!;\n    output[offset + 3] = parameters[value.offset + 3]!;\n    return;\n  }\n  const target =\n    sampleUnit(birth.seed, emitterHash, birth.ordinal, value.channel) *\n    value.totalWeight;\n  let selected = value.samples.length - 1;\n  for (let index = 0; index < value.cumulativeWeights.length; index += 1) {\n    if (target < value.cumulativeWeights[index]!) {\n      selected = index;\n      break;\n    }\n  }\n  const selectedColor = value.samples[selected]!;\n  output[offset] = selectedColor[0];\n  output[offset + 1] = selectedColor[1];\n  output[offset + 2] = selectedColor[2];\n  output[offset + 3] = selectedColor[3];\n}\n\nexport function sampleCircleRadius(unit: number, radius: number): number {\n  return Math.sqrt(unit) * radius;\n}\n\nexport function sampleShape2D(\n  shape: PibblParticleShape2D,\n  unit0: number,\n  unit1: number,\n  _unit2: number,\n  output: Float64Array,\n  offset: number,\n): void {\n  switch (shape.type) {\n    case \"point\":\n      output[offset] = shape.position?.[0] ?? 0;\n      output[offset + 1] = shape.position?.[1] ?? 0;\n      return;\n    case \"line\":\n      output[offset] = shape.from[0] + (shape.to[0] - shape.from[0]) * unit0;\n      output[offset + 1] =\n        shape.from[1] + (shape.to[1] - shape.from[1]) * unit0;\n      return;\n    case \"rectangle\": {\n      if (shape.sample === \"interior\") {\n        output[offset] = (unit0 - 0.5) * shape.width;\n        output[offset + 1] = (unit1 - 0.5) * shape.height;\n        return;\n      }\n      let distance = unit0 * 2 * (shape.width + shape.height);\n      if (distance < shape.width) {\n        output[offset] = -shape.width / 2 + distance;\n        output[offset + 1] = -shape.height / 2;\n        return;\n      }\n      distance -= shape.width;\n      if (distance < shape.height) {\n        output[offset] = shape.width / 2;\n        output[offset + 1] = -shape.height / 2 + distance;\n        return;\n      }\n      distance -= shape.height;\n      if (distance < shape.width) {\n        output[offset] = shape.width / 2 - distance;\n        output[offset + 1] = shape.height / 2;\n        return;\n      }\n      output[offset] = -shape.width / 2;\n      output[offset + 1] = shape.height / 2 - (distance - shape.width);\n      return;\n    }\n    case \"circle\": {\n      const radius =\n        shape.sample === \"interior\"\n          ? sampleCircleRadius(unit0, shape.radius)\n          : shape.radius;\n      const angle = unit1 * TAU;\n      output[offset] = Math.cos(angle) * radius;\n      output[offset + 1] = Math.sin(angle) * radius;\n      return;\n    }\n    case \"ring\": {\n      const innerSquared = shape.innerRadius * shape.innerRadius;\n      const radius = Math.sqrt(\n        innerSquared +\n          unit0 * (shape.outerRadius * shape.outerRadius - innerSquared),\n      );\n      const angle = unit1 * TAU;\n      output[offset] = Math.cos(angle) * radius;\n      output[offset + 1] = Math.sin(angle) * radius;\n      return;\n    }\n  }\n}\n\nfunction sampleEmitterShape2D(\n  plan: CompiledEmitter2D,\n  birth: ParticleBirthView,\n  output: Float64Array,\n): void {\n  sampleShape2D(\n    plan.shape,\n    sampleUnit(\n      birth.seed,\n      plan.emitterHash,\n      birth.ordinal,\n      plan.shapeChannels[0],\n    ),\n    sampleUnit(\n      birth.seed,\n      plan.emitterHash,\n      birth.ordinal,\n      plan.shapeChannels[1],\n    ),\n    sampleUnit(\n      birth.seed,\n      plan.emitterHash,\n      birth.ordinal,\n      plan.shapeChannels[2],\n    ),\n    output,\n    Particle2DRegister.X,\n  );\n}\n\nexport function sampleParticle2D(\n  plan: CompiledEmitter2D,\n  birth: ParticleBirthView,\n  effectTimeMilliseconds: number,\n  parameters: Readonly<Float64Array>,\n  output: Float64Array,\n): boolean {\n  particleSamples += 1;\n  const ageMilliseconds = effectTimeMilliseconds - birth.birthTimeMilliseconds;\n  const lifetimeMilliseconds = scalar(\n    plan.initial.lifetime,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  if (ageMilliseconds < 0 || ageMilliseconds >= lifetimeMilliseconds) {\n    output[Particle2DRegister.Live] = 0;\n    return false;\n  }\n  const ageSeconds = ageMilliseconds / 1_000;\n  const normalizedAge = ageMilliseconds / lifetimeMilliseconds;\n  output[Particle2DRegister.Live] = 1;\n  sampleEmitterShape2D(plan, birth, output);\n\n  const originX = output[Particle2DRegister.X]!;\n  const originY = output[Particle2DRegister.Y]!;\n  const initialVelocityX = vectorComponent(\n    plan.initial.velocity,\n    0,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  const initialVelocityY = vectorComponent(\n    plan.initial.velocity,\n    1,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  let accelerationX = 0;\n  let accelerationY = 0;\n  let driftX = 0;\n  let driftY = 0;\n  let drag = 0;\n  let swayX = 0;\n  let swayVelocityX = 0;\n  let angularVelocity = scalar(\n    plan.initial.angularVelocity,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  let orbitCenterX = 0;\n  let orbitCenterY = 0;\n  let orbitDegrees = 0;\n  let hasOrbit = false;\n\n  for (\n    let moduleIndex = 0;\n    moduleIndex < plan.motion.length;\n    moduleIndex += 1\n  ) {\n    const module = plan.motion[moduleIndex]!;\n    switch (module.type) {\n      case \"acceleration\":\n      case \"gravity\":\n        accelerationX += vectorComponent(\n          module.value,\n          0,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        accelerationY += vectorComponent(\n          module.value,\n          1,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        break;\n      case \"drift\":\n        driftX += vectorComponent(\n          module.value,\n          0,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        driftY += vectorComponent(\n          module.value,\n          1,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        break;\n      case \"drag\":\n        drag += scalar(module.amount, birth, plan.emitterHash, parameters);\n        break;\n      case \"radialAcceleration\": {\n        const dx = originX - module.center[0];\n        const dy = originY - module.center[1];\n        const length = Math.hypot(dx, dy);\n        if (length !== 0) {\n          const amount = scalar(\n            module.amount,\n            birth,\n            plan.emitterHash,\n            parameters,\n          );\n          accelerationX += (dx / length) * amount;\n          accelerationY += (dy / length) * amount;\n        }\n        break;\n      }\n      case \"orbit\":\n        hasOrbit = true;\n        orbitCenterX = module.center[0];\n        orbitCenterY = module.center[1];\n        orbitDegrees = scalar(\n          module.degreesPerSecond,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        break;\n      case \"sway\": {\n        const amplitude = scalar(\n          module.amplitude,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        const frequency = scalar(\n          module.frequency,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        const angularFrequency = TAU * frequency;\n        swayX += amplitude * Math.sin(angularFrequency * ageSeconds);\n        swayVelocityX +=\n          amplitude *\n          angularFrequency *\n          Math.cos(angularFrequency * ageSeconds);\n        break;\n      }\n      case \"angularVelocity\":\n        angularVelocity += scalar(\n          module.degreesPerSecond,\n          birth,\n          plan.emitterHash,\n          parameters,\n        );\n        break;\n    }\n  }\n\n  const dragDecay = drag === 0 ? 1 : Math.exp(-drag * ageSeconds);\n  const dragIntegral = drag === 0 ? ageSeconds : (1 - dragDecay) / drag;\n  let x =\n    originX +\n    initialVelocityX * dragIntegral +\n    driftX * ageSeconds +\n    0.5 * accelerationX * ageSeconds * ageSeconds +\n    swayX;\n  let y =\n    originY +\n    initialVelocityY * dragIntegral +\n    driftY * ageSeconds +\n    0.5 * accelerationY * ageSeconds * ageSeconds;\n  let velocityX =\n    initialVelocityX * dragDecay +\n    driftX +\n    accelerationX * ageSeconds +\n    swayVelocityX;\n  let velocityY =\n    initialVelocityY * dragDecay + driftY + accelerationY * ageSeconds;\n  if (hasOrbit) {\n    const radians = (orbitDegrees * ageSeconds * Math.PI) / 180;\n    const radiansPerSecond = (orbitDegrees * Math.PI) / 180;\n    const cosine = Math.cos(radians);\n    const sine = Math.sin(radians);\n    const dx = x - orbitCenterX;\n    const dy = y - orbitCenterY;\n    const rotatedVelocityX = velocityX * cosine - velocityY * sine;\n    const rotatedVelocityY = velocityX * sine + velocityY * cosine;\n    x = orbitCenterX + dx * cosine - dy * sine;\n    y = orbitCenterY + dx * sine + dy * cosine;\n    velocityX = rotatedVelocityX - radiansPerSecond * (y - orbitCenterY);\n    velocityY = rotatedVelocityY + radiansPerSecond * (x - orbitCenterX);\n  }\n  output[Particle2DRegister.X] = x;\n  output[Particle2DRegister.Y] = y;\n  output[Particle2DRegister.VelocityX] = velocityX;\n  output[Particle2DRegister.VelocityY] = velocityY;\n\n  const initialSizeX = vectorComponent(\n    plan.initial.size,\n    0,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  const initialSizeY = vectorComponent(\n    plan.initial.size,\n    1,\n    birth,\n    plan.emitterHash,\n    parameters,\n  );\n  output[Particle2DRegister.SizeX] =\n    plan.appearance.size === null\n      ? initialSizeX\n      : sampleParticleCurve(plan.appearance.size, normalizedAge, 0);\n  output[Particle2DRegister.SizeY] =\n    plan.appearance.size === null\n      ? initialSizeY\n      : sampleParticleCurve(\n          plan.appearance.size,\n          normalizedAge,\n          plan.appearance.size.dimension === 1 ? 0 : 1,\n        );\n  const initialRotation =\n    scalar(plan.initial.rotation, birth, plan.emitterHash, parameters) +\n    angularVelocity * ageSeconds;\n  output[Particle2DRegister.Rotation] =\n    plan.appearance.rotation === null\n      ? initialRotation\n      : sampleParticleCurve(plan.appearance.rotation, normalizedAge, 0);\n  color(\n    plan.initial.color,\n    birth,\n    plan.emitterHash,\n    parameters,\n    output,\n    Particle2DRegister.Red,\n  );\n  if (plan.appearance.color !== null) {\n    sampleParticleGradient(\n      plan.appearance.color,\n      normalizedAge,\n      output,\n      Particle2DRegister.Red,\n    );\n  }\n  const opacity =\n    plan.appearance.opacity === null\n      ? scalar(plan.initial.opacity, birth, plan.emitterHash, parameters)\n      : sampleParticleCurve(plan.appearance.opacity, normalizedAge, 0);\n  output[Particle2DRegister.Alpha] *= opacity;\n  output[Particle2DRegister.AtlasFrame] = 0;\n  return true;\n}\n"],
+  "mappings": "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",
+  "names": ["Particle2DRegister"]
+}

package/dist/features/particles/lib/signal-inputs.d.ts

@@ -0,0 +1,6 @@
+import { type SignalValue } from "@pibbl/core";
+export type SignalFields<T extends object> = {
+    readonly [K in keyof T]: SignalValue<T[K]>;
+};
+export declare function resolveSignalFields<T extends object>(input: SignalValue<SignalFields<T>>): T;
+export declare function resolveDeclaredParticleProps<T extends object>(source: T, preserve: ReadonlySet<PropertyKey>, styleKey: keyof T | undefined): T;

package/dist/features/particles/lib/signal-inputs.js

@@ -0,0 +1,41 @@
+import {
+  isSignal,
+  resolveSignalValue
+} from "@pibbl/core";
+function resolveSignalFields(input) {
+  const source = resolveSignalValue(input);
+  let resolved;
+  for (const key in source) {
+    const value = source[key];
+    if (!isSignal(value)) continue;
+    resolved ??= { ...source };
+    resolved[key] = resolveSignalValue(value);
+  }
+  return resolved ?? source;
+}
+function resolveDeclaredParticleProps(source, preserve, styleKey) {
+  let resolved;
+  for (const key in source) {
+    if (preserve.has(key)) continue;
+    const value = source[key];
+    if (styleKey === key && value !== void 0) {
+      const style = resolveSignalFields(
+        value
+      );
+      if (style !== value) {
+        resolved ??= { ...source };
+        resolved[key] = style;
+      }
+      continue;
+    }
+    if (!isSignal(value)) continue;
+    resolved ??= { ...source };
+    resolved[key] = resolveSignalValue(value);
+  }
+  return resolved ?? source;
+}
+export {
+  resolveDeclaredParticleProps,
+  resolveSignalFields
+};
+//# sourceMappingURL=signal-inputs.js.map

package/dist/features/particles/lib/signal-inputs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/particles/lib/signal-inputs.ts"],
+  "sourcesContent": ["import {\n  isSignal,\n  resolveSignalValue,\n  type SignalValue,\n} from \"@pibbl/core\";\n\nexport type SignalFields<T extends object> = {\n  readonly [K in keyof T]: SignalValue<T[K]>;\n};\n\nexport function resolveSignalFields<T extends object>(\n  input: SignalValue<SignalFields<T>>,\n): T {\n  const source = resolveSignalValue(input);\n  let resolved: Record<PropertyKey, unknown> | undefined;\n  for (const key in source) {\n    const value = source[key as keyof SignalFields<T>];\n    if (!isSignal(value)) continue;\n    resolved ??= { ...source } as Record<PropertyKey, unknown>;\n    resolved[key] = resolveSignalValue(value as SignalValue<unknown>);\n  }\n  return (resolved ?? source) as T;\n}\n\nexport function resolveDeclaredParticleProps<T extends object>(\n  source: T,\n  preserve: ReadonlySet<PropertyKey>,\n  styleKey: keyof T | undefined,\n): T {\n  let resolved: Record<PropertyKey, unknown> | undefined;\n  for (const key in source) {\n    if (preserve.has(key)) continue;\n    const value = source[key as keyof T];\n    if (styleKey === key && value !== undefined) {\n      const style = resolveSignalFields(\n        value as SignalValue<SignalFields<object>>,\n      );\n      if (style !== value) {\n        resolved ??= { ...source } as Record<PropertyKey, unknown>;\n        resolved[key] = style;\n      }\n      continue;\n    }\n    if (!isSignal(value)) continue;\n    resolved ??= { ...source } as Record<PropertyKey, unknown>;\n    resolved[key] = resolveSignalValue(value as SignalValue<unknown>);\n  }\n  return (resolved ?? source) as T;\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AAMA,SAAS,oBACd,OACG;AACH,QAAM,SAAS,mBAAmB,KAAK;AACvC,MAAI;AACJ,aAAW,OAAO,QAAQ;AACxB,UAAM,QAAQ,OAAO,GAA4B;AACjD,QAAI,CAAC,SAAS,KAAK,EAAG;AACtB,iBAAa,EAAE,GAAG,OAAO;AACzB,aAAS,GAAG,IAAI,mBAAmB,KAA6B;AAAA,EAClE;AACA,SAAQ,YAAY;AACtB;AAEO,SAAS,6BACd,QACA,UACA,UACG;AACH,MAAI;AACJ,aAAW,OAAO,QAAQ;AACxB,QAAI,SAAS,IAAI,GAAG,EAAG;AACvB,UAAM,QAAQ,OAAO,GAAc;AACnC,QAAI,aAAa,OAAO,UAAU,QAAW;AAC3C,YAAM,QAAQ;AAAA,QACZ;AAAA,MACF;AACA,UAAI,UAAU,OAAO;AACnB,qBAAa,EAAE,GAAG,OAAO;AACzB,iBAAS,GAAG,IAAI;AAAA,MAClB;AACA;AAAA,IACF;AACA,QAAI,CAAC,SAAS,KAAK,EAAG;AACtB,iBAAa,EAAE,GAAG,OAAO;AACzB,aAAS,GAAG,IAAI,mBAAmB,KAA6B;AAAA,EAClE;AACA,SAAQ,YAAY;AACtB;",
+  "names": []
+}

package/dist/features/particles/lib/system/binding.d.ts

@@ -0,0 +1,59 @@
+import { type PibblInternalRenderOwner } from "@pibbl/core/internal";
+import type { CompiledEffect2D } from "../compiler.js";
+import type { PibblParticleExecution, PibblParticleSystem, PibblParticleSystemEvent, PibblParticleSystemStatus } from "../types.js";
+export type CompiledParticleEffect = CompiledEffect2D;
+export interface ParticleBindingFrameState {
+    readonly liveCount: number;
+    readonly nextAutomaticBirthMilliseconds: number | null;
+    readonly latestDeathMilliseconds: number | null;
+}
+export interface ParticleBindingBurstRequest {
+    readonly generation: number;
+    readonly emitterIndex: number;
+    readonly count: number | undefined;
+    readonly birthTimeMilliseconds: number;
+    readonly seed: number;
+    readonly seedSalt: number;
+    readonly origin: readonly [number, number];
+    readonly spawnEpoch: number;
+}
+export interface ParticleBindingBurstResult extends ParticleBindingFrameState {
+    readonly requested: number;
+    readonly accepted: number;
+    readonly rejected: number;
+}
+export interface ParticleBindingCandidate {
+    readonly owner: PibblInternalRenderOwner;
+    readonly backend: "canvas";
+    readonly execution: PibblParticleExecution;
+    readonly compiled: CompiledParticleEffect;
+    readonly parameters: Readonly<Float64Array>;
+    requestRender(): void;
+    adoptFrame(frame: ParticleSystemFrame): ParticleBindingFrameState | void;
+    requestedBurstCount?(emitterIndex: number, count: number | undefined, seed: number): number;
+    emitBurst?(request: ParticleBindingBurstRequest): ParticleBindingBurstResult;
+    clear(): ParticleBindingFrameState | void;
+    finishTransaction?(success: boolean): void;
+    dispose(): void;
+}
+export interface ParticleSystemFrame {
+    readonly generation: number;
+    readonly frameId: number;
+    readonly logicalTime: number;
+    readonly effectTimeMilliseconds: number;
+    readonly previousEffectTimeMilliseconds: number;
+    readonly seed: number;
+    readonly status: PibblParticleSystemStatus;
+}
+export interface ParticleSystemBindingInput {
+    readonly system: PibblParticleSystem;
+    readonly backend: "canvas";
+    readonly create: (owner: PibblInternalRenderOwner) => ParticleBindingCandidate;
+    readonly onEvent?: (event: PibblParticleSystemEvent) => void;
+    readonly onError?: (error: unknown) => void;
+}
+/**
+ * Reserves, validates, and transactionally adopts one renderer-owned particle
+ * candidate. The factory is deliberately called only after conflict checking.
+ */
+export declare function useParticleSystemBinding(input: ParticleSystemBindingInput): ParticleBindingCandidate;