paperlab 0.7.1 → 0.8.0

package/dist/fx.js

@@ -31,11 +31,11 @@ import {
   luminance,
   srgbToLinear,
   timesPaperWhite
-} from "./chunk-GB6BMHC3.js";
+} from "./chunk-7WOGU2D4.js";
 import {
   DAMAGE_CHANNELS,
   DAMAGE_LOOK_DEFAULTS
-} from "./chunk-7TLIWPGM.js";
+} from "./chunk-232SU3AQ.js";
 
 // src/fx/particles.ts
 var particlePresets = {
@@ -90,7 +90,13 @@ var particlePresets = {
    * simulation, on purpose; see the fx plan.
    */
   smoke: {
-    life: [1.8, 3.5],
+    // Shorter, and smaller below: these are the thread beside the
+    // simulator's smoke, and the simulator's is gone within a second or two
+    // of the last flame. Left to live three and a half seconds and grow to
+    // seven centimetres, the last few of them overlapped into a flat wash
+    // over the hole with nothing left to move them — the one moment of a
+    // burn Noor found the smoke wrong (2026-09-13).
+    life: [1.4, 2.6],
     speed: [0.05, 0.15],
     direction: [0, 1, 0],
     spread: 0.3,
@@ -98,13 +104,13 @@ var particlePresets = {
     drag: 0.9,
     jitter: 0.3,
     windCatch: 1,
-    size: [0.05, 0.35],
+    size: [0.05, 0.18],
     // #6B6560 grey-brown, linear, and thin — the background stays clear.
     color: [
       [0.147, 0.13, 0.117],
       [0.2, 0.19, 0.18]
     ],
-    alpha: [0.08, 0],
+    alpha: [0.07, 0],
     spin: 0.4,
     blend: "normal",
     shape: "soft",
@@ -116,7 +122,9 @@ var particlePresets = {
    * burn that proves paper was there.
    */
   ash: {
-    life: [2.5, 5],
+    // A second or two: ash that hung in the air for five read as grey
+    // confetti over the hole, dust or stars rather than something falling.
+    life: [1.2, 2.6],
     // Thrown UP by the heat it came off, before it is heavier than the air.
     // It used to leave at almost nothing (0.02–0.1) with a lift of −0.35, so
     // every flake began falling the moment it was born — straight through the
@@ -124,7 +132,9 @@ var particlePresets = {
     speed: [0.14, 0.3],
     direction: [0, 1, 0],
     spread: 0.55,
-    lift: -0.22,
+    // Heavier than the air once the throw is spent: most flakes tumble down,
+    // only the lightest ride the heat up a little first.
+    lift: -0.42,
     drag: 1.6,
     jitter: 1.2,
     windCatch: 1,
@@ -132,9 +142,11 @@ var particlePresets = {
     // 3.8 mm and there were far too many of them: a shower of specks rather
     // than a few flakes you would notice.
     size: [0.03, 0.026],
+    // Charred paper, near black: under a bright key the old value read as
+    // pale grey against the black stage, which is the confetti.
     color: [
-      [0.07, 0.065, 0.06],
-      [0.12, 0.115, 0.11]
+      [0.04, 0.037, 0.034],
+      [0.07, 0.066, 0.062]
     ],
     alpha: [0.95, 0],
     spin: 4,
@@ -358,13 +370,14 @@ var ParticlePool = class {
 
 // src/fx/fire.ts
 var fireEmitterDefaults = {
-  embers: 0.35,
-  smoke: 0,
-  ash: 0.12,
+  embers: 0.39,
+  smoke: 0.135,
+  ash: 0.36,
   seed: 7,
   caps: {}
 };
 var PER_UPDATE = 24;
+var CRACKLE_SPARKS = 0.06;
 var FireEmitter = class {
   field;
   pool;
@@ -401,7 +414,10 @@ var FireEmitter = class {
       heat /= front;
       const struggle = 0.35 + 1.6 * Math.max(0, 0.7 - heat) + air * 0.8;
       const oxygen = 1 + air * 1.5;
-      this.emberDebt = Math.min(this.emberDebt + front * o.embers * oxygen * dt, PER_UPDATE);
+      this.emberDebt = Math.min(
+        this.emberDebt + front * o.embers * oxygen * dt + field.lastStats.charred * o.embers * CRACKLE_SPARKS,
+        PER_UPDATE
+      );
       this.smokeDebt = Math.min(this.smokeDebt + front * o.smoke * struggle * dt, PER_UPDATE);
       while (this.emberDebt >= 1) {
         this.emberDebt -= 1;
@@ -757,7 +773,7 @@ function FxParticles({ pool }) {
 import { Suspense, lazy } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
 var Pass = lazy(
-  () => import("./FxPostPass-M66QMVVC.js").then((m) => ({ default: m.FxPostPass })).catch((error) => {
+  () => import("./FxPostPass-V6YDK4H2.js").then((m) => ({ default: m.FxPostPass })).catch((error) => {
     warnOnce(error);
     return { default: (() => null) };
   })
@@ -1742,10 +1758,17 @@ void main() {
   float rootMask = smoothstep(mix(0.4, 0.02, uRootReach), mix(0.6, 0.12, uRootReach), fuel) * (1.0 - smoothstep(0.25, 0.6, t));
   fire += uRootColor * rootMask * uRootAmount * uPaperWhite * uGlow * 0.6;
 
-  // Smoke: warm grey-brown (a cool grey over cream reads lavender), lit by
-  // the fire under it.
+  // Smoke: grey-brown, warm (a cool grey over cream reads lavender), and LIT
+  // BY THE FIRE UNDER IT rather than by nothing.
+  //
+  // The base used to be bright enough to read on its own \u2014 beige \u2014 which is
+  // right while flames are lighting it and wrong the moment they stop: the
+  // last of the smoke hung over a black stage as flat beige slabs, the same
+  // colour everywhere, which reads as a filled shape rather than as smoke
+  // (Noor, 2026-09-13). Dim at the base and warm where the fire is: smoke by
+  // the flames looks as it did, smoke after them goes to a dim grey.
   float smokeAlpha = 1.0 - exp(-smoke * uSmokeDensity);
-  vec3 smokeColor = vec3(0.16, 0.13, 0.10) + vec3(0.22, 0.09, 0.02) * smoothstep(0.15, 0.9, t);
+  vec3 smokeColor = vec3(0.075, 0.068, 0.062) + vec3(0.3, 0.14, 0.045) * smoothstep(0.12, 0.9, t);
   float alpha = smokeAlpha + fireAlpha - smokeAlpha * fireAlpha;
   // No square edge: the domain fades out before its borders.
   float edge = smoothstep(0.0, 0.06, vUv.x) * smoothstep(1.0, 0.94, vUv.x) * smoothstep(0.0, 0.03, vUv.y) * smoothstep(1.0, 0.9, vUv.y);
@@ -2544,55 +2567,261 @@ function FxFireFluid({
 import * as THREE6 from "three";
 import { useFrame as useFrame5 } from "@react-three/fiber";
 import { useRef as useRef4 } from "react";
-import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
-function FxFireLight({ field, locate, gain = FIRE_LIGHT_GAIN }) {
-  const front = useRef4(null);
-  const through = useRef4(null);
-  const anchors = useRef4([]);
-  useFrame5(({ camera }) => {
-    const a = front.current;
-    const b = through.current;
-    if (!a || !b) return;
-    const n = flameAnchors(field, locate, 32, anchors.current);
-    if (n === 0) {
-      a.intensity = 0;
-      b.intensity = 0;
-      return;
-    }
+
+// src/fx/fireState.ts
+var FLAMES = 32;
+var FIRE_CLUSTERS = 4;
+var CLUSTER_REACH = 25 / 210;
+var FireState = class {
+  constructor(field, locate) {
+    this.field = field;
+    this.locate = locate;
+  }
+  field;
+  locate;
+  /** The flames it was taken over. Only the first {@link count} are current. */
+  anchors = [];
+  count = 0;
+  /** Where the fire is, as a whole: its flames' mean. Zero with none. */
+  x = 0;
+  y = 0;
+  z = 0;
+  /** Its flames' mean height. */
+  height = 0;
+  /** Its flames' mean puff. */
+  flicker = 0;
+  /** Where it is gathered. Only the first {@link clusterCount} are current. */
+  clusters = [];
+  clusterCount = 0;
+  frame = Number.NaN;
+  order = [];
+  root = new Float64Array(FIRE_CLUSTERS * 3);
+  weight = new Float64Array(FIRE_CLUSTERS);
+  /**
+   * Bring it up to date for `frame` — any number that is the same for every
+   * reader in one frame and different in the next; R3F's `clock.elapsedTime`
+   * is the one in hand. Free the second time it is asked in a frame.
+   */
+  update(frame) {
+    if (frame === this.frame) return this;
+    this.frame = frame;
+    const { field, anchors } = this;
+    const n = flameAnchors(field, this.locate, FLAMES, anchors);
+    this.count = n;
     let x = 0;
     let y = 0;
     let z = 0;
     let h = 0;
     let flicker = 0;
     for (let i = 0; i < n; i++) {
-      const f = anchors.current[i];
+      const f = anchors[i];
       x += f.x;
       y += f.y;
       z += f.z;
       h += f.height;
       flicker += flamePuff(f.seed, field.time);
     }
-    x /= n;
-    y /= n;
-    z /= n;
-    h /= n;
-    flicker /= n;
-    const toCamera = new THREE6.Vector3(camera.position.x - x, 0, camera.position.z - z);
-    toCamera.normalize().multiplyScalar(0.035);
-    const lift = h * 0.5;
-    a.position.set(x + toCamera.x, y + lift, z + toCamera.z);
-    b.position.set(x - toCamera.x, y + lift, z - toCamera.z);
-    const level = field.lastStats.front * gain * flicker;
-    a.intensity = level;
-    b.intensity = level * 0.35;
+    if (n > 0) {
+      x /= n;
+      y /= n;
+      z /= n;
+      h /= n;
+      flicker /= n;
+    }
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.height = h;
+    this.flicker = flicker;
+    this.gather();
+    return this;
+  }
+  /**
+   * Group the flames into at most {@link FIRE_CLUSTERS} clusters.
+   *
+   * Tallest first, so each cluster is named by its tallest tongue and stands
+   * where that one stands: a flame joins the nearest cluster within
+   * {@link CLUSTER_REACH} of it, or starts one while there is room, or joins
+   * the nearest once there is not. Pure arithmetic over the flames, so the
+   * same burn gathers the same way every time.
+   */
+  gather() {
+    const anchors = this.anchors;
+    const clusters = this.clusters;
+    const order = this.order;
+    const root = this.root;
+    const weight = this.weight;
+    const n = this.count;
+    order.length = 0;
+    for (let i = 0; i < n; i++) order.push(i);
+    order.sort((i, j) => anchors[j].height - anchors[i].height || i - j);
+    let k = 0;
+    for (const i of order) {
+      const f = anchors[i];
+      let best = -1;
+      let near = Number.POSITIVE_INFINITY;
+      for (let c = 0; c < k; c++) {
+        const d = Math.hypot(f.x - root[c * 3], f.y - root[c * 3 + 1], f.z - root[c * 3 + 2]);
+        if (d < near) {
+          near = d;
+          best = c;
+        }
+      }
+      if (best < 0 || near > CLUSTER_REACH && k < FIRE_CLUSTERS) {
+        best = k++;
+        root[best * 3] = f.x;
+        root[best * 3 + 1] = f.y;
+        root[best * 3 + 2] = f.z;
+        weight[best] = 0;
+        let cluster2 = clusters[best];
+        if (!cluster2) {
+          cluster2 = { x: 0, y: 0, z: 0, height: 0, tallest: 0, flicker: 0, heat: 0, count: 0 };
+          clusters[best] = cluster2;
+        }
+        cluster2.x = 0;
+        cluster2.y = 0;
+        cluster2.z = 0;
+        cluster2.height = 0;
+        cluster2.tallest = f.height;
+        cluster2.flicker = 0;
+        cluster2.heat = 0;
+        cluster2.count = 0;
+      }
+      const cluster = clusters[best];
+      const w = f.height;
+      cluster.x += f.x * w;
+      cluster.y += f.y * w;
+      cluster.z += f.z * w;
+      weight[best] = weight[best] + w;
+      cluster.height += f.height;
+      cluster.flicker += flamePuff(f.seed, this.field.time);
+      cluster.heat += f.heat;
+      cluster.count++;
+    }
+    for (let c = 0; c < k; c++) {
+      const cluster = clusters[c];
+      const w = weight[c];
+      if (w > 0) {
+        cluster.x /= w;
+        cluster.y /= w;
+        cluster.z /= w;
+      } else {
+        cluster.x = root[c * 3];
+        cluster.y = root[c * 3 + 1];
+        cluster.z = root[c * 3 + 2];
+      }
+      cluster.height /= cluster.count;
+      cluster.flicker /= cluster.count;
+      cluster.heat /= cluster.count;
+    }
+    this.clusterCount = k;
+  }
+};
+var shared = /* @__PURE__ */ new WeakMap();
+function fireStateOf(field, locate) {
+  let byLocator = shared.get(field);
+  if (!byLocator) {
+    byLocator = /* @__PURE__ */ new WeakMap();
+    shared.set(field, byLocator);
+  }
+  let state = byLocator.get(locate);
+  if (!state) {
+    state = new FireState(field, locate);
+    byLocator.set(locate, state);
+  }
+  return state;
+}
+
+// src/fx/FxFireLight.tsx
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+function FxFireLight({ field, locate, gain = FIRE_LIGHT_GAIN, shadows = false }) {
+  const front = useRef4([]);
+  const through = useRef4(null);
+  const spot = useRef4(null);
+  useFrame5(({ camera, clock }) => {
+    const b = through.current;
+    if (!b) return;
+    const fire = fireStateOf(field, locate).update(clock.elapsedTime);
+    const level = field.lastStats.front * gain;
+    let total = 0;
+    let brightest = -1;
+    let most = 0;
+    for (let c = 0; c < fire.clusterCount; c++) {
+      const cluster = fire.clusters[c];
+      const share = cluster.count * cluster.height;
+      total += share;
+      if (share > most) {
+        most = share;
+        brightest = c;
+      }
+    }
+    const s = shadows ? spot.current : null;
+    if (s) s.intensity = 0;
+    for (let i = 0; i < FIRE_CLUSTERS; i++) {
+      const light = front.current[i];
+      if (!light) continue;
+      const cluster = i < fire.clusterCount ? fire.clusters[i] : null;
+      if (!cluster || !(total > 0)) {
+        light.intensity = 0;
+        continue;
+      }
+      toward.set(camera.position.x - cluster.x, 0, camera.position.z - cluster.z).normalize().multiplyScalar(0.035);
+      light.position.set(cluster.x + toward.x, cluster.y + cluster.height * 0.5, cluster.z + toward.z);
+      light.intensity = level * cluster.flicker * (cluster.count * cluster.height / total);
+      light.color.copy(COOLING).lerp(FIRE_COLOR, Math.min(1, Math.max(0, cluster.heat)));
+      if (s && i === brightest) {
+        s.position.copy(light.position);
+        s.target.position.set(cluster.x, cluster.y, cluster.z);
+        s.target.updateMatrixWorld();
+        s.intensity = light.intensity;
+        s.color.copy(light.color);
+        light.intensity = 0;
+      }
+    }
+    if (fire.count === 0) {
+      b.intensity = 0;
+      return;
+    }
+    toward.set(camera.position.x - fire.x, 0, camera.position.z - fire.z).normalize().multiplyScalar(0.035);
+    b.position.set(fire.x - toward.x, fire.y + fire.height * 0.5, fire.z - toward.z);
+    b.intensity = level * fire.flicker * 0.35;
   });
   return /* @__PURE__ */ jsxs2(Fragment3, { children: [
-    /* @__PURE__ */ jsx6("pointLight", { ref: front, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 }),
+    Array.from({ length: FIRE_CLUSTERS }, (_, i) => /* @__PURE__ */ jsx6(
+      "pointLight",
+      {
+        ref: (light) => {
+          front.current[i] = light;
+        },
+        color: FIRE_COLOR,
+        intensity: 0,
+        decay: 0.9,
+        distance: 0
+      },
+      i
+    )),
+    shadows && /* @__PURE__ */ jsx6(
+      "spotLight",
+      {
+        ref: spot,
+        color: FIRE_COLOR,
+        intensity: 0,
+        decay: 0.9,
+        distance: 0,
+        angle: 1.3,
+        penumbra: 0.8,
+        castShadow: true,
+        "shadow-mapSize": [512, 512],
+        "shadow-bias": -4e-4
+      }
+    ),
     /* @__PURE__ */ jsx6("pointLight", { ref: through, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 })
   ] });
 }
+var toward = new THREE6.Vector3();
 var FIRE_COLOR = new THREE6.Color("#ffa24c");
-var FIRE_LIGHT_GAIN = 42;
+var COOLING = new THREE6.Color("#ff8a33");
+var FIRE_LIGHT_GAIN = 26;
 
 // src/fx/FxMatchFlame.tsx
 import * as THREE7 from "three";
@@ -3148,6 +3377,7 @@ export {
   FIELD_SIZE,
   FIRE_GLOW,
   FIRE_HEAT_SCALE,
+  FIRE_LIGHT_GAIN,
   FIRE_SOOT_SCALE,
   FIRE_ZONES,
   FIXED_DT,