@voluma/vlam 0.2.2 → 0.2.4

package/README.md

@@ -16,9 +16,7 @@ Local site and generated API: `npm run dev` (http://localhost:5170, viewer at `/
 > Package `@voluma/vlam`, public **0.2.0**. APIs may still move before 1.0.
 
 ## Important notice!
-This is a pre-release. The API can still change in breaking ways before v1.0. Great for prototypes and experiments, not yet recommended for production.
-
-Phones and Intel/AMD integrated GPUs still need more device runs. A Galaxy S24 Ultra holds WebGPU; goose.sog is locked 60 rAF in SD and ~58 in HD, streamed million-splat views are fill-bound. On a MacBook Air M3 the demo keeps the fill-constrained (SD) preset; HD is a toggle, not the default.
+This is a pre-release not yet recommended for production. The API can still change in breaking ways before v1.0.
 
 
 ## Install

package/dist/effects.d.ts

@@ -15,6 +15,12 @@
  *    tiles (or raw geometries) for PlayCanvas-style {@link SplatMesh.setRelighting}.
  *  - {@link createRelightingShadowFactorMaterial}: writes a shadow **multiplier**
  *    (1 = lit, <1 = umbra) so coverage does not statically tint splats.
+ *    Accepts one light or {@link RelightingLightContribution}[] with intensity
+ *    weights. Optional `color` / `diffuse` / `direction` add a Lambert boost on
+ *    top of that identity (RGB may exceed 1 on a HalfFloat lighting RT).
+ *  - {@link renderRelightingFactorMap}: host-safe lighting pass. Isolates
+ *    `autoClear`, shadow maps, and swaps a passthrough `contextNode` so the
+ *    example works on an existing `WebGPURenderer`, not only `createSplatRenderer`.
  *  - {@link worldWarpPreset}: camera-centered sphere wrap (planet / bowl).
  *  - {@link depthOfFieldPreset}: stylized modifier-based depth-of-field (M13).
  *    For physically-modeled camera DoF prefer the core
@@ -262,6 +268,7 @@ export declare function worldWarpPreset(options?: {
     intensity?: number;
     radius?: number;
 }): WorldWarpPreset;
+export { renderRelightingFactorMap, type RelightingFactorRenderer } from './relighting-pass';
 /** Handle returned by {@link createRelightingProxy}. */
 export interface RelightingProxy {
     /** World-space group of lit proxy meshes (hide from the main splat scene). */
@@ -274,14 +281,77 @@ export interface RelightingProxy {
     /** Disposes geometries and the default material owned by this helper. */
     dispose(): void;
 }
+/** One independent shadow-casting light for {@link createRelightingShadowFactorMaterial}. */
+export type RelightingLightContribution = {
+    light: THREE.Light;
+    /** Relative umbra weight. Default `1`. Values `<= 0` are skipped unless `fill` is set. */
+    intensity?: number;
+    /**
+     * Additive Lambert fill on top of the umbra factor (RGB may exceed 1).
+     * Gated by `shadow()`, facing, and for spot/point lights the Frostbite
+     * `distance` window (and the spot cone). `0` / omitted = umbra only.
+     */
+    fill?: number;
+};
+/** Options for {@link createRelightingShadowFactorMaterial}. */
+export type RelightingShadowFactorOptions = {
+    umbra?: number;
+    receiveUpMin?: number;
+    color?: THREE.Color;
+    diffuse?: number;
+    direction?: THREE.Vector3;
+    /**
+     * How independent contributions combine into one multiplier.
+     * - `average` (default): intensity-weighted mean of shadows (fill lights).
+     * - `min`: union of umbras — each caster keeps its own silhouette. Contribution
+     *   `intensity` scales umbra depth: `0` → none, `1` → default `umbra`,
+     *   `>1` → darker than default (`umbra_i = clamp(1 - I*(1-umbra), 0, 1)`).
+     */
+    combine?: 'average' | 'min';
+    midLight?: THREE.Light;
+    midRadius?: number;
+    outerLight?: THREE.Light;
+    outerRadius?: number;
+    farLight?: THREE.Light;
+    nearRadius?: number;
+};
+/**
+ * Cap on independent shadow lights (cascades of the first directional do not
+ * count). Extra contributions are ignored. The compiled graph unrolls only
+ * the live contribution count, not a padded 32-wide loop.
+ */
+export declare const MAX_RELIGHTING_SHADOW_LIGHTS = 32;
 /**
  * Node material for a **shadow-factor** lighting RT used with
  * {@link SplatMesh.setRelighting}.
  *
- * Fragment output is `vec4(vec3(mix(umbra, 1, shadow(light))), 1)`:
+ * Fragment output is `vec4(vec3(mix(umbra, 1, shadow)) + boost, 1)`:
  *  - covered + lit → RGB ≈ 1 (identity modulate when brightness/background are 1)
  *  - covered + umbra → RGB ≈ `umbra` (soft darken; never pure black)
  *  - uncovered stays clear-alpha 0 from the RT clear
+ *  - with `diffuse` &gt; 0, facing surfaces add `color * NdotL * diffuse`
+ *    (RGB may exceed 1; use a HalfFloat lighting RT)
+ *
+ * Pass one {@link THREE.Light} (demo / single-sun) or an array of
+ * {@link RelightingLightContribution} so independent lights share one
+ * multiplier. Default combine is intensity-weighted average
+ * (`illum = sum(I_i * shadow_i) / sum(I_i)`); pass `combine: 'min'` for a
+ * union of umbras so each caster keeps its silhouette. Spot / point lights
+ * with `distance &gt; 0` fade their umbra to lit via a Frostbite cutoff window
+ * (steepened by `decay`) so the shadow map far plane is not a hard cliff.
+ * Contribution `fill` adds occluded Lambert (range + cone for punctual lights)
+ * on top of that identity so marker lamps can light splats without wrapping
+ * through collision. Cascades (`midLight` / `outerLight` / `farLight`) still
+ * attach to the **first** directional only. At most
+ * {@link MAX_RELIGHTING_SHADOW_LIGHTS} independent lights are used; extras
+ * are ignored. Graph size follows the live contribution count (not a padded
+ * loop of that width).
+ *
+ * By default, only **upward** proxy faces receive (`receiveUpMin`). Vertical
+ * and noisy foliage triangles still **cast**, but they do not self-shadow —
+ * that PCF acne reads as per-frame sparkle in trees. Pass `receiveUpMin: 0`
+ * to receive on every face. Contribution `fill` does **not** use that slope
+ * gate (stems would otherwise stay unlit in the factor map).
  *
  * Clear the lighting RT to **RGB 1, A 0** (not black). Softness / bilinear
  * samples at coverage edges otherwise pull in black and draw a dark outline
@@ -292,12 +362,36 @@ export interface RelightingProxy {
  * Assign to proxy meshes with `castShadow` and `receiveShadow` both true; the
  * umbra shape follows those triangles (splat foliage cannot cast).
  *
- * @param light - Shadow-casting light (typically a {@link THREE.DirectionalLight}).
+ * @param lights - Shadow-casting light, or intensity-weighted contributions.
+ *   The first entry is the innermost cascade when `midLight` / `outerLight` /
+ *   `farLight` are set.
  * @param options.umbra - Multiplier in full shadow, in `[0, 1]`. Default `0.45`.
+ * @param options.receiveUpMin - World-up `normal.y` below which the face does
+ *   not receive. Default `0.25`. `0` disables the slope gate.
+ * @param options.color - Light tint for the optional Lambert boost. Mutate
+ *   in place; the material holds this object. Default white.
+ * @param options.diffuse - Lambert boost on top of identity. Default `0`
+ *   (shadow multiplier only). Facing, unshadowed coverage becomes
+ *   `1 + color * NdotL * diffuse`.
+ * @param options.direction - World-space direction **toward** the light.
+ *   Mutate in place each frame as the sun moves. Default `(0, 1, 0)`.
+ * @param options.midLight - Optional mid cascade (demo: ~50 m). Blend from
+ *   the first light over `nearRadius`.
+ * @param options.midRadius - World metres where the mid cascade yields to
+ *   `outerLight` (or `farLight`). Default `50`.
+ * @param options.outerLight - Optional outer cascade (demo: ~160 m) between
+ *   mid and scene-sized far. Blend from mid over `midRadius`, then to
+ *   `farLight` over `outerRadius`.
+ * @param options.outerRadius - World metres where the outer cascade yields to
+ *   `farLight`. Default `160`. Ignored without `outerLight` and `farLight`.
+ * @param options.farLight - Optional scene-sized cascade. Out-of-frustum
+ *   `shadow()` is 1 (lit), so inner maps can stay tight without clipping
+ *   distant umbras. Blend by camera distance.
+ * @param options.nearRadius - World metres where the inner cascade yields to
+ *   `midLight` (or to `farLight` if there is no mid). Default `20` with
+ *   `midLight`, else `100`.
  */
-export declare function createRelightingShadowFactorMaterial(light: THREE.Light, options?: {
-    umbra?: number;
-}): THREE.MeshStandardNodeMaterial;
+export declare function createRelightingShadowFactorMaterial(lights: THREE.Light | RelightingLightContribution[], options?: RelightingShadowFactorOptions): THREE.MeshStandardNodeMaterial;
 /**
  * Builds a PlayCanvas-style relighting **proxy** from collision tiles or raw
  * geometries. The host places {@link RelightingProxy.group} on a dedicated

package/dist/effects.js

@@ -1,87 +1,100 @@
-import * as g from "three/webgpu";
-import { shadow as te, mix as x, float as i, vec4 as O, vec3 as h, uniform as C, wgslFn as se, uniformArray as ne, smoothstep as X, int as oe, mat3 as re, modelViewMatrix as ae, vec2 as ce } from "three/tsl";
-import { w as ie } from "./logging-BfPdd7NJ.js";
-const Q = 5, le = { tint: 0, desaturate: 1, hide: 2, rim: 3 }, de = [0, 0, 0], ue = [1, 1, 1], fe = [0, 0, 0, 1];
-function ye(o = [], n = {}) {
-  const r = Math.max(1, Math.floor(n.maxShapes ?? 32)), t = [];
-  for (let e = 0; e < r * Q; e++) t.push(new g.Vector4());
-  const d = ne(t, "vec4"), f = C(0, "int");
-  let u = !1;
-  const l = (e) => {
-    const m = Math.min(e.length, r);
-    e.length > r && !u && (u = !0, ie(
-      `sdfEffects: ${e.length} shapes exceeds maxShapes=${r}; extra shapes are ignored. Raise maxShapes if you need more.`
+import * as w from "three/webgpu";
+import { context as mt, positionWorld as ot, cameraPosition as ft, smoothstep as F, float as a, normalWorld as Q, mix as p, min as ht, vec3 as v, uniform as R, vec4 as U, wgslFn as gt, uniformArray as xt, shadow as L, objectPosition as O, cos as nt, int as bt, mat3 as pt, modelViewMatrix as wt, reference as Mt, frameGroup as vt, vec2 as yt } from "three/tsl";
+import { w as Ct } from "./logging-BfPdd7NJ.js";
+const Z = new w.Vector2(), st = new w.Color(), Tt = mt({
+  getOutput: (t) => t
+});
+function Gt(t, e, c, o) {
+  t.getDrawingBufferSize(Z), o.setSize(Math.max(1, Z.x), Math.max(1, Z.y));
+  const m = t.getRenderTarget(), l = t.getActiveCubeFace(), d = t.getActiveMipmapLevel(), i = t.getMRT(), b = t.getClearAlpha(), n = t.autoClear, x = t.shadowMap.enabled, u = t.shadowMap.autoUpdate, s = t.contextNode;
+  t.getClearColor(st);
+  try {
+    t.contextNode = Tt, t.autoClear = !0, t.shadowMap.enabled = !0, u === !1 && (t.shadowMap.autoUpdate = !0), t.setMRT(null), t.setRenderTarget(o), t.setClearColor(16777215, 0), t.clear(), t.render(e, c);
+  } finally {
+    t.setRenderTarget(m, l, d), t.setMRT(i), t.setClearColor(st, b), t.autoClear = n, t.shadowMap.enabled = x, u !== void 0 && (t.shadowMap.autoUpdate = u), t.contextNode = s;
+  }
+}
+const tt = 5, Rt = { tint: 0, desaturate: 1, hide: 2, rim: 3 }, St = [0, 0, 0], kt = [1, 1, 1], Lt = [0, 0, 0, 1];
+function Vt(t = [], e = {}) {
+  const c = Math.max(1, Math.floor(e.maxShapes ?? 32)), o = [];
+  for (let n = 0; n < c * tt; n++) o.push(new w.Vector4());
+  const m = xt(o, "vec4"), l = R(0, "int");
+  let d = !1;
+  const i = (n) => {
+    const x = Math.min(n.length, c);
+    n.length > c && !d && (d = !0, Ct(
+      `sdfEffects: ${n.length} shapes exceeds maxShapes=${c}; extra shapes are ignored. Raise maxShapes if you need more.`
     ));
-    for (let c = 0; c < m; c++) {
-      const s = e[c];
+    for (let u = 0; u < x; u++) {
+      const s = n[u];
       if (s.kind === "box") {
-        const a = s.halfExtents;
-        if (!a || !(a[0] > 0) || !(a[1] > 0) || !(a[2] > 0))
+        const f = s.halfExtents;
+        if (!f || !(f[0] > 0) || !(f[1] > 0) || !(f[2] > 0))
           throw new Error(
-            `sdfEffects.setShapes: shape ${c} is a box and requires halfExtents with three positive components (got ${a ? `[${a.join(", ")}]` : "undefined"}).`
+            `sdfEffects.setShapes: shape ${u} is a box and requires halfExtents with three positive components (got ${f ? `[${f.join(", ")}]` : "undefined"}).`
           );
       } else if (typeof s.radius == "number" && s.radius > 0) {
         if (s.kind === "cylinder" && !(typeof s.height == "number" && s.height > 0))
           throw new Error(
-            `sdfEffects.setShapes: shape ${c} is a cylinder and requires a positive height (got ${String(s.height)}).`
+            `sdfEffects.setShapes: shape ${u} is a cylinder and requires a positive height (got ${String(s.height)}).`
           );
       } else throw new Error(
-        `sdfEffects.setShapes: shape ${c} is a ${s.kind} and requires a positive radius (got ${String(s.radius)}).`
+        `sdfEffects.setShapes: shape ${u} is a ${s.kind} and requires a positive radius (got ${String(s.radius)}).`
       );
     }
-    for (let c = 0; c < m; c++) {
-      const s = e[c], a = c * Q, w = s.center ?? de, p = s.color ?? ue, y = s.rotation ?? fe, E = s.kind === "box" ? 1 : s.kind === "cylinder" ? 2 : 0;
-      if (t[a + 0].set(w[0], w[1], w[2], E), s.kind === "box") {
-        const v = s.halfExtents;
-        t[a + 1].set(v[0], v[1], v[2], s.falloff ?? 0);
-      } else s.kind === "cylinder" ? t[a + 1].set(
+    for (let u = 0; u < x; u++) {
+      const s = n[u], f = u * tt, h = s.center ?? St, r = s.color ?? kt, g = s.rotation ?? Lt, y = s.kind === "box" ? 1 : s.kind === "cylinder" ? 2 : 0;
+      if (o[f + 0].set(h[0], h[1], h[2], y), s.kind === "box") {
+        const M = s.halfExtents;
+        o[f + 1].set(M[0], M[1], M[2], s.falloff ?? 0);
+      } else s.kind === "cylinder" ? o[f + 1].set(
         s.radius,
         s.height / 2,
         0,
         s.falloff ?? 0
-      ) : t[a + 1].set(s.radius, 0, 0, s.falloff ?? 0);
-      t[a + 2].set(p[0], p[1], p[2], le[s.mode]), t[a + 3].set(y[0], y[1], y[2], y[3]), t[a + 4].set(s.invert ? 1 : 0, s.strength ?? 1, 0, 0);
+      ) : o[f + 1].set(s.radius, 0, 0, s.falloff ?? 0);
+      o[f + 2].set(r[0], r[1], r[2], Rt[s.mode]), o[f + 3].set(g[0], g[1], g[2], g[3]), o[f + 4].set(s.invert ? 1 : 0, s.strength ?? 1, 0, 0);
     }
-    f.value = m;
+    l.value = x;
   };
-  return l(o), { modifier: (e) => {
-    const m = e.localCenter;
-    let c = e.color.rgb, s = i(1);
-    for (let a = 0; a < r; a++) {
-      const w = a * Q, p = (ee) => d.element(w + ee), y = p(0), E = p(1), v = p(2), R = p(3), D = p(4), U = y.xyz, P = y.w, T = E.xyz, $ = E.w.max(1e-4), B = v.xyz, M = v.w, L = D.x, N = D.y, V = oe(a).lessThan(f).select(i(1), i(0)), I = m.sub(U), z = xe(R, I), A = z.length().sub(T.x), k = me(z, T), q = he(z, T.x, T.y), F = P.greaterThan(0.5).and(P.lessThan(1.5)).select(i(1), i(0)), G = P.greaterThan(1.5).select(i(1), i(0)), W = x(x(A, k, F), q, G), _ = x(W, W.negate(), L), S = i(1).sub(X(0, $, _)).mul(N).mul(V), j = i(1).sub(X(0, $, _.abs())).mul(N).mul(V), H = M.lessThan(0.5).select(i(1), i(0)), J = M.greaterThan(0.5).and(M.lessThan(1.5)).select(i(1), i(0)), K = M.greaterThan(1.5).and(M.lessThan(2.5)).select(i(1), i(0)), Y = M.greaterThan(2.5).select(i(1), i(0)), Z = c.dot(h(0.2126, 0.7152, 0.0722));
-      c = x(c, B, S.mul(H)), c = x(c, h(Z), S.mul(J)), c = x(c, B, j.mul(Y)), s = s.mul(i(1).sub(S.mul(K)));
+  return i(t), { modifier: (n) => {
+    const x = n.localCenter;
+    let u = n.color.rgb, s = a(1);
+    for (let f = 0; f < c; f++) {
+      const h = f * tt, r = (dt) => m.element(h + dt), g = r(0), y = r(1), M = r(2), C = r(3), T = r(4), J = g.xyz, N = g.w, z = y.xyz, _ = y.w.max(1e-4), G = M.xyz, S = M.w, K = T.x, V = T.y, B = bt(f).lessThan(l).select(a(1), a(0)), W = x.sub(J), E = At(C, W), P = E.length().sub(z.x), k = zt(E, z), $ = Et(E, z.x, z.y), D = N.greaterThan(0.5).and(N.lessThan(1.5)).select(a(1), a(0)), j = N.greaterThan(1.5).select(a(1), a(0)), q = p(p(P, k, D), $, j), H = p(q, q.negate(), K), A = a(1).sub(F(0, _, H)).mul(V).mul(B), X = a(1).sub(F(0, _, H.abs())).mul(V).mul(B), Y = S.lessThan(0.5).select(a(1), a(0)), ct = S.greaterThan(0.5).and(S.lessThan(1.5)).select(a(1), a(0)), rt = S.greaterThan(1.5).and(S.lessThan(2.5)).select(a(1), a(0)), lt = S.greaterThan(2.5).select(a(1), a(0)), ut = u.dot(v(0.2126, 0.7152, 0.0722));
+      u = p(u, G, A.mul(Y)), u = p(u, v(ut), A.mul(ct)), u = p(u, G, X.mul(lt)), s = s.mul(a(1).sub(A.mul(rt)));
     }
-    return { color: O(c, e.color.a.mul(s)) };
-  }, setShapes: l, maxShapes: r, _uniforms: { slots: t, count: f } };
+    return { color: U(u, n.color.a.mul(s)) };
+  }, setShapes: i, maxShapes: c, _uniforms: { slots: o, count: l } };
 }
-function me(o, n) {
-  const r = o.abs().sub(n), t = r.max(h(0, 0, 0)).length(), d = r.x.max(r.y.max(r.z)).min(0);
-  return t.add(d);
+function zt(t, e) {
+  const c = t.abs().sub(e), o = c.max(v(0, 0, 0)).length(), m = c.x.max(c.y.max(c.z)).min(0);
+  return o.add(m);
 }
-function he(o, n, r) {
-  const t = o.xz.length().sub(n), d = o.y.abs().sub(r), f = ce(t.max(0), d.max(0)).length(), u = t.max(d).min(0);
-  return f.add(u);
+function Et(t, e, c) {
+  const o = t.xz.length().sub(e), m = t.y.abs().sub(c), l = yt(o.max(0), m.max(0)).length(), d = o.max(m).min(0);
+  return l.add(d);
 }
-function xe(o, n) {
-  const r = o.xyz, t = o.w, d = r.cross(n).mul(2);
-  return n.sub(d.mul(t)).add(r.cross(d));
+function At(t, e) {
+  const c = t.xyz, o = t.w, m = c.cross(e).mul(2);
+  return e.sub(m.mul(o)).add(c.cross(m));
 }
-function we(o = {}) {
-  const n = new g.Vector3(...o.direction ?? [0.3, 1, 0.6]).normalize(), r = C(n), t = i(o.ambient ?? 0.35), d = i(o.diffuse ?? 0.75);
-  return { modifier: (u) => {
-    const l = u.normal.dot(r.normalize()).max(0), b = t.add(l.mul(d));
-    return { color: O(u.color.rgb.mul(b), u.color.a) };
-  }, direction: r };
+function Bt(t = {}) {
+  const e = new w.Vector3(...t.direction ?? [0.3, 1, 0.6]).normalize(), c = R(e), o = a(t.ambient ?? 0.35), m = a(t.diffuse ?? 0.75);
+  return { modifier: (d) => {
+    const i = d.normal.dot(c.normalize()).max(0), b = o.add(i.mul(m));
+    return { color: U(d.color.rgb.mul(b), d.color.a) };
+  }, direction: c };
 }
-function ve(o = {}) {
-  const n = C(Math.max(1e-4, o.focusDistance ?? 10)), r = C(Math.max(0, o.aperture ?? 0.5)), t = i(Math.max(0, o.maxBlur ?? 6));
-  return { modifier: (f) => {
-    const u = f.viewCenter.z.negate().max(1e-4), l = n.max(1e-4), b = u.sub(l).abs().div(l).mul(r).min(t), e = i(1).add(b), m = f.color.a.div(e.mul(e));
-    return { scale: f.scale.mul(e), color: O(f.color.rgb, m) };
-  }, focusDistance: n, aperture: r };
+function Wt(t = {}) {
+  const e = R(Math.max(1e-4, t.focusDistance ?? 10)), c = R(Math.max(0, t.aperture ?? 0.5)), o = a(Math.max(0, t.maxBlur ?? 6));
+  return { modifier: (l) => {
+    const d = l.viewCenter.z.negate().max(1e-4), i = e.max(1e-4), b = d.sub(i).abs().div(i).mul(c).min(o), n = a(1).add(b), x = l.color.a.div(n.mul(n));
+    return { scale: l.scale.mul(n), color: U(l.color.rgb, x) };
+  }, focusDistance: e, aperture: c };
 }
-function Me(o = {}) {
-  const n = C(0), r = o.frequency ?? 3, t = Math.min(Math.max(o.edge ?? 0.08, 0), 0.5), d = se(
+function $t(t = {}) {
+  const e = R(0), c = t.frequency ?? 3, o = Math.min(Math.max(t.edge ?? 0.08, 0), 0.5), m = gt(
     /* wgsl */
     `
     fn vnoise( x: vec3<f32> ) -> f32 {
@@ -108,73 +121,163 @@ function Me(o = {}) {
     }
   `
   );
-  return { modifier: (u) => {
-    const l = d({ x: u.localCenter.mul(r) }), b = l.mul(1 - 2 * t).add(t), e = X(b.sub(t), b.add(t), n), m = n.greaterThan(b.sub(t));
-    return { color: O(u.color.rgb, u.color.a.mul(e)), visible: m };
-  }, progress: n };
-}
-function ke(o = {}) {
-  const n = C(Math.min(1, Math.max(-1, o.intensity ?? 0))), r = C(Math.max(1e-4, o.radius ?? 1));
   return { modifier: (d) => {
-    const f = n.clamp(-1, 1), u = r.max(1e-4), l = d.viewCenter, b = f.max(0), e = f.negate().max(0), m = l.z.negate().max(0), c = m.div(u).atan().mul(i(Math.PI * 0.5)), s = c.cos(), a = c.sin(), w = a.negate(), p = h(l.x, l.y.mul(s).sub(l.z.mul(a)), l.y.mul(a).add(l.z.mul(s))), y = h(l.x, l.y.mul(s).sub(l.z.mul(w)), l.y.mul(w).add(l.z.mul(s))), E = x(x(l, p, e), y, b), v = i(Math.PI * 0.5).mul(u), R = l.z.lessThan(0).select(v.negate().div(m.mul(m).add(u.mul(u))), i(0)), D = R.negate(), U = h(1, 0, 0), P = h(0, s, a), T = h(0, a.negate().sub(p.z.mul(R)), s.add(p.y.mul(R))), $ = h(1, 0, 0), B = h(0, s, w), M = h(
+    const i = m({ x: d.localCenter.mul(c) }), b = i.mul(1 - 2 * o).add(o), n = F(b.sub(o), b.add(o), e), x = e.greaterThan(b.sub(o));
+    return { color: U(d.color.rgb, d.color.a.mul(n)), visible: x };
+  }, progress: e };
+}
+function jt(t = {}) {
+  const e = R(Math.min(1, Math.max(-1, t.intensity ?? 0))), c = R(Math.max(1e-4, t.radius ?? 1));
+  return { modifier: (m) => {
+    const l = e.clamp(-1, 1), d = c.max(1e-4), i = m.viewCenter, b = l.max(0), n = l.negate().max(0), x = i.z.negate().max(0), u = x.div(d).atan().mul(a(Math.PI * 0.5)), s = u.cos(), f = u.sin(), h = f.negate(), r = v(i.x, i.y.mul(s).sub(i.z.mul(f)), i.y.mul(f).add(i.z.mul(s))), g = v(i.x, i.y.mul(s).sub(i.z.mul(h)), i.y.mul(h).add(i.z.mul(s))), y = p(p(i, r, n), g, b), M = a(Math.PI * 0.5).mul(d), C = i.z.lessThan(0).select(M.negate().div(x.mul(x).add(d.mul(d))), a(0)), T = C.negate(), J = v(1, 0, 0), N = v(0, s, f), z = v(0, f.negate().sub(r.z.mul(C)), s.add(r.y.mul(C))), _ = v(1, 0, 0), G = v(0, s, h), S = v(
       0,
-      w.negate().sub(y.z.mul(D)),
-      s.add(y.y.mul(D))
-    ), L = h(1, 0, 0), N = h(0, 1, 0), V = h(0, 0, 1), I = x(x(L, U, e), $, b), z = x(x(N, P, e), B, b), A = x(x(V, T, e), M, b), k = I.div(I.length().max(1e-6)), q = z.sub(k.mul(k.dot(z))), F = q.div(q.length().max(1e-6)), G = A.sub(k.mul(k.dot(A))).sub(F.mul(F.dot(A))), W = G.div(G.length().max(1e-6)), _ = re(k, F, W), S = ae.toMat3(), j = S.transpose(), H = j.mul(_).mul(S);
+      h.negate().sub(g.z.mul(T)),
+      s.add(g.y.mul(T))
+    ), K = v(1, 0, 0), V = v(0, 1, 0), B = v(0, 0, 1), W = p(p(K, J, n), _, b), E = p(p(V, N, n), G, b), P = p(p(B, z, n), S, b), k = W.div(W.length().max(1e-6)), $ = E.sub(k.mul(k.dot(E))), D = $.div($.length().max(1e-6)), j = P.sub(k.mul(k.dot(P))).sub(D.mul(D.dot(P))), q = j.div(j.length().max(1e-6)), H = pt(k, D, q), A = wt.toMat3(), X = A.transpose(), Y = X.mul(H).mul(A);
     return {
-      offset: d.offset.add(j.mul(E.sub(l))),
-      rotation: H.mul(d.rotation)
+      offset: m.offset.add(X.mul(y.sub(i))),
+      rotation: Y.mul(m.rotation)
     };
-  }, intensity: n, radius: r };
+  }, intensity: e, radius: c };
 }
-function Ce(o, n = {}) {
-  const r = Number.isFinite(n.umbra) ? Math.min(1, Math.max(0, n.umbra)) : 0.45, t = new g.MeshStandardNodeMaterial();
-  t.side = g.DoubleSide, t.color = new g.Color(1, 1, 1), t.roughness = 1, t.metalness = 0, t.transparent = !1, t.depthWrite = !0, t.polygonOffset = !0, t.polygonOffsetFactor = 1, t.polygonOffsetUnits = 1;
-  const d = te(o), f = x(i(r), i(1), d);
-  return t.outputNode = O(h(f), i(1)), t;
+const Ft = 32, et = (t) => {
+  const e = t.intensity;
+  return Number.isFinite(e) ? Math.max(0, e) : 1;
+}, it = (t) => {
+  const e = t.fill;
+  return Number.isFinite(e) ? Math.max(0, e) : 0;
+}, I = (t, e, c) => {
+  const o = Mt(t, e, c);
+  return o.setGroup(vt), o;
+}, at = (t) => {
+  const e = t;
+  if (!(e.isSpotLight === !0 || e.isPointLight === !0)) return a(1);
+  if (!(Number(e.distance) > 0)) return a(1);
+  const m = Math.max(Number(e.decay) || 1, 0.01), l = ot.distance(O(e)), d = I("distance", "float", e).max(1e-4), i = l.div(d).pow4().oneMinus().clamp().pow2();
+  return i.pow(a(m));
+}, Nt = (t, e, c) => {
+  const o = t, m = o.isSpotLight === !0, l = o.isPointLight === !0;
+  if (!m && !l) return v(0, 0, 0);
+  const d = O(o), i = d.sub(ot), b = i.length().max(1e-4), n = i.div(b), x = Q.dot(n).max(0), u = at(t);
+  let s = u.mul(x).mul(c);
+  if (m) {
+    const h = t, r = O(h.target).sub(d).normalize(), g = I("angle", "float", h).max(1e-3), y = I("penumbra", "float", h).clamp(0, 0.95), M = g.mul(a(1).sub(y)).max(1e-3), C = F(nt(g), nt(M), n.negate().dot(r));
+    s = s.mul(C);
+  }
+  const f = I("color", "color", t);
+  return f.mul(a(e)).mul(s);
+}, Pt = (t, e, c) => {
+  const o = t;
+  if (o.isDirectionalLight !== !0) return v(0, 0, 0);
+  const m = O(o.target).sub(O(o)).normalize(), l = Q.dot(m.negate()).max(0), d = I("color", "color", t);
+  return d.mul(a(e)).mul(l).mul(c);
+}, Dt = (t) => {
+  const e = Array.isArray(t) ? t : [{ light: t, intensity: 1 }], c = [];
+  for (const o of e) {
+    if (c.length >= Ft) break;
+    et(o) <= 0 && it(o) <= 0 || c.push(o);
+  }
+  return c;
+}, It = (t, e, c) => {
+  const o = Number.isFinite(e.nearRadius) ? Math.max(1, e.nearRadius) : e.midLight ? 20 : 100, m = Number.isFinite(e.midRadius) ? Math.max(o, e.midRadius) : 50, l = Number.isFinite(e.outerRadius) ? Math.max(m, e.outerRadius) : 160, d = (b, n, x) => p(b, n, F(a(x * 0.7), a(x * 0.95), c));
+  let i = L(t);
+  return e.midLight ? (i = d(i, L(e.midLight), o), e.outerLight ? (i = d(i, L(e.outerLight), m), e.farLight && (i = d(i, L(e.farLight), l))) : e.farLight && (i = d(i, L(e.farLight), m))) : e.farLight && (i = d(i, L(e.farLight), o)), i;
+};
+function qt(t, e = {}) {
+  const c = Number.isFinite(e.umbra) ? Math.min(1, Math.max(0, e.umbra)) : 0.45, o = Number.isFinite(e.receiveUpMin) ? Math.min(0.95, Math.max(0, e.receiveUpMin)) : 0.25, m = Number.isFinite(e.diffuse) ? Math.max(0, e.diffuse) : 0, l = new w.MeshStandardNodeMaterial();
+  l.side = w.DoubleSide, l.color = new w.Color(1, 1, 1), l.roughness = 1, l.metalness = 0, l.transparent = !1, l.depthWrite = !0, l.polygonOffset = !0, l.polygonOffsetFactor = 2, l.polygonOffsetUnits = 2;
+  const d = ot.distance(ft), i = Dt(t), b = o > 0 ? F(a(o), a(o + 0.3), Q.y) : a(1), n = (h, r) => {
+    const g = h === 0 ? It(r, e, d) : L(r);
+    return p(a(1), g, at(r));
+  }, x = i.map(
+    (h, r) => n(r, h.light)
+  );
+  let u, s = a(1);
+  if (e.combine === "min" && i.length > 0) {
+    let h = a(1);
+    for (let r = 0; r < i.length; r++) {
+      const g = i[r], y = et(g);
+      if (y <= 0) continue;
+      const M = Math.min(1, Math.max(0, 1 - y * (1 - c))), C = x[r], T = p(a(M), a(1), C);
+      h = ht(h, T);
+    }
+    s = h, u = p(a(1), h, b);
+  } else {
+    const h = i.map((r, g) => ({ index: g, intensity: et(r) })).filter(({ intensity: r }) => r > 0);
+    if (h.length === 1)
+      s = x[h[0].index];
+    else if (h.length > 1) {
+      let r = a(0), g = 0;
+      for (const { index: y, intensity: M } of h) {
+        g += M;
+        const C = x[y];
+        r = r.add(a(M).mul(C));
+      }
+      s = r.div(a(g));
+    }
+    if (h.length > 0) {
+      const r = p(a(1), s, b);
+      u = p(a(c), a(1), r);
+    } else
+      u = a(1);
+  }
+  let f = v(0, 0, 0);
+  if (m > 0) {
+    const h = R(e.color ?? new w.Color(1, 1, 1)), r = R(e.direction ?? new w.Vector3(0, 1, 0)), g = Q.dot(r.normalize()).max(0);
+    f = h.mul(g).mul(a(m)).mul(b).mul(s);
+  }
+  for (let h = 0; h < i.length; h++) {
+    const r = i[h], g = it(r);
+    if (g <= 0) continue;
+    const y = r.light, M = x[h], C = Nt(y, g, M), T = Pt(y, g, M);
+    f = f.add(C).add(T);
+  }
+  return l.outputNode = U(v(u).add(f), a(1)), l;
 }
-function ge(o) {
-  const n = new g.BufferGeometry();
-  return n.setAttribute("position", new g.BufferAttribute(o.positions.slice(), 3)), n.setIndex(new g.BufferAttribute(o.indices.slice(), 1)), n;
+function Ot(t) {
+  const e = new w.BufferGeometry();
+  return e.setAttribute("position", new w.BufferAttribute(t.positions.slice(), 3)), e.setIndex(new w.BufferAttribute(t.indices.slice(), 1)), e;
 }
-function Ee(o = {}) {
-  const n = o.albedo ?? 0.5, r = new g.Group(), t = o.matrixWorld ?? null, d = [], f = new g.MeshStandardMaterial({
-    color: new g.Color(n, n, n),
+function Ht(t = {}) {
+  const e = t.albedo ?? 0.5, c = new w.Group(), o = t.matrixWorld ?? null, m = [], l = new w.MeshStandardMaterial({
+    color: new w.Color(e, e, e),
     roughness: 1,
     metalness: 0,
-    side: g.DoubleSide
-  }), u = (e) => {
-    t && e.applyMatrix4(t);
-  }, l = (e, m) => {
-    let c = e, s = m;
-    t && !m && (c = e.clone(), s = !0), u(c), c.computeVertexNormals(), s && d.push(c);
-    const a = new g.Mesh(c, f);
-    a.castShadow = !0, a.receiveShadow = !0, a.raycast = () => {
-    }, r.add(a);
+    side: w.DoubleSide
+  }), d = (n) => {
+    o && n.applyMatrix4(o);
+  }, i = (n, x) => {
+    let u = n, s = x;
+    o && !x && (u = n.clone(), s = !0), d(u), u.computeVertexNormals(), s && m.push(u);
+    const f = new w.Mesh(u, l);
+    f.castShadow = !0, f.receiveShadow = !0, f.raycast = () => {
+    }, c.add(f);
   };
-  for (const e of o.tiles ?? [])
-    l(ge(e.data), !0);
-  for (const e of o.geometries ?? [])
-    l(e, !1);
+  for (const n of t.tiles ?? [])
+    i(Ot(n.data), !0);
+  for (const n of t.geometries ?? [])
+    i(n, !1);
   return {
-    group: r,
-    configureMaterial: (e) => {
-      e.side = g.DoubleSide, e.transparent = !1, e.opacity = 1, "color" in e && e.color instanceof g.Color && e.color.setRGB(n, n, n), "roughness" in e && typeof e.roughness == "number" && (e.roughness = 1), "metalness" in e && typeof e.metalness == "number" && (e.metalness = 0);
+    group: c,
+    configureMaterial: (n) => {
+      n.side = w.DoubleSide, n.transparent = !1, n.opacity = 1, "color" in n && n.color instanceof w.Color && n.color.setRGB(e, e, e), "roughness" in n && typeof n.roughness == "number" && (n.roughness = 1), "metalness" in n && typeof n.metalness == "number" && (n.metalness = 0);
     },
     dispose: () => {
-      f.dispose();
-      for (const e of d) e.dispose();
-      r.clear();
+      l.dispose();
+      for (const n of m) n.dispose();
+      c.clear();
     }
   };
 }
 export {
-  Ee as createRelightingProxy,
-  Ce as createRelightingShadowFactorMaterial,
-  ve as depthOfFieldPreset,
-  we as lightingPreset,
-  Me as revealPreset,
-  ye as sdfEffects,
-  ke as worldWarpPreset
+  Ft as MAX_RELIGHTING_SHADOW_LIGHTS,
+  Ht as createRelightingProxy,
+  qt as createRelightingShadowFactorMaterial,
+  Wt as depthOfFieldPreset,
+  Bt as lightingPreset,
+  Gt as renderRelightingFactorMap,
+  $t as revealPreset,
+  Vt as sdfEffects,
+  jt as worldWarpPreset
 };
 //# sourceMappingURL=effects.js.map