pixi-effects 0.48.1 → 0.49.0

package/dist/3d.cjs

@@ -0,0 +1,963 @@
+'use strict';
+
+var chunk33USHRV5_cjs = require('./chunk-33USHRV5.cjs');
+var chunk5YNME6AH_cjs = require('./chunk-5YNME6AH.cjs');
+var chunkABWRISRK_cjs = require('./chunk-ABWRISRK.cjs');
+var chunkDOLTCXCL_cjs = require('./chunk-DOLTCXCL.cjs');
+var _3d = require('@pixi/3d');
+var pixi_js = require('pixi.js');
+
+var NEAR = 1;
+var FAR = 2e4;
+function applyCameraState(camera, s) {
+  camera.mode = "perspective";
+  camera.zoom = 1;
+  camera.fov = s.fov;
+  camera.near = NEAR;
+  camera.far = FAR;
+  camera.position.set(s.x, -s.y, s.z);
+  const same = Math.hypot(s.lookAtX - s.x, s.lookAtY - s.y, s.lookAtZ - s.z) < 1e-9;
+  camera.lookAt(same ? { x: s.x, y: -s.y, z: s.z - 1 } : { x: s.lookAtX, y: -s.lookAtY, z: s.lookAtZ });
+}
+var LightMirror = class {
+  constructor(root, extent = 2e3, say = () => {
+  }, center = { x: 0, y: 0, z: 0 }) {
+    this.root = root;
+    this.extent = extent;
+    this.say = say;
+    this.center = center;
+  }
+  root;
+  extent;
+  say;
+  center;
+  entries = [];
+  said = /* @__PURE__ */ new Set();
+  update(lights) {
+    lights.forEach((s, i) => {
+      let e = this.entries[i];
+      if (!e || e.kind !== s.kind) {
+        if (e) this.remove(e);
+        e = this.entries[i] = this.make(s.kind);
+      }
+      this.configure(e, s);
+    });
+    for (let i = lights.length; i < this.entries.length; i++) this.entries[i].light.visible = false;
+  }
+  dispose() {
+    for (const e of this.entries) this.remove(e);
+    this.entries = [];
+  }
+  /** The lights now live under another root (a rebuild moved the scene into a new view): new lights go there. */
+  rehome(root) {
+    this.root = root;
+  }
+  once(key, message) {
+    if (this.said.has(key)) return;
+    this.said.add(key);
+    this.say(message);
+  }
+  make(kind) {
+    const light = kind === "ambient" ? new _3d.AmbientLight() : kind === "parallel" ? new _3d.DirectionalLight() : kind === "spot" ? new _3d.SpotLight() : new _3d.PointLight();
+    light.label = "pixi-effects:composition-light";
+    this.root.addChild(light);
+    return { kind, light };
+  }
+  remove(e) {
+    e.light.removeFromParent();
+    e.light.destroy();
+  }
+  configure(e, s) {
+    const { light } = e;
+    light.visible = true;
+    light.color = [s.r, s.g, s.b];
+    let intensity = s.intensity * Math.PI;
+    if (s.kind !== "ambient") {
+      light.position.set(s.x, -s.y, s.z);
+      const same = Math.hypot(s.lookAtX - s.x, s.lookAtY - s.y, s.lookAtZ - s.z) < 1e-9;
+      if (s.kind !== "point") light.lookAt(same ? { x: s.x, y: -s.y, z: s.z - 1 } : { x: s.lookAtX, y: -s.lookAtY, z: s.lookAtZ });
+    }
+    if (s.kind === "point" || s.kind === "spot") {
+      const l = light;
+      const flat = 100 * this.extent;
+      const shadowRange = s.kind === "spot" && s.castsShadows ? 20 * this.extent : 0;
+      if (s.falloff === "inverseSquare") {
+        l.radius = Math.max(s.radius, 1e-3);
+        intensity *= l.radius * l.radius;
+        l.range = shadowRange;
+      } else if (s.falloff === "smooth") {
+        const reach = s.radius + Math.max(s.falloffDistance, 1e-3), p = s.radius / reach;
+        l.radius = flat;
+        intensity *= flat * flat * (SMOOTH_FIT.gain[0] + SMOOTH_FIT.gain[1] * p);
+        l.range = reach * (SMOOTH_FIT.range[0] + SMOOTH_FIT.range[1] * p);
+      } else {
+        l.radius = flat;
+        intensity *= flat * flat;
+        l.range = shadowRange;
+      }
+    }
+    if (s.kind === "spot") {
+      const l = light;
+      l.coneAngle = s.coneAngle / 2;
+      l.penumbra = s.coneFeather;
+    }
+    light.intensity = intensity;
+    if (s.kind !== "ambient") {
+      const casts = s.castsShadows && s.kind !== "point";
+      light.castShadow = casts;
+      if (casts) {
+        const shadow = light.shadow;
+        if (s.kind === "spot") shadow.bias = SPOT_SHADOW_BIAS;
+        else shadow.bounds = shadow.bounds ??= _3d.Box.fromCenterSize(this.center, this.extent);
+      }
+      if (s.castsShadows && s.kind === "point") this.once("point", "followLights: a point light casts no shadow in PixiJS 3D; use a spot light (or a parallel one) for the shadow");
+      if (casts && (s.shadowDarkness < 1 || s.shadowDiffusion > 0)) {
+        this.once("shadowLook", `followLights: shadowDarkness and shadowDiffusion are not mirrored (PixiJS 3D draws a shadow at full darkness with its view's own filter); the shadow is drawn ${s.shadowDarkness < 1 ? "darker" : "harder"} than on the cards`);
+      }
+    }
+  }
+};
+var SPOT_SHADOW_BIAS = 1e-5;
+var SMOOTH_FIT = { range: [0.8, 0.45], gain: [0.87, 0.45] };
+var FogMirror = class {
+  constructor(view) {
+    this.view = view;
+  }
+  view;
+  own = null;
+  update(fog) {
+    const current = this.view.fog;
+    if (current && current !== this.own) return;
+    if (!fog) {
+      if (this.own && current === this.own) this.view.fog = null;
+      this.own = null;
+      return;
+    }
+    if (!this.own) {
+      this.own = { type: "linear", color: [fog.r, fog.g, fog.b], near: fog.near, far: fog.far };
+      this.view.fog = this.own;
+    }
+    this.own.color = [fog.r, fog.g, fog.b];
+    this.own.near = fog.near;
+    this.own.far = fog.far;
+  }
+  dispose() {
+    this.update(null);
+  }
+};
+var HOST = /* @__PURE__ */ Symbol.for("pixi-effects:scene3d-host");
+var label = "pixi-effects: layerTexture";
+async function layerTexture(ctx, name, options = {}) {
+  const host = ctx[HOST];
+  if (!host) throw new Error(`${label}: call it from the setup of a scene3d layer: const screen = await layerTexture(ctx, 'screen')`);
+  if (typeof name !== "string" || !name) throw new Error(`${label}: the second argument is the name of a 2D layer: layerTexture(ctx, 'screen')`);
+  const resolution = options.resolution ?? 1;
+  if (!(Number.isFinite(resolution) && resolution > 0 && resolution <= 4)) throw new Error(`${label}: resolution is a number from above 0 to 4 (2 = twice the pixels), got ${JSON.stringify(options.resolution)}`);
+  const pixi = host.pixiRenderer;
+  if (!pixi) throw new Error(`${label}: PixiJS's renderer is not available here (the movie is not ready)`);
+  const source = host.findLayer(name);
+  if (!source) {
+    const names = host.layerNames();
+    throw new Error(`${label}: no layer named "${name}" before this scene3d layer${names.length ? ` (the layers built before it: ${names.map((n) => `"${n}"`).join(", ")})` : ""}. A layer shown on a mesh must be listed BEFORE the scene3d layer, in the same composition, and have that name.`);
+  }
+  if (source.spec.type !== "composition") {
+    throw new Error(`${label}: "${name}" is a ${source.spec.type} layer: a layer shown on a mesh must be a composition (wrap it: { type: 'composition', name: '${name}', width: 480, height: 270, sequences: [ \u2026 ] })`);
+  }
+  const logicalW = Math.max(1, Math.round(source.intrinsicWidth)), logicalH = Math.max(1, Math.round(source.intrinsicHeight));
+  const rt = pixi_js.RenderTexture.create({ width: logicalW, height: logicalH, resolution, autoGenerateMipmaps: true });
+  const transparent = options.transparent === true;
+  const material = new _3d.FlatMaterial({ baseColorTexture: rt, uvTransform: new pixi_js.Matrix(1, 0, 0, -1, 0, 1), ...transparent ? { alphaMode: "blend" } : {} });
+  let current = source;
+  let display = source.target;
+  let sx = logicalW / source.intrinsicWidth, sy = logicalH / source.intrinsicHeight;
+  let hidden = false;
+  const hide = () => {
+    display.visible = false;
+    hidden = true;
+  };
+  hide();
+  const uncull = (c) => {
+    if (c.culled) c.culled = false;
+    for (const k of c.children) uncull(k);
+  };
+  const refresh = () => {
+    display.visible = true;
+    uncull(display);
+    try {
+      pixi.render({ container: display, target: rt, transform: new pixi_js.Matrix().scale(sx, sy), clear: true, clearColor: [0, 0, 0, transparent ? 0 : 1] });
+    } finally {
+      display.visible = false;
+    }
+    rt.source.updateMipmaps();
+  };
+  const stop = host.beforeDraw(refresh);
+  refresh();
+  let disposed = false;
+  const handle = {
+    material,
+    texture: rt,
+    width: Math.round(logicalW * resolution),
+    height: Math.round(logicalH * resolution),
+    source: () => current,
+    sourceAt: (u, v) => ({ x: u, y: 1 - v }),
+    // a plane's uv: v runs up; the texture's rows run down
+    prepare(next) {
+      const again = next.findLayer(name);
+      if (disposed) return () => {
+      };
+      if (!again) throw new Error(`${label}: after a rebuild there is no layer "${name}" before the scene3d layer any more`);
+      return () => {
+        current = again;
+        display = again.target;
+        sx = logicalW / again.intrinsicWidth;
+        sy = logicalH / again.intrinsicHeight;
+        hide();
+        refresh();
+      };
+    },
+    keepHidden() {
+      if (hidden && !disposed) display.visible = false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      untrack();
+      stop();
+      if (hidden) {
+        display.visible = true;
+        hidden = false;
+      }
+    }
+  };
+  const untrack = host.track(handle);
+  host.own(() => {
+    try {
+      material.destroy?.();
+    } catch {
+    }
+    try {
+      rt.destroy(true);
+    } catch {
+    }
+  });
+  return handle;
+}
+
+// src/3d/Scene3DSequence.ts
+var OWN_KEYS = ["width", "height", "view", "resolution", "setup", "update", "dispose", "followCamera", "followLights", "followFog", "reuse"];
+var THREE_ONLY = ["renderer", "shareGpu", "antialias"];
+var LAYER_OWNED = ["width", "height", "autoResize"];
+var Scene3DSequence = class extends chunk33USHRV5_cjs.Sequence {
+  _view = null;
+  _ctx = null;
+  _objects = {};
+  _warned = /* @__PURE__ */ new Set();
+  /** The animation players under the root (found after setup). */
+  _players = [];
+  /** The layer's own last filter: what PixiJS 3D ignores on its view (alpha, its parents' alpha, a basic blend mode) applied to the view's picture. Only there while needed. */
+  _look = null;
+  /** An advanced blend mode on a layer with no filter of its own: its blend filter, owned by the layer (the view's own blend mode would be shut inside the look filter's pass). */
+  _blend = null;
+  /** The layer's time, what PixiJS 3D's shader time `uTime` reads once pinned (see `_pinShaderTime`). */
+  _time = 0;
+  /** Things to do before every frame of the scene is drawn (the 2D layers shown on meshes: `layerTexture`), and their handles. */
+  _drawHooks = /* @__PURE__ */ new Set();
+  _shown = [];
+  /** Resources the 2D layers on meshes leave to this layer to free when it goes (shared, like `_shown`, with a layer that takes the scene over). */
+  _owned = [];
+  /** What a rebuild matches this layer by (core/reuse.ts); null: never kept (`reuse: false`, no `name`, view options that are not plain data). */
+  _key = null;
+  /** The layer of the tree being replaced whose scene this one takes over at the swap (`commitReuse`): until then it is not this layer's. */
+  _borrowed = null;
+  /** True once another layer took this layer's scene: destroying this one must not let it go. */
+  _donated = false;
+  _pendingRebinds = [];
+  _lightMirror = null;
+  _fogMirror = null;
+  _pinned = false;
+  /** The scene may have changed since the meshes were last made pickable (a frame ran `update`): the next pick walks it again, the picks after it do not. */
+  _pickStale = true;
+  /** The PixiJS 3D view this layer shows (null before build and after destroy). */
+  get view() {
+    return this._view;
+  }
+  get _spec() {
+    return this.spec;
+  }
+  _say(key, message) {
+    if (this._warned.has(key)) return;
+    this._warned.add(key);
+    console.warn(`${this._who()}: ${message}`);
+  }
+  _who() {
+    const name = this._spec.name;
+    return `pixi-effects: scene3d layer${name ? ` "${name}"` : ""}`;
+  }
+  pathRouters() {
+    return { scene3d: (path) => this._resolvePath(path) };
+  }
+  async build() {
+    const spec = this._spec;
+    if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
+    this._checkKeys();
+    this._checkTint();
+    if (typeof spec.update === "function" && chunk33USHRV5_cjs.NOT_PURE.test(spec.update.toString())) {
+      this._say("pure", "update calls Math.random, Date.now, performance.now or new Date, so it is not deterministic: the same frame would draw differently in playback, in a seek and in an export. Derive the value from t");
+    }
+    const renderer = this.root.pixiRenderer;
+    if (renderer && !renderer.renderPipes.view3d) {
+      throw new Error(`${this._who()}: PixiJS 3D was loaded after the renderer started; import 'pixi-effects/3d' (and call register3D()) before movie.init`);
+    }
+    const scope = chunk33USHRV5_cjs.buildScope(this, this.parent, this.root);
+    const width = resolveDim(spec.width, scope) ?? this.parent?.width ?? this.root.width;
+    const height = resolveDim(spec.height, scope) ?? this.parent?.height ?? this.root.height;
+    const viewOptions = { ...spec.view ?? {} };
+    const owned = LAYER_OWNED.filter((k) => k in viewOptions);
+    if (owned.length) {
+      this._say("owned", `${owned.join(" / ")} belong${owned.length === 1 ? "s" : ""} on the layer, not in view; ignored`);
+      for (const k of owned) delete viewOptions[k];
+    }
+    const view = new _3d.View3D({ cull: "cpu", ...viewOptions, width, height, ...spec.resolution !== void 0 ? { resolution: spec.resolution } : {} });
+    view.label = spec.name ?? "scene3d";
+    this._view = view;
+    this.target = view;
+    this.intrinsicWidth = width;
+    this.intrinsicHeight = height;
+    this._key = spec.reuse === false || !spec.name ? null : reuseKeyOf(spec, width, height);
+    const donor = this._key !== null ? this.root.reuse?.claim(this._key) : null;
+    if (donor && donor._lendable()) {
+      this._borrow(donor, view, renderer ?? null, width, height);
+      if (spec.followCamera) this._checkFollowShape(width, height);
+      this.buildFilters();
+      return;
+    }
+    const objects = {};
+    const ctx = { view, root: view.root, camera: view.camera, renderer, width, height, objects };
+    Object.defineProperty(ctx, HOST, { value: this._makeHost(renderer ?? null), enumerable: false });
+    let result;
+    try {
+      result = await spec.setup(ctx);
+    } catch (err) {
+      this._destroyView();
+      throw new Error(`${this._who()}: setup failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    Object.assign(objects, result?.objects ?? {});
+    if (!("camera" in objects)) objects.camera = view.camera;
+    if (!("view" in objects)) objects.view = view;
+    this._objects = objects;
+    this._ctx = ctx;
+    this._stopSelfUpdating(view.root);
+    if (spec.followCamera) this._checkFollowShape(width, height);
+    this.buildFilters();
+  }
+  /** Reuse (core/reuse.ts): the key this layer is matched by, while it can still lend its scene. */
+  reuseKey() {
+    return this._lendable() ? this._key : null;
+  }
+  _lendable() {
+    return !!this._view && !!this._ctx && !this._donated && !this._borrowed;
+  }
+  /**
+   * Take over a layer of the tree being replaced. The view is a PixiJS display object with one parent, so the old view stays in the old tree (which goes on drawing while this tree is
+   * built); this layer has a view of its own, and at the swap (`commitReuse`) the old view's whole scene, its camera with it, moves into this one. The objects setup made (and every
+   * value an author kept from setup: the camera, the meshes) are the same objects.
+   */
+  _borrow(d, view, renderer, width, height) {
+    this._borrowed = d;
+    const objects = { ...d._objects, ...d._objects.view === d._view ? { view } : {} };
+    this._objects = objects;
+    this._players = d._players;
+    const ctx = { view, root: view.root, camera: d._view.camera, renderer, width, height, objects };
+    const host = this._makeHost(renderer);
+    Object.defineProperty(ctx, HOST, { value: host, enumerable: false });
+    this._ctx = ctx;
+    this._pendingRebinds = d._shown.map((h) => h.prepare(host));
+  }
+  /** The new tree is on stage: the scene of the layer this one borrowed from moves into this layer's view, for good. */
+  commitReuse() {
+    const d = this._borrowed, view = this._view, ctx = this._ctx;
+    if (!d || !view || !ctx) return;
+    const from = d._view;
+    const own = view.camera;
+    for (const child of [...from.root.children]) view.root.addChild(child);
+    view.camera = ctx.camera;
+    if (own !== ctx.camera) {
+      own.removeFromParent();
+      own.destroy();
+    }
+    const keep = ["background", "environment", "exposure", "toneMapping", "shadowQuality", "shadowFilter", "cull", ...d._fogMirror ? [] : ["fog"]];
+    const src = from, dst = view;
+    for (const key of keep) {
+      try {
+        if (key in src && dst[key] !== src[key]) dst[key] = src[key];
+      } catch {
+      }
+    }
+    try {
+      const passes = src.passes;
+      if (Array.isArray(passes) && passes.length) {
+        dst.passes = [...passes];
+        src.passes = [];
+      }
+    } catch {
+    }
+    this._lightMirror = d._lightMirror;
+    this._lightMirror?.rehome(view.root);
+    this._fogMirror = null;
+    this._pickStale = true;
+    this._shown = d._shown;
+    this._drawHooks = d._drawHooks;
+    this._owned = d._owned;
+    d._donated = true;
+    this._borrowed = null;
+    for (const apply of this._pendingRebinds) apply();
+    this._pendingRebinds = [];
+  }
+  /** Unknown keys (with the likely one), and the keys only a three layer has. */
+  _checkKeys() {
+    const valid = [...chunkABWRISRK_cjs.COMMON, ...OWN_KEYS];
+    for (const key of Object.keys(this.spec)) {
+      if (valid.includes(key)) continue;
+      if (THREE_ONLY.includes(key)) {
+        this._say(`key:${key}`, `${key} is about three's own renderer; a scene3d layer is drawn by PixiJS itself, so it has no such option (ignored)`);
+        continue;
+      }
+      const guess = chunkDOLTCXCL_cjs.suggestName(key, valid);
+      this._say(`key:${key}`, `unknown key "${key}"${guess ? `; did you mean "${guess}"?` : ""} (a scene3d layer has ${OWN_KEYS.join(", ")} and the keys every layer has)`);
+    }
+  }
+  /**
+   * PixiJS 3D (0.1.0) writes `performance.now()` into the shader time `uTime` of every view at every draw: a shader bit that reads it would follow the wall clock.
+   * The view's global uniforms exist once PixiJS has drawn it; from then on `uTime` reads the layer's time and the pipe's write is ignored. Tried before every frame
+   * until it holds (drawing the view on its own at build to make them sooner broke a stencil mask on it later). This reaches into the view's per-renderer data
+   * (`_gpuData[renderer.uid].globalUniformGroup.uniforms`); when that is there but has no `uTime` (another version), say so once.
+   */
+  _pinShaderTime() {
+    if (this._pinned) return;
+    const view = this._view, renderer = this.root.pixiRenderer;
+    if (!view || !renderer) return;
+    const data = view._gpuData?.[renderer.uid];
+    if (!data) return;
+    this._pinned = true;
+    const uniforms = data.globalUniformGroup?.uniforms;
+    if (!uniforms || !("uTime" in uniforms)) {
+      this._say("uTime", "could not tie PixiJS 3D's shader time uTime to the video's time (no global uniforms found): a custom shader bit that reads uTime follows the wall clock; give it a uniform you set from t instead");
+      return;
+    }
+    Object.defineProperty(uniforms, "uTime", { configurable: true, enumerable: true, get: () => this._time, set: () => {
+    } });
+  }
+  /**
+   * `followCamera` (and, later, `followLights` / `followFog`): before each frame, ask the composition for its camera at this moment (the layer's time on the composition's
+   * clock) and put the view's camera there. `ctx.space` keeps the raw numbers for `update`, which runs after and may override.
+   */
+  _followSpace(t) {
+    const spec = this._spec;
+    if (!spec.followCamera && !spec.followLights && !spec.followFog) return;
+    const ctx = this._ctx, view = this._view;
+    if (!ctx || !view) return;
+    if (!this.parent?.spaceAt) {
+      this._say("parent", "followCamera / followLights / followFog need the layer to sit in a composition that has a camera or a light to follow; this layer's parent cannot say (it keeps its own camera and lights)");
+      return;
+    }
+    const space = this.parent.spaceAt((this.absoluteStart ?? this.at) + t);
+    ctx.space = space;
+    if (spec.followCamera) applyCameraState(view.camera, space.camera);
+    if (spec.followLights) (this._lightMirror ??= new LightMirror(view.root, Math.max(ctx.width, ctx.height) * 2, (m) => this._say(`light:${m}`, m), { x: ctx.width / 2, y: -ctx.height / 2, z: 0 })).update(space.lights);
+    if (spec.followFog) {
+      if (space.fog && space.fog.amount !== 1) this._say("fogAmount", `followFog: the camera's fogAmount is ${space.fog.amount}, and PixiJS 3D's fog has no amount below 1: the layer uses the full amount (set fogColor to the colour you want at the far end, or leave followFog off and set view.fog yourself from ctx.space.fog)`);
+      (this._fogMirror ??= new FogMirror(view)).update(space.fog);
+    }
+  }
+  /** followCamera shows the whole composition through the layer's picture: a layer of another shape would show it squeezed or cut. Said once at build. */
+  _checkFollowShape(width, height) {
+    const p = this.parent;
+    if (!p || !(p.width > 0 && p.height > 0)) return;
+    if (Math.abs(width * p.height - height * p.width) <= 1e-3 * width * p.height) return;
+    this._say("shape", `followCamera: the layer is ${width} x ${height} but the composition is ${p.width} x ${p.height}; the camera shows the whole composition, so the layer needs its aspect ratio (drop width / height to cover the composition)`);
+  }
+  /** PixiJS 3D draws the view in its materials' colours: a tint does nothing. Said once, at build. */
+  _checkTint() {
+    const spec = this._spec;
+    const uses = spec.initial?.tint !== void 0 || (spec.keyframes ?? []).some((k) => k?.to?.tint !== void 0 || k?.from?.tint !== void 0);
+    if (uses) this._say("tint", "tint is ignored on a scene3d layer (PixiJS 3D draws its own colours): colour the materials, or put a filter on the layer");
+  }
+  /**
+   * Every frame, before the draw: PixiJS 3D ignores the view's alpha (and its parents') and a basic blend mode, so when the layer is not at full strength or blends,
+   * its picture goes through one AlphaFilter of the layer's own, last in its filter list, that applies them. A layer at alpha 1 with a normal blend has no such filter.
+   */
+  syncFrame() {
+    super.syncFrame();
+    for (const h of this._shown) h.keepHidden();
+    const view = this._view;
+    if (!view) return;
+    let alpha = 1;
+    for (let c = view; c; c = c.parent) alpha *= c.alpha;
+    const current = view.filters ?? [];
+    const others = current.filter((f) => f !== this._look && f !== this._blend);
+    const authored = String(this.spec.blendMode ?? "normal");
+    if (others.length === 0 && chunk5YNME6AH_cjs.isAdvancedBlend(authored) && !this._blend) {
+      this._blend = chunk5YNME6AH_cjs.blendFilterFor(authored);
+      if (this._blend) view.blendMode = "normal";
+    }
+    const mode = String(view.blendMode ?? "normal");
+    const basic = others.length === 0 && (mode === "add" || mode === "screen" || mode === "multiply");
+    const need = alpha < 1 || basic;
+    const own = this._blend && others.length === 0 ? [this._blend] : [];
+    let next = [...others, ...own];
+    if (need) {
+      const look = this._look ??= new pixi_js.AlphaFilter({ alpha: 1 });
+      look.alpha = alpha;
+      look.blendMode = basic ? mode : "normal";
+      next = others.length || own.length ? [look, ...others, ...own] : [look];
+    }
+    if (next.length !== current.length || next.some((f, k) => f !== current[k])) view.filters = next.length ? next : null;
+  }
+  /**
+   * Models, animation players and particle systems update themselves on PixiJS's shared ticker unless told otherwise: their picture would follow the browser's clock,
+   * not the video's time. Turn that off on everything under the root, and say once what was turned off (the author drives them from `update`).
+   */
+  _stopSelfUpdating(root) {
+    const stopped = [];
+    const visit = (node) => {
+      const n = node;
+      let hit = false;
+      if (n.player && Array.isArray(n.player.animationLabels) && !this._players.includes(n.player)) this._players.push(n.player);
+      if (n.player && n.player.autoUpdate === true) {
+        n.player.autoUpdate = false;
+        hit = true;
+      }
+      if (n.autoUpdate === true) {
+        n.autoUpdate = false;
+        hit = true;
+      }
+      if (hit) stopped.push(n.label || n.constructor?.name || "a node");
+    };
+    root.traverse(visit);
+    if (stopped.length) {
+      this._say("autoUpdate", `turned off autoUpdate on ${stopped.join(", ")}: a video draws from the time, so drive them from update(t) (a model's clip: model.player.getState(name).gotoAndStop(t))`);
+    }
+  }
+  /**
+   * Per-frame hook, duck-typed by `Movie._awaitVideoFrames` (as the video and three layers are): the single frame path of playback, seek and export.
+   * `update` sets the scene from the time; PixiJS draws the view with the rest of the stage.
+   */
+  async awaitFrameAt(local) {
+    if (!this._ctx || this._borrowed) return;
+    const t = Math.max(0, Math.min(local, this.duration ?? local));
+    this._time = t;
+    this._pickStale = true;
+    this._pinShaderTime();
+    this._followSpace(t);
+    const update = this._spec.update;
+    if (update) {
+      try {
+        update(t, this._ctx);
+      } catch (err) {
+        this._say("update", `update threw (reported once): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    this._poseClips(t);
+    for (const hook of this._drawHooks) hook();
+  }
+  /**
+   * A clip still playing after `update` (a model made with `autoPlay`, a `player.play(name)` in setup) is posed by nobody: it would move with the ticker, or not at all.
+   * The layer poses it from its own time (its speed and loop kept) and leaves it playing, so it plays in the video as it would in a page. A clip `update` poses itself
+   * (`gotoAndStop(t)` stops it) is left alone. Nothing is remembered from one frame to the next: the frame depends on this frame's `update` only.
+   */
+  _poseClips(t) {
+    for (const player of this._players) {
+      for (const label3 of player.animationLabels) {
+        const state = player.getState(label3);
+        if (!state.playing) continue;
+        const length = state.animation.duration;
+        const x = t * (state.animationSpeed ?? 1);
+        state.gotoAndStop(length > 0 ? state.loop ? (x % length + length) % length : Math.min(Math.max(x, 0), length) : 0);
+        state.play();
+      }
+    }
+  }
+  /**
+   * The determinism check (`check`, `movie.review()`): the scene set by `update` and drawn at a few moments in two orders, with one draw thrown away first, and the pictures
+   * compared, as the canvas and three layers are. A scene whose same frame is not the same picture (state kept from call to call, a clock, a player or particle system on its
+   * own clock, a motion blur that reads the last frame) is reported. It draws the view alone into a texture of its own size with PixiJS's renderer; the next real frame sets
+   * the scene again, so nothing is left behind.
+   */
+  checkDeterminism(times) {
+    const none = { differs: [], drawMs: 0, threw: [] };
+    const view = this._view, ctx = this._ctx;
+    const renderer = this.root.pixiRenderer;
+    if (!view || !ctx || !renderer) return none;
+    const w = Math.max(1, Math.ceil(ctx.width)), h = Math.max(1, Math.ceil(ctx.height));
+    const rt = pixi_js.RenderTexture.create({ width: w, height: h });
+    const wasGroup = view.isRenderGroup;
+    const at = new pixi_js.Matrix().translate(view.anchor.x * w, view.anchor.y * h);
+    const keep = w * h * 4 * times.length <= 96e6;
+    const hash = (d) => {
+      let x = 2166136261;
+      for (let i = 0; i < d.length; i++) {
+        x ^= d[i];
+        x = Math.imul(x, 16777619);
+      }
+      return x >>> 0;
+    };
+    const ms = [];
+    const threw = /* @__PURE__ */ new Set();
+    const update = this._spec.update;
+    const once = (t, timed) => {
+      const from = performance.now();
+      let pixels = new Uint8Array(0);
+      try {
+        this._time = t;
+        this._followSpace(t);
+        update?.(t, ctx);
+        this._poseClips(t);
+        renderer.render({ container: view, target: rt, clear: true, transform: at });
+        pixels = renderer.extract.pixels(rt).pixels;
+      } catch {
+        threw.add(t);
+      }
+      if (timed) ms.push(performance.now() - from);
+      return pixels;
+    };
+    try {
+      for (const t of times) once(t, false);
+      const first = times.map((t) => {
+        const d = once(t, true);
+        return keep ? d.slice() : hash(d);
+      });
+      const second = [...times].reverse().map((t) => once(t, false)).reverse();
+      const differs = [];
+      times.forEach((t, i) => {
+        const a = first[i], b = second[i];
+        if (typeof a === "number") {
+          if (a !== hash(b)) differs.push({ t, pixels: -1, maxDiff: -1 });
+          return;
+        }
+        let pixels = 0, maxDiff = 0;
+        for (let k = 0; k < a.length; k++) {
+          const d = Math.abs(a[k] - b[k]);
+          if (d) {
+            pixels++;
+            if (d > maxDiff) maxDiff = d;
+          }
+        }
+        if (pixels) differs.push({ t, pixels, maxDiff });
+      });
+      ms.sort((x, y) => x - y);
+      return { differs: differs.filter((d) => !threw.has(d.t)), drawMs: ms.length ? ms[Math.floor(ms.length / 2)] : 0, threw: times.filter((t) => threw.has(t)) };
+    } finally {
+      rt.destroy(true);
+      if (!wasGroup && view.isRenderGroup) view.disableRenderGroup();
+    }
+  }
+  /** What `layerTexture` asks of this layer: the layers listed before it, PixiJS's renderer, and a place to hook in before every frame. */
+  _makeHost(renderer) {
+    return {
+      findLayer: (name) => this.parent?.findLayer?.(name) ?? null,
+      layerNames: () => this.parent?.layerNames?.() ?? [],
+      pixiRenderer: renderer,
+      beforeDraw: (fn) => {
+        this._drawHooks.add(fn);
+        return () => {
+          this._drawHooks.delete(fn);
+        };
+      },
+      track: (handle) => {
+        this._shown.push(handle);
+        return () => {
+          const i = this._shown.indexOf(handle);
+          if (i >= 0) this._shown.splice(i, 1);
+        };
+      },
+      own: (free) => {
+        this._owned.push(free);
+      }
+    };
+  }
+  /** True when this layer shows 2D layers on its meshes (`layerTexture`): the movie runs its frame after the rest of the frame is ready (projections, filters fed), as for a three layer. */
+  get showsLayers() {
+    return this._shown.length > 0;
+  }
+  /** The 2D layer that a material shows (`layerTexture`), for a click on the mesh to reach it (movie.pick); null for any other material. */
+  screenOf(material) {
+    const handle = this._shown.find((h) => h.material === material);
+    return handle ? { source: handle.source(), at: (u, v) => handle.sourceAt(u, v) } : null;
+  }
+  /** The view's global point at (u, v) of its picture (0..1, v down). */
+  _globalAt(u, v) {
+    const view = this._view;
+    if (!view) return null;
+    const b = view.getLocalBounds();
+    return view.toGlobal({ x: b.x + u * b.width, y: b.y + v * b.height });
+  }
+  /**
+   * Make the scene's meshes hit by a ray, exactly: PixiJS 3D only hits nodes whose eventMode is not 'passive', and by default against the mesh's bounding box (a sphere's corners
+   * count, and the hit has no uv). A mesh the author left as it was gets eventMode 'static' and hitVolume 'geometry' (per triangle: the silhouette, the normal and the uv a 2D
+   * layer on the mesh needs); the author's own choice is kept.
+   */
+  _makePickable() {
+    if (!this._pickStale) return;
+    this._pickStale = false;
+    const root = this._view?.root;
+    root?.traverse((node) => {
+      const n = node;
+      if (n.eventMode !== "passive" || n.geometry === void 0) return;
+      n.eventMode = "static";
+      if (n.hitVolume === void 0 || n.hitVolume === null) n.hitVolume = "geometry";
+    });
+  }
+  /**
+   * `movie.pick`: a ray through (u, v) of the layer's picture (0..1, v down) from the view's camera, and what it meets first: the object's name (its own label, or its nearest
+   * labelled ancestor's), where (scene units), how far from the camera, and the node. Uses the transforms of the last render, which is the frame on screen. null when it meets nothing.
+   */
+  pickAt(u, v) {
+    const view = this._view;
+    const at = this._globalAt(u, v);
+    if (!view || !at) return null;
+    this._makePickable();
+    const hit = view.raycast(at);
+    if (!hit) return null;
+    let name = "";
+    for (let n = hit.target; n && n !== view.root; n = n.parent) {
+      if (n.label && n.label !== n.constructor?.name) {
+        name = n.label;
+        break;
+      }
+    }
+    return {
+      object: name,
+      point: [hit.point.x, hit.point.y, hit.point.z],
+      distance: hit.distance,
+      object3d: hit.target,
+      ...hit.uv ? { uv: { u: hit.uv.x, v: hit.uv.y } } : {},
+      material: hit.target.material
+    };
+  }
+  /**
+   * `hit.scene3d.grab(plane)`: a function of a point (u, v) of the layer's picture that gives where the pointer's ray meets a plane through the grabbed point, and how far that is
+   * from it (`delta`): move the object by it. `plane`: 'screen' (facing the camera: the default), 'floor' (horizontal: y up), 'wall' (z constant), or a normal [x, y, z].
+   * null where the ray never meets the plane.
+   */
+  dragPlane(point, plane = "screen") {
+    const view = this._view;
+    const grabbed = new _3d.Vector3(...point);
+    let normal;
+    if (plane === "floor") normal = new _3d.Vector3(0, 1, 0);
+    else if (plane === "wall") normal = new _3d.Vector3(0, 0, 1);
+    else if (Array.isArray(plane)) normal = new _3d.Vector3(...plane).normalize();
+    else {
+      const m = view?.camera.worldTransform.elements;
+      normal = m ? new _3d.Vector3(m[8], m[9], m[10]).normalize() : new _3d.Vector3(0, 0, 1);
+    }
+    const surface = new _3d.Plane().setFromNormalAndCoplanarPoint(normal, grabbed);
+    return (u, v) => {
+      const at = this._globalAt(u, v);
+      if (!view || !at) return null;
+      const meet = view.screenToRay(at).intersectPlane(surface, new _3d.Vector3());
+      if (!meet) return null;
+      return { point: [meet.x, meet.y, meet.z], delta: [meet.x - grabbed.x, meet.y - grabbed.y, meet.z - grabbed.z] };
+    };
+  }
+  _resolvePath(path) {
+    const segs = path.split(".");
+    if (segs.length < 2) {
+      this._warnPath(path, "needs at least <object>.<prop>");
+      return null;
+    }
+    let obj = this._objects[segs[0]];
+    if (obj == null) {
+      this._warnPath(path, `unknown object "${segs[0]}" (known: ${Object.keys(this._objects).join(", ")}): expose it in setup's { objects }`);
+      return null;
+    }
+    for (let i = 1; i < segs.length - 1; i++) {
+      obj = obj[segs[i]];
+      if (obj == null) {
+        this._warnPath(path, `"${segs[i]}" is undefined along the path`);
+        return null;
+      }
+    }
+    const prop = segs[segs.length - 1];
+    if (typeof obj !== "object" || !(prop in obj)) {
+      this._warnPath(path, `no property "${prop}"`);
+      return null;
+    }
+    return { target: obj, prop };
+  }
+  _warnPath(path, why) {
+    this._say(`path:${path}`, `keyframe path scene3d.${path}: ${why}; skipped`);
+  }
+  _destroyView() {
+    const view = this._view;
+    this._view = null;
+    if (this.target === view) this.target = null;
+    try {
+      view?.destroy({ children: true });
+    } catch (err) {
+      console.warn(`${this._who()}: destroying the view threw \u2014`, err);
+    }
+  }
+  destroy() {
+    const spec = this._spec;
+    const kept = this._donated || this._borrowed !== null;
+    if (!kept) {
+      if (this._ctx && spec.dispose) {
+        try {
+          spec.dispose(this._ctx);
+        } catch (err) {
+          console.warn(`${this._who()}: dispose() threw \u2014`, err);
+        }
+      }
+      for (const h of [...this._shown]) {
+        try {
+          h.dispose();
+        } catch {
+        }
+      }
+      this._drawHooks.clear();
+      for (const free of this._owned.splice(0)) free();
+      this._lightMirror?.dispose();
+    }
+    if (!kept) {
+      this._shown = [];
+      this._drawHooks = /* @__PURE__ */ new Set();
+      this._owned = [];
+    }
+    this._pendingRebinds = [];
+    this._borrowed = null;
+    this._lightMirror = null;
+    this._fogMirror = null;
+    this._ctx = null;
+    this._objects = {};
+    this._players = [];
+    this._destroyView();
+    this._look?.destroy();
+    this._look = null;
+    this._blend?.destroy();
+    this._blend = null;
+    super.destroy();
+  }
+};
+var ids = /* @__PURE__ */ new WeakMap();
+var lastId = 0;
+function idOf(fn) {
+  if (typeof fn !== "function") return 0;
+  let id = ids.get(fn);
+  if (id === void 0) {
+    id = ++lastId;
+    ids.set(fn, id);
+  }
+  return id;
+}
+function reuseKeyOf(spec, width, height) {
+  let view;
+  try {
+    view = JSON.stringify(spec.view ?? null) ?? "null";
+  } catch {
+    return null;
+  }
+  return JSON.stringify(["scene3d", spec.name, idOf(spec.setup), width, height, spec.resolution ?? 1, view, !!spec.followCamera, !!spec.followLights, !!spec.followFog]);
+}
+function resolveDim(v, scope) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number") return v;
+  return chunk33USHRV5_cjs.evaluateExpr(v, scope);
+}
+var label2 = "pixi-effects: loadModel";
+async function loadModel(url, options = {}) {
+  if (typeof url !== "string" || !url) throw new Error(`${label2}: the first argument is the model's URL: await loadModel('model.glb')`);
+  const source = await pixi_js.Assets.load(url);
+  const model = new _3d.Model3D({ source, autoUpdate: false, autoPlay: false });
+  const player = model.player;
+  const clips = player ? [...player.animationLabels] : [];
+  const speed = options.speed ?? 1, offset = options.offset ?? 0, loop = options.loop !== false;
+  let clip = null;
+  if (options.animation === void 0) clip = clips[0] ?? null;
+  else if (options.animation === false) clip = null;
+  else if (typeof options.animation === "number") {
+    clip = clips[options.animation] ?? null;
+    if (clip === null) throw new Error(`${label2}: the model has no clip number ${options.animation} (it has ${clips.length}${clips.length ? `: ${clips.map((c) => `"${c}"`).join(", ")}` : ""})`);
+  } else {
+    if (!clips.includes(options.animation)) throw new Error(`${label2}: the model has no clip "${options.animation}" (its clips: ${clips.length ? clips.map((c) => `"${c}"`).join(", ") : "none"})`);
+    clip = options.animation;
+  }
+  const object = new _3d.Container3D({ label: url.split("/").pop() ?? "model" });
+  object.addChild(model);
+  const box = model.getLocalBounds();
+  model.position.set(-(box.min.x + box.max.x) / 2, -(box.min.y + box.max.y) / 2, -(box.min.z + box.max.z) / 2);
+  const base = { x: box.max.x - box.min.x, y: box.max.y - box.min.y, z: box.max.z - box.min.z };
+  const state = clip !== null && player ? player.getState(clip) : null;
+  const pose = (t) => {
+    if (!state) return;
+    const length = state.animation.duration;
+    const x = t * speed + offset;
+    state.gotoAndStop(length > 0 ? loop ? (x % length + length) % length : Math.min(Math.max(x, 0), length) : 0);
+  };
+  pose(0);
+  return {
+    object,
+    model,
+    clips,
+    size: () => ({ x: base.x * object.scale.x, y: base.y * object.scale.y, z: base.z * object.scale.z }),
+    fit: (n) => {
+      const longest = Math.max(base.x, base.y, base.z);
+      if (!(n > 0) || !(longest > 0)) throw new Error(`${label2}: fit(n) needs a size above 0 (got ${n}) and a model with a size (its box is ${base.x} x ${base.y} x ${base.z})`);
+      const k = n / longest;
+      object.scale.set(k, k, k);
+    },
+    pose
+  };
+}
+function fitCamera(ctx, object, options = {}) {
+  const camera = ctx.camera;
+  const box = object.getLocalBounds().applyMatrix4(object.getGlobalTransform(new _3d.Matrix4()));
+  const centre = new _3d.Vector3((box.min.x + box.max.x) / 2, (box.min.y + box.max.y) / 2, (box.min.z + box.max.z) / 2);
+  const margin = options.margin ?? 1.1;
+  const [dx, dy, dz] = options.direction ?? [0.45, 0.3, 1];
+  const toCamera = new _3d.Vector3(dx, dy, dz).normalize();
+  const right = new _3d.Vector3(0, 1, 0).cross(toCamera);
+  if (right.x * right.x + right.y * right.y + right.z * right.z < 1e-12) right.set(1, 0, 0);
+  right.normalize();
+  const up = toCamera.clone().cross(right);
+  const tanV = Math.tan(camera.fov * Math.PI / 360), tanH = tanV * (ctx.width / ctx.height);
+  let distance = 1e-3;
+  for (const x of [box.min.x, box.max.x]) for (const y of [box.min.y, box.max.y]) for (const z of [box.min.z, box.max.z]) {
+    const r = new _3d.Vector3(x - centre.x, y - centre.y, z - centre.z);
+    const along = r.dot(toCamera);
+    distance = Math.max(distance, along + Math.abs(r.dot(right)) * margin / tanH, along + Math.abs(r.dot(up)) * margin / tanV);
+  }
+  camera.mode = "perspective";
+  camera.position.set(centre.x + toCamera.x * distance, centre.y + toCamera.y * distance, centre.z + toCamera.z * distance);
+  camera.near = Math.max(distance / 100, 1e-4);
+  camera.far = distance * 100;
+  camera.lookAt(centre);
+}
+
+// src/3d/index.ts
+var saidVersion = false;
+function versionAtLeast(v, min) {
+  const [a, b] = v.split(".").map(Number);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return true;
+  return a > min[0] || a === min[0] && b >= min[1];
+}
+function register3D() {
+  if (!saidVersion && !versionAtLeast(String(pixi_js.VERSION), [8, 23])) {
+    saidVersion = true;
+    console.warn(`pixi-effects: PixiJS 3D needs pixi.js 8.23.0 or later (this page has ${pixi_js.VERSION}): put pixi.js@8.23.0 in the import map`);
+  }
+  _3d.Model3D.defaultOptions.autoUpdate = false;
+  _3d.AnimationPlayer.defaultOptions.autoUpdate = false;
+  chunk33USHRV5_cjs.registerSequenceType("scene3d", Scene3DSequence);
+}
+function scene3d(spec) {
+  return spec;
+}
+
+exports.Scene3DSequence = Scene3DSequence;
+exports.fitCamera = fitCamera;
+exports.layerTexture = layerTexture;
+exports.loadModel = loadModel;
+exports.register3D = register3D;
+exports.scene3d = scene3d;
+//# sourceMappingURL=3d.cjs.map
+//# sourceMappingURL=3d.cjs.map