@voluma/vlam 0.1.0 → 0.2.1

package/dist/dataset-source.d.ts

@@ -0,0 +1,55 @@
+import { type SplatRequestOptions, type StreamedSplatFormat } from './loading';
+/**
+ * Where a streamed dataset's files come from.
+ *
+ * A streamed scene is never one file: it is a manifest plus sidecars and chunk
+ * files that the manifest names *relatively* (`data.bin`, `data/3dgs/x.sog`,
+ * `0_0/meta.json`). Over HTTP those resolve against the manifest's URL; from a
+ * dropped folder there is no URL to resolve against, only `File` objects.
+ *
+ * This is the seam between the two. Everything downstream - including the
+ * worker's ranged chunk reads - keeps working on plain URLs, because a
+ * dropped file's `blob:` URL answers `Range` with a real 206 (verified on
+ * Chromium/WebKit/Gecko), so only *name resolution* has to differ.
+ */
+export interface SplatDatasetSource {
+    /** Fetchable URL of the manifest itself. */
+    readonly manifestUrl: string;
+    /** Fetchable URL for a dataset-relative path, or null when absent. */
+    resolve(path: string): string | null;
+    /** Byte length of a file, or null when absent. */
+    size(path: string): Promise<number | null>;
+    /**
+     * The files inside a chunk *directory* (unbundled SOG), as
+     * `name → fetchable URL`. Null when the chunk should be fetched by URL
+     * instead - the HTTP case, where the directory is a real path.
+     */
+    directoryFiles(path: string): Record<string, string> | null;
+    /** Releases any resources held for this dataset (e.g. blob URLs). */
+    dispose(): void;
+}
+/** A dataset served over HTTP, resolved against the manifest's URL. */
+export declare function httpDatasetSource(manifestUrl: string, request?: SplatRequestOptions): SplatDatasetSource;
+/** A dataset picked out of a dropped folder. */
+export interface LocalDataset {
+    readonly source: SplatDatasetSource;
+    /** The streamed format the folder's manifest identifies it as. */
+    readonly format: Exclude<StreamedSplatFormat, 'auto'>;
+    /** The manifest's file name, for display. */
+    readonly name: string;
+}
+/**
+ * Builds a dataset from a dropped folder's files, keyed by their paths
+ * relative to the folder root.
+ *
+ * Every file gets a `blob:` URL, so the rest of the pipeline - including the
+ * worker's ranged reads into a multi-hundred-megabyte `data.bin` - is
+ * identical to the HTTP path. Nothing is copied or read here: a blob URL is a
+ * handle to the file on disk, so a 300 MB `data.bin` costs nothing until a
+ * chunk actually reads a range out of it.
+ *
+ * @throws {SplatLoadError} with `phase: 'manifest'` when the folder holds no
+ * recognizable manifest, or more than one (which would make the choice
+ * arbitrary). Neither is retryable: the same folder fails the same way.
+ */
+export declare function createLocalDataset(files: ReadonlyMap<string, File>): LocalDataset;

package/dist/depth-of-field.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Core projected-2D depth of field (post-EWA isotropic CoC).
+ *
+ * Spark-style pinhole CoC:
+ *   focusBlur = |depth − focus| / depth
+ *   apertureRadius = focalPx · tan(0.5 · apertureAngle)
+ *   cocRadius = focusBlur · apertureRadius
+ *   blurVariance = clamp(cocRadius², …, maxRadius²)
+ *
+ * `/ depth` is Spark's exact falloff (`splatVertex.glsl`), restored for visual
+ * parity: scenes authored against Spark's foreground defocus rendered flat here
+ * under the previous `/ max(depth, focus)`, which capped focusBlur at 1 and so
+ * limited the CoC to a single apertureRadius - sub-pixel at the aperture sizes
+ * ModifyCamera produces. Behind the focus plane the two forms are identical
+ * (`max(depth, focus) === depth`), so only the near side changes.
+ *
+ * Note `/ depth` is unbounded as depth → 0. The fill-rate guard is the same one
+ * Spark uses: {@link MAX_DOF_RADIUS_PX} clamps the CoC. Do not "fix" the near
+ * side by dividing by focus instead - that pushes every *background* splat to
+ * the cap when zooming out with a near focus plane (huge quads → fill-rate
+ * death), which is what the bounded form was originally guarding against.
+ *
+ * Voluma's ModifyCamera `apertureSize` maps to an angle through the *live*
+ * focus distance - `apertureAngle = 2·atan(0.5·size / focus)` - matching the
+ * host helper Voluma ships for Spark. A fixed reference distance was tried
+ * instead to stop near focus planes from
+ * ballooning every splat, but it decouples aperture from focus and so flattens
+ * the intended effect: racking focus toward the camera is exactly how authors
+ * get the whole scene to go soft. Keep the mapping focus-relative; the CoC cap
+ * is what bounds fill-rate.
+ *
+ * Unlike the M13 `depthOfFieldPreset` modifier (3D scale), this path adds
+ * `coc²·I` to the projected 2D covariance with `√(det)` opacity fade.
+ */
+/**
+ * Soft CoC radius cap in pixels (Spark clamps with `maxPixelRadius`).
+ * Kept modest for interactive fill-rate; raise only if cinematic stills need it.
+ */
+export declare const MAX_DOF_RADIUS_PX = 24;
+/** Cap on CoC variance (px²) added to the projected 2D covariance diagonal. */
+export declare const MAX_DOF_VARIANCE: number;
+/** Live camera depth-of-field settings for {@link SplatMesh.setDepthOfField}. */
+export type DepthOfFieldSettings = {
+    /** View-space distance to the focal plane (world units). Must stay positive. */
+    focusDistance: number;
+    /** Aperture size in the same units as Voluma `DofSettings.apertureSize`. `0` = off. */
+    aperture: number;
+};
+/**
+ * Maps Voluma aperture size → full aperture angle (radians) through the focus
+ * distance, identical to the host helper Voluma ships for Spark:
+ * `2·atan(0.5·size / focus)`. Pulling focus toward the camera widens the angle,
+ * which is what makes a near focus plane soften the whole scene.
+ */
+export declare function apertureAngleFromSize(aperture: number, focusDistance: number): number;
+/**
+ * Circle-of-confusion variance in px² for a splat at view-space depth.
+ * Returns `0` when aperture is disabled. Mirrors Spark's vertex DoF branch.
+ */
+export declare function computeDofCocVariancePx2(options: {
+    depth: number;
+    focusDistance: number;
+    aperture: number;
+    focalPx: number;
+    maxVariance?: number;
+}): number;
+/**
+ * Opacity fade that conserves Gaussian mass after isotropic screen-space
+ * dilation: `√(detRaw / detBlur)`.
+ */
+export declare function computeDofOpacityFade(detRaw: number, detBlur: number): number;
+/** Clamps host-supplied DoF settings before writing live uniforms. */
+export declare function clampDepthOfFieldSettings(settings: Partial<DepthOfFieldSettings>, previous?: DepthOfFieldSettings): DepthOfFieldSettings;

package/dist/effects.d.ts

@@ -0,0 +1,337 @@
+/**
+ * `@voluma/vlam/effects` - optional, tree-shakeable effects built on the M7
+ * {@link SplatModifier} contract. Import only what you use; nothing here is
+ * pulled into the core renderer bundle.
+ *
+ *  - {@link sdfEffects}: a declarative sphere/box/cylinder shape list evaluated
+ *    in-shader from a bounded uniform array (a fixed unroll over `maxShapes`
+ *    slots, gated by the live count) - add/move/remove shapes is data-only
+ *    (no pipeline recompile), on WebGPU and the WebGL2 fallback alike (M7.4).
+ *    The kinds mirror the CPU selection volumes (`createSelectionVolume`), so
+ *    a host can highlight exactly what a selection would take.
+ *  - {@link lightingPreset} / {@link revealPreset}: small reference presets,
+ *    starting points rather than a framework (M7.5).
+ *  - {@link createRelightingProxy}: builds a gray lit mesh group from collision
+ *    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.
+ *  - {@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
+ *    {@link SplatMesh.setDepthOfField} / `UnifiedSplatRenderer.setDepthOfField`
+ *    path - this preset is the soft/approximate alternative built purely on
+ *    the modifier hook.
+ *
+ * Every preset here reads positions from `ctx.localCenter` - mesh-local space,
+ * which inside a `SplatScene` is the splat's **placed** position. So a shape or
+ * a reveal spans every source as one scene instead of travelling with a moved
+ * one; see `docs/guide/effects-and-modifiers.md` for what that looks like, and
+ * `ctx.sourceCenter` for the opposite behaviour.
+ *
+ * See `docs/guide/effects-and-modifiers.md`.
+ */
+import * as THREE from 'three/webgpu';
+import type { SplatModifier } from './splat-modifier';
+import type { CollisionMeshTile } from './formats/lcc/collision-mesh';
+/**
+ * A signed-distance primitive kind. `cylinder` is capped and runs along the
+ * shape-local Y axis (rotate it with {@link SdfShape.rotation}).
+ */
+export type SdfShapeKind = 'sphere' | 'box' | 'cylinder';
+/**
+ * What a shape does to the splats it covers:
+ *  - `tint` - blend the splat color toward the shape color.
+ *  - `desaturate` - blend the splat color toward its luminance.
+ *  - `hide` - fade the splat out (soft cutaway).
+ *  - `rim` - tint only a band around the shape's surface.
+ */
+export type SdfMode = 'tint' | 'desaturate' | 'hide' | 'rim';
+/** One SDF shape in a {@link sdfEffects} list. All spaces are mesh-local. */
+export interface SdfShape {
+    kind: SdfShapeKind;
+    /** Shape center, mesh-local. Default `[0, 0, 0]`. */
+    center?: readonly [number, number, number];
+    /**
+     * Sphere/cylinder radius. Required for `kind: 'sphere'` and
+     * `kind: 'cylinder'`; must be positive - {@link SdfEffect.setShapes} throws
+     * otherwise.
+     */
+    radius?: number;
+    /**
+     * Cylinder full height along the shape-local Y axis. Required (and only
+     * used) for `kind: 'cylinder'`; must be positive - {@link SdfEffect.setShapes}
+     * throws otherwise.
+     */
+    height?: number;
+    /**
+     * Box half-extents. Required (and only used) for `kind: 'box'`; every
+     * component must be positive - {@link SdfEffect.setShapes} throws otherwise.
+     */
+    halfExtents?: readonly [number, number, number];
+    /** Orientation quaternion `[x, y, z, w]` (boxes and cylinders). Default identity. */
+    rotation?: readonly [number, number, number, number];
+    /** Effect color (tint/rim). Default white. */
+    color?: readonly [number, number, number];
+    /** Soft-edge width in world units; 0 is a hard edge. Default `0`. */
+    falloff?: number;
+    /** Invert the test - affect the outside of the shape instead. */
+    invert?: boolean;
+    /** Effect strength in `[0, 1]`. Default `1`. */
+    strength?: number;
+    mode: SdfMode;
+}
+/** A live SDF effect: one modifier plus a data-only way to update its shapes. */
+export interface SdfEffect {
+    /** Attach to `mesh.modifiers`. Built once; updating shapes never recompiles. */
+    readonly modifier: SplatModifier;
+    /**
+     * Replaces the shape list. Purely a uniform-buffer write, so animating
+     * shape poses/colors/thresholds every frame costs no pipeline recompile.
+     * Shapes beyond {@link maxShapes} are dropped with a one-time warning.
+     *
+     * Throws (before writing anything) if a sphere or cylinder lacks a positive
+     * `radius`, a cylinder lacks a positive `height`, or a box lacks positive
+     * `halfExtents` - a zero-size shape is always a caller bug, never a useful
+     * no-op.
+     */
+    setShapes(shapes: readonly SdfShape[]): void;
+    /** The compiled-in shape capacity (see {@link sdfEffects} `maxShapes`). */
+    readonly maxShapes: number;
+}
+/**
+ * Builds a {@link SdfEffect} from a declarative shape list. Shapes live in a
+ * bounded uniform array and are tested in-shader against each splat's local
+ * center as a **fixed unroll over all `maxShapes` slots**, each slot gated by
+ * `slot < count` so unused slots contribute nothing. (An in-shader loop is
+ * not viable here - see the TSL varying constraint documented inside the
+ * modifier.) Adding, moving or removing a shape - or changing the count - is
+ * still a pure uniform write with no recompile. Works on WebGPU and the
+ * WebGL2 fallback.
+ *
+ * `maxShapes` is the compiled capacity (default 32). Because every slot is
+ * unrolled into the shader, raising it grows the shader's size and compile
+ * time (and the uniform array; very large values can exceed WebGL2's uniform
+ * limits), so keep it to what a scene needs.
+ *
+ * Shape positions are mesh-local. In a `SplatScene` that means scene
+ * coordinates - a shape overlapping two sources covers both as one continuous
+ * shape - so place them with `computeSplatBounds()`, which reports the sources
+ * at their current placement.
+ */
+export declare function sdfEffects(initialShapes?: readonly SdfShape[], options?: {
+    maxShapes?: number;
+}): SdfEffect;
+/** A preset that exposes a live light direction uniform. */
+export interface LightingPreset {
+    readonly modifier: SplatModifier;
+    /**
+     * Mesh-local light direction; mutate `.value` to animate (no recompile).
+     * Inside a `SplatScene` that frame is the scene's, so one direction lights
+     * every source consistently however they are posed.
+     */
+    readonly direction: {
+        value: THREE.Vector3;
+    };
+}
+/**
+ * Simple per-splat Lambertian shading using the splat's approximate normal
+ * (`ctx.normal`, the least-variance covariance axis). A starting point for
+ * relit product shots - not a lighting rig. Works on both backends.
+ *
+ * In a `SplatScene` the normal comes from the *placed* covariance, so a source
+ * that rotates relights as it turns.
+ */
+export declare function lightingPreset(options?: {
+    direction?: readonly [number, number, number];
+    ambient?: number;
+    diffuse?: number;
+}): LightingPreset;
+/** A live depth-of-field preset: focus plane and aperture are mutable uniforms. */
+export interface DepthOfFieldPreset {
+    readonly modifier: SplatModifier;
+    /** World-unit distance to the focal plane; splats there stay sharp. Mutate
+     * `.value` to rack focus (no recompile). Must stay positive. */
+    readonly focusDistance: {
+        value: number;
+    };
+    /** Blur strength (aperture-like); 0 is no blur. Mutate `.value`. */
+    readonly aperture: {
+        value: number;
+    };
+}
+/**
+ * Depth-of-field on the {@link SplatModifier} hook - **stylized / soft** path
+ * (M13). Prefer {@link SplatMesh.setDepthOfField} / the core projected-2D
+ * aperture model for camera DoF (isotropic screen-space CoC with √det opacity).
+ *
+ * A splat's circle of confusion grows with how far its view-space depth
+ * sits from `focusDistance`; the modifier blurs it by enlarging it
+ * (`scale = 1 + coc`) and, because the material scales the projected covariance
+ * by `scale²`, divides opacity by `scale²` so the widened splat conserves its
+ * integrated mass instead of over-brightening. Focus and aperture are live
+ * uniforms, so racking focus every frame costs no recompile. Pure TSL - works
+ * on WebGPU and the WebGL2 fallback.
+ *
+ * This is an *approximate* DoF: `scale` is a uniform 3D-covariance multiplier,
+ * so the blur enlarges the splat's own (possibly anisotropic) footprint rather
+ * than adding a truly isotropic screen-space disc. The physically exact aperture
+ * model adds `coc²·I` to the *projected 2D* covariance with the same √(det)
+ * opacity conservation the antialias filter uses - that path is
+ * `SplatMesh.setDepthOfField` / `UnifiedSplatRenderer.setDepthOfField`
+ * (see `docs/guide/effects-and-modifiers.md`, M13).
+ *
+ * Opacity conservation is exact only with `antialias` on: without it, the
+ * fixed 0.3-px dilation dominates sub-pixel splats, so strong blur *dims*
+ * distant splats (their footprint barely grows while alpha still falls by
+ * 1/scale²) rather than blurring them.
+ */
+export declare function depthOfFieldPreset(options?: {
+    focusDistance?: number;
+    aperture?: number;
+    maxBlur?: number;
+}): DepthOfFieldPreset;
+/** A preset that exposes a reveal `progress` uniform in `[0, 1]`. */
+export interface RevealPreset {
+    readonly modifier: SplatModifier;
+    /** Reveal progress; 0 hides everything, 1 shows everything. */
+    readonly progress: {
+        value: number;
+    };
+}
+/**
+ * Time-driven dissolve/reveal. A value-noise field over the splat's local
+ * position is thresholded against `progress`: splats whose noise is below the
+ * threshold are shown, with a soft alpha edge. The noise is a `wgslFn` chunk -
+ * the M7 escape hatch - so this preset is **WebGPU-only** (see the fallback
+ * notes); force WebGL2 and it will not compile.
+ *
+ * The field is anchored to the mesh, so in a `SplatScene` a moved source
+ * reveals in step with whatever it now sits beside (and the pattern slides
+ * across it as it travels) rather than carrying its own schedule around.
+ */
+export declare function revealPreset(options?: {
+    frequency?: number;
+    edge?: number;
+}): RevealPreset;
+/** A live world-warp preset: signed intensity and radius are mutable uniforms. */
+export interface WorldWarpPreset {
+    readonly modifier: SplatModifier;
+    /**
+     * Signed warp amount in `[-1, 1]`. Positive wraps the street *down* so you
+     * walk on top of the sphere (tiny planet); negative wraps it *up* so you
+     * stand in the bowl (Inception fold). `0` is identity. Mutate `.value` to
+     * animate (no recompile).
+     */
+    readonly intensity: {
+        value: number;
+    };
+    /**
+     * Distance at which the wrap becomes strong. Nearby splats (`depth ≪
+     * radius`) stay put so walk/fly controls still read as moving through the
+     * unwarped near field. Must stay positive. Mutate `.value`.
+     */
+    readonly radius: {
+        value: number;
+    };
+}
+/**
+ * Camera-centered splat warp on the {@link SplatModifier} hook: one signed
+ * `intensity` uniform, two opposite hinges of the same view-space wrap. The
+ * camera is not moved - only splat centers (and their rigid orientation)
+ * change, so WASD / orbit stay as they are.
+ *
+ * Both sides hinge view-space `(y, z)` around camera +X by
+ * `(π/2) · atan(depth / radius)`:
+ *
+ *  - `intensity > 0` - planet: the far street wraps *down* under your feet so
+ *    you walk on top of the sphere.
+ *  - `intensity < 0` - fold: the far street wraps *up* over your head so you
+ *    stand in the bowl.
+ *  - `intensity = 0` is identity (`offset = 0`, rotation unchanged).
+ *
+ * The shader mixes each full-strength hinge toward the original position by
+ * `|intensity|`. Orientation follows the orthonormalized Jacobian so
+ * ellipsoids wrap with the surface rather than sliding. Pure TSL - WebGPU
+ * and the WebGL2 fallback.
+ *
+ * Displaced splats keep their **pre-displacement** depth-sort order (the
+ * modifier-stack contract). Extreme warps can composite in the wrong order;
+ * this preset does not re-sort on warped centers.
+ */
+export declare function worldWarpPreset(options?: {
+    intensity?: number;
+    radius?: number;
+}): WorldWarpPreset;
+/** Handle returned by {@link createRelightingProxy}. */
+export interface RelightingProxy {
+    /** World-space group of lit proxy meshes (hide from the main splat scene). */
+    readonly group: THREE.Group;
+    /**
+     * Configures a material for the relight coverage pass: gray albedo and
+     * opaque alpha so uncovered RT pixels stay at clear-alpha 0.
+     */
+    configureMaterial(material: THREE.Material): void;
+    /** Disposes geometries and the default material owned by this helper. */
+    dispose(): void;
+}
+/**
+ * Node material for a **shadow-factor** lighting RT used with
+ * {@link SplatMesh.setRelighting}.
+ *
+ * Fragment output is `vec4(vec3(mix(umbra, 1, shadow(light))), 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
+ *
+ * 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
+ * of every collision triangle.
+ *
+ * Prefer this over a lit MeshStandard / ShadowMaterial pass when the host wants
+ * cast umbras without a static dark stamp on the whole collision footprint.
+ * 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 options.umbra - Multiplier in full shadow, in `[0, 1]`. Default `0.45`.
+ */
+export declare function createRelightingShadowFactorMaterial(light: THREE.Light, options?: {
+    umbra?: number;
+}): THREE.MeshStandardNodeMaterial;
+/**
+ * Builds a PlayCanvas-style relighting **proxy** from collision tiles or raw
+ * geometries. The host places {@link RelightingProxy.group} on a dedicated
+ * layer / scene with lights (never the main splat scene), renders that into
+ * an RGBA RT matching the main camera, then calls
+ * {@link SplatMesh.setRelighting} with the RT texture.
+ *
+ * Collision meshes are a convenient stand-in when their silhouette is good
+ * enough; a denser reconstructed mesh is often better. This helper does not
+ * own lights or the render target.
+ *
+ * When `matrixWorld` is set (e.g. streamed mesh world matrix with the LCC
+ * Z-up→Y-up correction), it is **baked into the geometry** the same way the
+ * demo collision BVH path does - so the proxy aligns with splats without
+ * depending on a live Object3D transform.
+ *
+ * Coarse collision proxies leave hard coverage silhouettes; hosts should pass
+ * `RelightingSettings.softness` (and often a half-res lighting RT) so those
+ * edges do not look like a static shadow.
+ *
+ * For cast umbras **without** a static dark footprint, render the proxy with
+ * {@link createRelightingShadowFactorMaterial} so RT RGB is a multiplier
+ * (unshadowed ≈ 1), not a lit-gray appearance.
+ */
+export declare function createRelightingProxy(options?: {
+    /** LCC collision tiles (source-local). Prefer with `matrixWorld`. */
+    tiles?: readonly CollisionMeshTile[];
+    /** Extra or alternative geometries already in the desired frame. */
+    geometries?: readonly THREE.BufferGeometry[];
+    /**
+     * Source-local → world (e.g. streamed mesh `matrixWorld`). Baked into
+     * tile / cloned geometries; leave unset when geometries are already world.
+     */
+    matrixWorld?: THREE.Matrix4;
+    /** Gray albedo in `[0, 1]`. Default `0.5` (PlayCanvas brightness 2). */
+    albedo?: number;
+}): RelightingProxy;

package/dist/effects.js

@@ -0,0 +1,180 @@
+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.`
+    ));
+    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))
+          throw new Error(
+            `sdfEffects.setShapes: shape ${c} is a box and requires halfExtents with three positive components (got ${a ? `[${a.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)}).`
+          );
+      } else throw new Error(
+        `sdfEffects.setShapes: shape ${c} 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(
+        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);
+    }
+    f.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 { color: O(c, e.color.a.mul(s)) };
+  }, setShapes: l, maxShapes: r, _uniforms: { slots: t, count: f } };
+}
+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 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 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 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 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 Me(o = {}) {
+  const n = C(0), r = o.frequency ?? 3, t = Math.min(Math.max(o.edge ?? 0.08, 0), 0.5), d = se(
+    /* wgsl */
+    `
+    fn vnoise( x: vec3<f32> ) -> f32 {
+      let i = floor( x );
+      let g = fract( x );
+      let u = g * g * ( 3.0 - 2.0 * g );
+      let k = vec3<f32>( 12.9898, 78.233, 37.719 );
+      let s = 43758.5453;
+      let h000 = fract( sin( dot( i + vec3<f32>( 0.0, 0.0, 0.0 ), k ) ) * s );
+      let h100 = fract( sin( dot( i + vec3<f32>( 1.0, 0.0, 0.0 ), k ) ) * s );
+      let h010 = fract( sin( dot( i + vec3<f32>( 0.0, 1.0, 0.0 ), k ) ) * s );
+      let h110 = fract( sin( dot( i + vec3<f32>( 1.0, 1.0, 0.0 ), k ) ) * s );
+      let h001 = fract( sin( dot( i + vec3<f32>( 0.0, 0.0, 1.0 ), k ) ) * s );
+      let h101 = fract( sin( dot( i + vec3<f32>( 1.0, 0.0, 1.0 ), k ) ) * s );
+      let h011 = fract( sin( dot( i + vec3<f32>( 0.0, 1.0, 1.0 ), k ) ) * s );
+      let h111 = fract( sin( dot( i + vec3<f32>( 1.0, 1.0, 1.0 ), k ) ) * s );
+      let x00 = mix( h000, h100, u.x );
+      let x10 = mix( h010, h110, u.x );
+      let x01 = mix( h001, h101, u.x );
+      let x11 = mix( h011, h111, u.x );
+      let y0 = mix( x00, x10, u.y );
+      let y1 = mix( x01, x11, u.y );
+      return mix( y0, y1, u.z );
+    }
+  `
+  );
+  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(
+      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);
+    return {
+      offset: d.offset.add(j.mul(E.sub(l))),
+      rotation: H.mul(d.rotation)
+    };
+  }, intensity: n, 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;
+}
+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 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),
+    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);
+  };
+  for (const e of o.tiles ?? [])
+    l(ge(e.data), !0);
+  for (const e of o.geometries ?? [])
+    l(e, !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);
+    },
+    dispose: () => {
+      f.dispose();
+      for (const e of d) e.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
+};
+//# sourceMappingURL=effects.js.map