@voluma/vlam 0.2.1 → 0.2.3

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