pixi-effects 0.45.0 → 0.47.0

package/dist/{chunk-Z6JQO7GX.js → chunk-W46VWAZC.js}

@@ -1,6 +1,6 @@
-import { CompositionSequence, maskSourceOf } from './chunk-ICI6ACHY.js';
-import { EXPRESSION_NAMES, createTimeline, lengthen, ensureFilterLibrary, checkEase, parseEase, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, trimPolylines, rand, DEG, timeRemapOf, contentLength, resolveAt, parseSpring, springDuration, spansMeta } from './chunk-4QVQ5UJJ.js';
-import { analyzeAudio, fft, resampleThrough, measureLoudness, playSpan } from './chunk-K24FF4BT.js';
+import { CompositionSequence, maskSourceOf } from './chunk-FPV3NPYC.js';
+import { EXPRESSION_NAMES, createTimeline, lengthen, ensureFilterLibrary, checkEase, parseEase, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, trimPolylines, rand, DEG, timeRemapOf, contentLength, resolveAt, parseSpring, springDuration, spansMeta } from './chunk-DM2OLQOJ.js';
+import { analyzeAudio, fft, resampleThrough, measureLoudness, playSpan } from './chunk-4SEL6W7H.js';
 import { usesAdvancedBlend, enableAdvancedBlend } from './chunk-VNP7QCJE.js';
 import { describeLayer } from './chunk-32MMNDDN.js';
 import { warnUnknownOptions, suggestName } from './chunk-BXOCEZ4U.js';
@@ -141,18 +141,86 @@ async function mixdown(audios, totalDuration, sampleRate = 44100, pace) {
 }
 var KNEE = 0.9;
 var LOUDNESS_CEILING_DB = -1;
+var MAX_LIMIT_DB = 10;
+function limitInto(source, out, gain, ceil, sampleRate) {
+  const n = source[0]?.length ?? 0;
+  const req = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    let p = 0;
+    for (const c of source) {
+      const a = Math.abs(c[i]) * gain;
+      if (a > p) p = a;
+    }
+    req[i] = p > ceil ? ceil / p : 1;
+  }
+  const L = Math.max(1, Math.round(3e-3 * sampleRate));
+  const mn = new Float32Array(n), dq = new Int32Array(n);
+  let head = 0, tail = 0;
+  for (let i = n - 1; i >= 0; i--) {
+    while (tail > head && req[dq[tail - 1]] >= req[i]) tail--;
+    dq[tail++] = i;
+    while (dq[head] > i + L) head++;
+    mn[i] = req[dq[head]];
+  }
+  const release = 1 - Math.exp(-1 / (0.08 * sampleRate));
+  let run = 0, prev = 1, lowest = 1, lowestAt = 0;
+  const gains = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    run += mn[i];
+    if (i > L) run -= mn[i - L - 1];
+    const avg = run / Math.min(i + 1, L + 1);
+    const g = Math.min(avg, prev + (1 - prev) * release);
+    gains[i] = g;
+    prev = g;
+    if (g < lowest) {
+      lowest = g;
+      lowestAt = i;
+    }
+  }
+  for (let ch = 0; ch < source.length; ch++) {
+    const s = source[ch], o = out[ch];
+    for (let i = 0; i < n; i++) {
+      const v = s[i] * gain * gains[i];
+      o[i] = v > ceil ? ceil : v < -ceil ? -ceil : v;
+    }
+  }
+  return { reductionDb: lowest < 1 ? -20 * Math.log10(lowest) : 0, at: lowestAt / sampleRate };
+}
 function normalizeMix(buffer, target) {
   const chans = [];
   for (let ch = 0; ch < buffer.numberOfChannels; ch++) chans.push(buffer.getChannelData(ch));
-  const m = measureLoudness(chans, buffer.sampleRate, { truePeak: false });
+  const sr = buffer.sampleRate;
+  const m = measureLoudness(chans, sr, { truePeak: false });
   if (m.integratedLufs === null) return { target, gainDb: 0, reachedLufs: null, limited: false };
+  const original = chans.map((c) => Float32Array.from(c));
   let gainDb = target - m.integratedLufs;
-  const room = LOUDNESS_CEILING_DB - m.samplePeakDb;
-  const limited = gainDb > room;
-  if (limited) gainDb = room;
-  const gain = 10 ** (gainDb / 20);
-  for (const d of chans) for (let i = 0; i < d.length; i++) d[i] = d[i] * gain;
-  return { target, gainDb: Math.round(gainDb * 10) / 10, reachedLufs: Math.round((m.integratedLufs + gainDb) * 10) / 10, limited };
+  let ceilDb = LOUDNESS_CEILING_DB;
+  let applied = { reductionDb: 0, at: 0 }, measured = m;
+  for (let round2 = 0; round2 < 8; round2++) {
+    const cap = MAX_LIMIT_DB + ceilDb - m.samplePeakDb;
+    if (gainDb > cap) gainDb = cap;
+    applied = limitInto(original, chans, 10 ** (gainDb / 20), 10 ** (ceilDb / 20), sr);
+    measured = measureLoudness(chans, sr);
+    const overTp = measured.truePeakDb - LOUDNESS_CEILING_DB;
+    if (overTp > 0.02) {
+      ceilDb -= overTp + 0.02;
+      continue;
+    }
+    const deficit = target - measured.integratedLufs;
+    if (Math.abs(deficit) <= 0.15) break;
+    const next = Math.min(gainDb + deficit, cap);
+    if (Math.abs(next - gainDb) < 0.05) break;
+    gainDb = next;
+  }
+  const limited = measured.integratedLufs < target - 0.15;
+  const reduction = Math.round(applied.reductionDb * 10) / 10;
+  return {
+    target,
+    gainDb: Math.round(gainDb * 10) / 10,
+    reachedLufs: measured.integratedLufs,
+    limited,
+    ...reduction >= 0.1 ? { limiterDb: reduction, limiterAt: Math.round(applied.at * 100) / 100 } : {}
+  };
 }
 function limitMix(buffer, audios) {
   let peak = 0;
@@ -1632,7 +1700,7 @@ function inspectScene(root, frame, time, canvas, opts = {}) {
       const name = seq.spec.name;
       const label = name ?? `${seq.spec.type}#${i}`;
       const alpha = (t?.alpha ?? 1) * carriers.reduce((a, c) => a * (c.target?.alpha ?? 1), 1);
-      const alive = (threeD ? display.visible : t?.renderable ?? true) && carriers.every((c) => c.target?.renderable ?? true);
+      const alive = (threeD ? display.visible : (t?.renderable ?? true) && t?.visible !== false) && carriers.every((c) => c.target?.renderable ?? true);
       const visible = parentVisible && alive && alpha > 0;
       let bounds = null;
       if (!insideThreeD) {
@@ -1812,7 +1880,22 @@ function pickScene(root, x, y, opts = {}, deps = {}) {
     return true;
   };
   const inside = (b, p) => p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;
-  const walk3 = (comp, prefix, parentVisible) => {
+  const hiddenSources = /* @__PURE__ */ new Map();
+  const forwards = [];
+  const rays = /* @__PURE__ */ new Map();
+  const rayOf = (seq, d, local, lb) => {
+    if (typeof seq.pickAt !== "function") return null;
+    if (!rays.has(seq)) rays.set(seq, seq.pickAt((local.x - lb.x) / lb.width, (local.y - lb.y) / lb.height));
+    return rays.get(seq);
+  };
+  const forwardThrough = (seq, d, path, local, lb) => {
+    const shows = seq.screenOf;
+    if (!shows || !inside(lb, local)) return;
+    const r = rayOf(seq, d, local, lb);
+    const shown = r?.uv ? shows.call(seq, r.material) : null;
+    if (r?.uv && shown) forwards.push({ source: shown.source, uv: r.uv, via: { path, object: String(r.object) }, order: orderOf(d) });
+  };
+  const walk3 = (comp, prefix, parentVisible, at = { x, y }, orderBase, via) => {
     comp.layers().forEach(({ seq, display, threeD, carriers, quad }, i) => {
       const d = display;
       if (!d) return;
@@ -1820,16 +1903,25 @@ function pickScene(root, x, y, opts = {}, deps = {}) {
       const name = seq.spec.name;
       const path = prefix + (name ?? `${seq.spec.type}#${i}`);
       const alpha = (t?.alpha ?? 1) * carriers.reduce((a, c) => a * (c.target?.alpha ?? 1), 1);
-      const alive = (threeD ? d.visible : t?.renderable ?? true) && carriers.every((c) => c.target?.renderable ?? true);
+      const alive = (threeD ? d.visible : (t?.renderable ?? true) && t?.visible !== false) && carriers.every((c) => c.target?.renderable ?? true);
       const visible = parentVisible && alive && alpha > 0;
-      if (!visible) return;
+      if (!visible) {
+        if (seq instanceof CompositionSequence && !threeD && parentVisible && alpha > 0 && t?.visible === false && (t?.renderable ?? true) && carriers.every((c) => c.target?.renderable ?? true)) hiddenSources.set(seq, path);
+        return;
+      }
       const isComposition = seq instanceof CompositionSequence;
       if (isComposition && !threeD) {
-        walk3(seq, path + "/", visible);
+        walk3(seq, path + "/", visible, at, orderBase, via);
         return;
       }
-      if (!wanted(name, path)) return;
-      const point = { x, y };
+      if (!wanted(name, path)) {
+        if (!threeD) {
+          const lp = d.toLocal(at);
+          forwardThrough(seq, d, path, lp, d.getLocalBounds());
+        }
+        return;
+      }
+      const point = at;
       let hit = null;
       if (threeD) {
         if (quad && pointInQuad(quad, d.toLocal(point).x, d.toLocal(point).y)) hit = { name, path, type: seq.spec.type, kind: "card", point };
@@ -1837,7 +1929,10 @@ function pickScene(root, x, y, opts = {}, deps = {}) {
         const local = d.toLocal(point);
         const lb = d.getLocalBounds();
         if (inside(lb, local)) {
-          const three = typeof seq.pickAt === "function" ? seq.pickAt((local.x - lb.x) / lb.width, (local.y - lb.y) / lb.height) : void 0;
+          const isThree = typeof seq.pickAt === "function";
+          const ray = isThree ? rayOf(seq, d, local, lb) : void 0;
+          if (isThree) forwardThrough(seq, d, path, local, lb);
+          const three = ray ? { object: ray.object, point: ray.point, distance: ray.distance, object3d: ray.object3d } : isThree ? null : void 0;
           if (three) {
             const planeOf = seq.dragPlane;
             if (planeOf) {
@@ -1872,10 +1967,16 @@ function pickScene(root, x, y, opts = {}, deps = {}) {
       const maskTarget = seq.maskSequence?.target;
       const maskSrc = maskSourceOf(seq.spec.mask);
       if (maskTarget && !(maskSrc.kind === "inline" && maskSrc.invert) && !inside(maskTarget.getBounds(), point)) return;
-      found.push({ hit, order: orderOf(d) });
+      found.push({ hit: via ? { ...hit, point: { x, y }, via } : hit, order: orderBase ? [...orderBase, ...orderOf(d)] : orderOf(d) });
     });
   };
   walk3(root, "", true);
+  for (const f of forwards) {
+    const path = hiddenSources.get(f.source);
+    if (path === void 0) continue;
+    const g = f.source.target.toGlobal({ x: f.uv.u * f.source.intrinsicWidth, y: (1 - f.uv.v) * f.source.intrinsicHeight });
+    walk3(f.source, path + "/", true, g, f.order, f.via);
+  }
   return found.sort((a, b) => above(a.order, b.order)).map((f) => f.hit);
 }
 var cache = /* @__PURE__ */ new WeakMap();
@@ -2818,6 +2919,7 @@ var Movie = class {
       frameRate: this.frameRate,
       vars: numericVars(vars),
       ...gpuField,
+      ...this.app?.renderer ? { pixiRenderer: this.app.renderer } : {},
       ...reuse ? { reuse } : {},
       ...lp ? { onLayerBuilt: async () => {
         lp.tick();
@@ -4412,20 +4514,25 @@ function animateText(text, style, options) {
   const pieces = splitText(text, style, { by, x, y, align, ...vertical ? { vertical } : {} });
   if (pieces.length === 0) return [];
   const lineHeight = measureText("M", style).height;
-  const inTween = options.in === false ? null : resolveTween(options.in ?? "rise", "in");
-  const outTween = options.out === void 0 || options.out === false ? null : resolveTween(options.out, "out");
+  const given = (v) => v === false || v === "none" ? void 0 : v;
+  const inSpec = options.in === void 0 ? "rise" : given(options.in), outSpec = given(options.out);
+  const inTween = inSpec === void 0 ? null : resolveTween(inSpec, "in");
+  const outTween = outSpec === void 0 ? null : resolveTween(outSpec, "out");
   const delays = stagger(pieces.length, options.stagger ?? { each: 0.04 });
   const wave = Math.max(...delays);
-  const need = (inTween?.duration ?? 0) + (outTween?.duration ?? 0) + wave;
+  const outDelays = outTween?.stagger ? stagger(pieces.length, outTween.stagger) : delays;
+  const outWave = Math.max(...outDelays);
+  const lead = Math.max(...delays.map((d, i) => d - outDelays[i]));
+  const need = (inTween?.duration ?? 0) + (outTween ? outTween.duration + outWave + lead : wave);
   if (duration < need - 1e-9) {
     throw new Error(`animateText(): duration ${duration} is too short for this wave: the entrance${outTween ? ", the exit" : ""} and the stagger need at least ${+need.toFixed(3)} s`);
   }
   const end = at + duration;
   if (outTween?.at !== void 0) {
     if (outTween.at < at - 1e-9) console.warn(`pixi-effects: animateText(): out.at ${outTween.at} is before the layer starts (at ${at}): the exit starts with the piece; use out.at \u2265 ${at}`);
-    const latest = end - outTween.duration - wave;
-    if (outTween.at > latest + 1e-9) console.warn(`pixi-effects: animateText(): out.at ${outTween.at} leaves after the layer ends (the exit and the wave take ${+(outTween.duration + wave).toFixed(3)} s and the layer ends at ${+end.toFixed(3)} s): use out.at \u2264 ${+latest.toFixed(3)}, or a longer duration`);
-    if (inTween && outTween.at - at < inTween.duration - 1e-9) console.warn(`pixi-effects: animateText(): out.at ${outTween.at} is before the entrance has finished (it takes ${inTween.duration} s from at ${at}): use out.at \u2265 ${+(at + inTween.duration).toFixed(3)}`);
+    const latest = end - outTween.duration - outWave;
+    if (outTween.at > latest + 1e-9) console.warn(`pixi-effects: animateText(): out.at ${outTween.at} leaves after the layer ends (the exit and the wave take ${+(outTween.duration + outWave).toFixed(3)} s and the layer ends at ${+end.toFixed(3)} s): use out.at \u2264 ${+latest.toFixed(3)}, or a longer duration`);
+    if (inTween && outTween.at - at < inTween.duration + lead - 1e-9) console.warn(`pixi-effects: animateText(): out.at ${outTween.at} is before the entrance has finished (it takes ${inTween.duration} s from at ${at}): use out.at \u2265 ${+(at + inTween.duration + lead).toFixed(3)}`);
   }
   return pieces.map((p, i) => {
     const cx = p.cx ?? p.x + p.width / 2, cy = p.cy ?? p.y + lineHeight / 2;
@@ -4445,8 +4552,8 @@ function animateText(text, style, options) {
     }
     let idleEnd = len;
     if (outTween) {
-      const begin = outTween.at !== void 0 ? void 0 : outTween.duration + (wave - delays[i]);
-      const local = outTween.at !== void 0 ? Math.max(0, outTween.at - at) : -begin;
+      const begin = outTween.at !== void 0 ? void 0 : outTween.duration + (outWave - outDelays[i]);
+      const local = outTween.at !== void 0 ? Math.max(0, outTween.at + outDelays[i] - start) : -begin;
       idleEnd = outTween.at !== void 0 ? local : len - begin;
       keyframes.push({
         at: local,
@@ -4482,6 +4589,10 @@ function resolveTween(spec, which) {
   if (typeof spec === "object" && spec) {
     for (const key of Object.keys(spec)) {
       if (TWEEN_KEYS.includes(key)) continue;
+      if (key === "stagger") {
+        if (which === "in") console.warn("pixi-effects: animateText(): in.stagger is ignored: the entrance wave is the options' `stagger` (only `out` can have a wave of its own: out: { stagger: 0 } leaves all at once)");
+        continue;
+      }
       if (which === "out" && key === "at") {
         if (typeof spec.at !== "number" || !Number.isFinite(spec.at)) console.warn(`pixi-effects: animateText(): out.at must be a number of seconds (the composition second the exit starts at), got ${JSON.stringify(spec.at)}; ignored`);
         continue;
@@ -4493,7 +4604,7 @@ function resolveTween(spec, which) {
   }
   if (t.preset !== void 0 && !(t.preset in PRESETS)) {
     const guess = suggestName(String(t.preset), PRESET_NAMES);
-    throw new Error(`animateText(): ${which} "${t.preset}" is not a preset${guess ? `; did you mean "${guess}"?` : ""} (presets: ${PRESET_NAMES.map((n) => `"${n}"`).join(", ")})`);
+    throw new Error(`animateText(): ${which} "${t.preset}" is not a preset${guess ? `; did you mean "${guess}"?` : ""} (presets: ${PRESET_NAMES.map((n) => `"${n}"`).join(", ")}; for no ${which === "out" ? "exit: omit `out` or write out: false (the pieces stay until the layer ends)" : "entrance: in: false"})`);
   }
   const base = t.preset ? PRESETS[t.preset] : void 0;
   const from = { ...base?.from ?? {}, ...t.from ?? {} };
@@ -4502,11 +4613,14 @@ function resolveTween(spec, which) {
   for (const k of Object.keys(from)) {
     if (!known.has(k) && to[k] === void 0) throw new Error(`animateText(): ${which}.from has "${k}", which has no resting value; give ${which}.to: { ${k}: \u2026 }`);
   }
-  if (Object.keys(from).length === 0) throw new Error(`animateText(): ${which} needs a preset or a from`);
+  if (Object.keys(from).length === 0) {
+    throw new Error(`animateText(): ${which} needs a preset or a from${which === "out" && Object.keys(to).length ? ` \u2014 ${which} takes \`from\`: the state the piece leaves to (out: { from: { y: 18, alpha: 0 } }); \`to\` is only the resting value of a property that has none` : ""}`);
+  }
   let ease = t.ease ?? base?.ease ?? "power2.out";
   if (which === "out" && t.ease === void 0) ease = ease.replace(".out", ".in");
   const at = which === "out" && typeof t.at === "number" && Number.isFinite(t.at) ? t.at : void 0;
-  return { from, to: { ...to }, duration: t.duration ?? base?.duration ?? 0.5, ease, ...at !== void 0 ? { at } : {} };
+  const wave = which === "out" && t.stagger !== void 0 ? t.stagger === 0 ? { each: 0 } : t.stagger : void 0;
+  return { from, to: { ...to }, duration: t.duration ?? base?.duration ?? 0.5, ease, ...at !== void 0 ? { at } : {}, ...wave ? { stagger: wave } : {} };
 }
 
 // src/presets/react.ts
@@ -4814,5 +4928,5 @@ function withFade(spec, opts) {
 }
 
 export { Movie, animateText, audioEnvelope, bpmEnvelope, cameraPath, computeEnvelope, dismissLoader, failLoader, followPath, kenBurns, measureText, musicBuffer, musicEnvelope, musicEvents, orbit, parseEase2 as parseEase, particles, react, resolveLoader, samplePath, splitText, stagger, wiggle, withFade };
-//# sourceMappingURL=chunk-Z6JQO7GX.js.map
-//# sourceMappingURL=chunk-Z6JQO7GX.js.map
+//# sourceMappingURL=chunk-W46VWAZC.js.map
+//# sourceMappingURL=chunk-W46VWAZC.js.map