reze-engine 0.24.1 → 0.25.0

package/dist/gpu-profile.js

@@ -0,0 +1,120 @@
+// WebGPU timestamp-query profiling. Records pass durations into the same
+// profiler module as CPU phases (so the snapshot table mixes both with a
+// "gpu." prefix). Read-only — no effect on rendering output.
+//
+// Pattern (per spec):
+//   1. Each render pass declares timestampWrites { begin, end } slot indices.
+//   2. After all passes, encoder.resolveQuerySet writes uint64 ns timestamps
+//      into a QUERY_RESOLVE buffer.
+//   3. We copy the resolve buffer into a MAP_READ readback buffer.
+//   4. Submit. After the GPU finishes, mapAsync resolves; we read durations
+//      and record them.
+//
+// One readback buffer with an in-flight gate: if mapAsync hasn't resolved
+// from a previous frame, we skip the copy this frame (no contention, just
+// one frame of dropped sampling).
+import { profiler } from "./physics/profile";
+const MAX_PASSES_PER_FRAME = 64;
+export class GpuTimestamp {
+    constructor(device) {
+        this.enabled = false;
+        this.querySet = null;
+        this.resolveBuffer = null;
+        this.readbackBuffer = null;
+        this.nextSlot = 0;
+        this.frameLabels = [];
+        this.inFlight = false;
+        // Set inside endFrame() when a copy was queued this frame; consumed by
+        // afterSubmit() to kick mapAsync. mapAsync must run AFTER queue.submit —
+        // calling it before submit puts the buffer into "mapping pending" state,
+        // which makes the copy in the encoder illegal.
+        this.pendingLabels = null;
+        this.device = device;
+        this.supported = device.features.has("timestamp-query");
+    }
+    ensureCreated() {
+        if (this.querySet || !this.supported)
+            return;
+        const slots = MAX_PASSES_PER_FRAME * 2;
+        this.querySet = this.device.createQuerySet({ type: "timestamp", count: slots });
+        this.resolveBuffer = this.device.createBuffer({
+            label: "gpu-timestamp-resolve",
+            size: slots * 8,
+            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
+        });
+        this.readbackBuffer = this.device.createBuffer({
+            label: "gpu-timestamp-readback",
+            size: slots * 8,
+            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+        });
+    }
+    // Called once at the top of each render() before any pass wrap.
+    beginFrame() {
+        if (!this.enabled || !this.supported)
+            return;
+        this.ensureCreated();
+        this.nextSlot = 0;
+        this.frameLabels = [];
+    }
+    // Wrap a render-pass descriptor with timestampWrites for `label`. If
+    // profiling is off / unsupported / out of slots, returns desc unchanged.
+    // The same label called multiple times (e.g. each bloom mip) is fine —
+    // the profiler accumulates by label.
+    wrap(desc, label) {
+        if (!this.enabled || !this.querySet)
+            return desc;
+        if (this.nextSlot + 2 > MAX_PASSES_PER_FRAME * 2)
+            return desc;
+        const begin = this.nextSlot;
+        const end = this.nextSlot + 1;
+        this.nextSlot += 2;
+        this.frameLabels.push(label);
+        return {
+            ...desc,
+            timestampWrites: {
+                querySet: this.querySet,
+                beginningOfPassWriteIndex: begin,
+                endOfPassWriteIndex: end,
+            },
+        };
+    }
+    // Call on the encoder after all passes, BEFORE encoder.finish(). Adds
+    // resolveQuerySet + copyBufferToBuffer commands. mapAsync is deferred to
+    // afterSubmit() — calling it before submit transitions the readback buffer
+    // into "mapping pending" state, which makes the queued copy illegal.
+    endFrame(encoder) {
+        if (!this.enabled || !this.querySet || this.frameLabels.length === 0)
+            return;
+        const count = this.frameLabels.length * 2;
+        encoder.resolveQuerySet(this.querySet, 0, count, this.resolveBuffer, 0);
+        if (this.inFlight)
+            return;
+        encoder.copyBufferToBuffer(this.resolveBuffer, 0, this.readbackBuffer, 0, count * 8);
+        this.pendingLabels = this.frameLabels.slice();
+    }
+    // Call AFTER device.queue.submit(). Kicks mapAsync if a copy was queued
+    // this frame; the .then() reads durations and unmaps.
+    afterSubmit() {
+        const labels = this.pendingLabels;
+        if (!labels)
+            return;
+        this.pendingLabels = null;
+        this.inFlight = true;
+        const readback = this.readbackBuffer;
+        void readback.mapAsync(GPUMapMode.READ).then(() => {
+            const arr = new BigInt64Array(readback.getMappedRange());
+            for (let i = 0; i < labels.length; i++) {
+                const start = arr[i * 2];
+                const end = arr[i * 2 + 1];
+                // Per spec, timestamps are nanoseconds.
+                const ms = Number(end - start) / 1e6;
+                if (ms >= 0 && ms < 1000)
+                    profiler.record("gpu." + labels[i], ms);
+            }
+            readback.unmap();
+            this.inFlight = false;
+        }, () => {
+            this.inFlight = false;
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Engine, DEFAULT_BLOOM_OPTIONS, DEFAULT_VIEW_TRANSFORM, type EngineStats, type EngineOptions, type BloomOptions, type ViewTransformOptions, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type GizmoDragEvent, type GizmoDragCallback, type GizmoDragKind, } from "./engine";
+export { Engine, DEFAULT_BLOOM_OPTIONS, DEFAULT_VIEW_TRANSFORM, type EngineStats, type EngineOptions, type BloomOptions, type ViewTransformOptions, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type GizmoDragEvent, type GizmoDragCallback, type GizmoDragKind, type BackgroundEffectParamValue, type BackgroundEffectResult, } from "./engine";
 export { parsePmxFolderInput, pmxFileAtRelativePath, type PmxFolderInputResult } from "./folder-upload";
 export { compileGraph, validateGraph, assignStyleSlots, type CompileOptions, type CompileResult, type StyleSlot, } from "./graph/compile";
 export type { ShaderGraph, GraphNode, GraphLink, ExposedParam, SocketValue, Diagnostic, } from "./graph/schema";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC7G,YAAY,EACV,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC7G,YAAY,EACV,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}

package/dist/physics/profile.d.ts

@@ -0,0 +1,18 @@
+declare class PhysicsProfiler {
+    enabled: boolean;
+    private sums;
+    private counts;
+    begin(): number;
+    end(label: string, t0: number): void;
+    record(label: string, ms: number): void;
+    snapshot(): Record<string, {
+        avgMs: number;
+        calls: number;
+        totalMs: number;
+    }>;
+    reset(): void;
+}
+export declare const profiler: PhysicsProfiler;
+export type ProfileSnapshot = ReturnType<PhysicsProfiler["snapshot"]>;
+export {};
+//# sourceMappingURL=profile.d.ts.map

package/dist/physics/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/physics/profile.ts"],"names":[],"mappings":"AAIA,cAAM,eAAe;IACnB,OAAO,UAAQ;IACf,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,MAAM,CAA8C;IAE5D,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IASpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAQvC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAU7E,KAAK,IAAI,IAAI;CAId;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAA;AAC7C,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA"}

package/dist/physics/profile.js

@@ -0,0 +1,44 @@
+// Per-phase wall-clock accumulator. Off by default — when `enabled` is false,
+// begin()/end() short-circuit so production has zero overhead. Toggle via
+// `RezePhysics.setProfileEnabled(true)` and read with `getProfile()`.
+class PhysicsProfiler {
+    constructor() {
+        this.enabled = false;
+        this.sums = Object.create(null);
+        this.counts = Object.create(null);
+    }
+    begin() {
+        return this.enabled ? performance.now() : 0;
+    }
+    end(label, t0) {
+        if (!this.enabled)
+            return;
+        const dt = performance.now() - t0;
+        this.sums[label] = (this.sums[label] ?? 0) + dt;
+        this.counts[label] = (this.counts[label] ?? 0) + 1;
+    }
+    // Direct accumulator for durations not measured via begin()/end() — used by
+    // GPU timestamp readback, which arrives async after the frame has ended.
+    record(label, ms) {
+        if (!this.enabled)
+            return;
+        this.sums[label] = (this.sums[label] ?? 0) + ms;
+        this.counts[label] = (this.counts[label] ?? 0) + 1;
+    }
+    // Snapshot since last reset(). avgMs is per call; totalMs is the cumulative
+    // window cost — divide by elapsed wall time to get a "% of frame budget".
+    snapshot() {
+        const out = {};
+        for (const k in this.sums) {
+            const total = this.sums[k];
+            const calls = this.counts[k];
+            out[k] = { avgMs: calls > 0 ? total / calls : 0, calls, totalMs: total };
+        }
+        return out;
+    }
+    reset() {
+        this.sums = Object.create(null);
+        this.counts = Object.create(null);
+    }
+}
+export const profiler = new PhysicsProfiler();

package/dist/shaders/passes/composite.d.ts

@@ -1,2 +1,24 @@
-export declare const COMPOSITE_SHADER_WGSL = "\n// Pipeline-override constant: the engine creates two composite pipelines, one\n// with APPLY_GAMMA=false (gamma=1 fast path) and one with APPLY_GAMMA=true.\n// The 'if (APPLY_GAMMA)' below is resolved at pipeline-compile time \u2014 the\n// dead branch is dropped by the shader compiler (no runtime branch, no pow\n// invocation on Safari's Metal backend in the common case).\noverride APPLY_GAMMA: bool = true;\n\n@group(0) @binding(0) var hdrTex: texture_2d<f32>;\n@group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)\n@group(0) @binding(2) var bloomSamp: sampler;\n@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 6>;\n// Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).\n// .g = accumulated canvas alpha (what hdr.a carried before the HDR format\n// became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then\n// re-premultiply the tonemapped color for output so the premultiplied canvas\n// alphaMode composites the WebGPU surface over the page background correctly.\n@group(0) @binding(4) var maskTex: texture_2d<f32>;\n// Filmic tone curve baked to a WIDTH\u00D71 r16float LUT (bakeFilmicLut on the CPU side).\n// Domain: log2(linear) mapped to [0,13]. Replaces the old array<f32,14> that was indexed\n// by a runtime u32 (a Metal-backend smell \u2014 dynamic local-array indexing lowers to a\n// per-invocation copy/switch) and interpolated piecewise-linearly (C0, so segment slope\n// discontinuities showed as Mach bands in smooth skin/shadow gradients). The LUT is a\n// monotone-cubic (Fritsch\u2013Carlson) fit through the same 14 anchors \u2014 same values, C1\n// continuity kills the banding \u2014 sampled with hardware linear filtering.\n@group(0) @binding(5) var filmicLut: texture_2d<f32>;\n// viewU[0] = (exposure, invGamma, _, _);  viewU[1] = (tint.rgb, intensity)\n// viewU[2] = (background.rgb, mode) \u2014 display-space sRGB, composited UNDER the\n//            scene post-tonemap. mode: 0 transparent (DOM shows), 1 solid color,\n//            2 = 360 equirect skybox sampled by view ray.\n// viewU[3] = (camera right, tanHalfFov\u00B7aspect); viewU[4] = (camera up, tanHalfFov);\n// viewU[5] = (camera forward, _) \u2014 refreshed per frame while the skybox is active.\n// invGamma = 1/gamma precomputed on CPU \u2014 avoids a per-pixel divide.\n@group(0) @binding(6) var bgEquirect: texture_2d<f32>;\n\n// Must match FILMIC_LUT_WIDTH in engine.ts (bakeFilmicLut).\nconst FILMIC_LUT_W: f32 = 256.0;\n\nfn filmic(x: f32) -> f32 {\n  // Reference checkpoints (Blender 3.6 Filmic MHC, sobotka/filmic-blender\n  // look_medium-high-contrast.spi1d): linear 0.18 \u2192 ~0.395, linear 1.0 \u2192 ~0.83.\n  // NOTE: version-pinned to Blender 3.6 \u2014 4.x defaults to AgX, not Filmic.\n  let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);\n  // Map t\u2208[0,13] to the texel-center of baked sample j = t\u00B7(W-1)/13.\n  let u = (t * (FILMIC_LUT_W - 1.0) / 13.0 + 0.5) / FILMIC_LUT_W;\n  // textureSampleLevel (explicit LOD, no derivatives) is legal in non-uniform flow.\n  return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;\n}\n\n@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let x = f32((vi & 1u) << 2u) - 1.0;\n  let y = f32((vi & 2u) << 1u) - 1.0;\n  return vec4f(x, y, 0.0, 1.0);\n}\n\n@fragment fn fs(@builtin(position) fragCoord: vec4f) -> @location(0) vec4f {\n  let coord = vec2<i32>(fragCoord.xy);\n  let hdr = textureLoad(hdrTex, coord, 0);\n  let alpha = textureLoad(maskTex, coord, 0).g;\n  let a = max(alpha, 1e-6);\n  let straight = hdr.rgb / a;\n  let fullSz = vec2f(textureDimensions(hdrTex));\n  // Bloom is at half-res (pyramid mip 0). Sampler interpolates back to full-res UVs.\n  // fragCoord.xy is already at pixel center (e.g. 0.5, 0.5 for first pixel).\n  let bloomUv = fragCoord.xy / max(fullSz, vec2f(1.0));\n  let tint = viewU[1].xyz;\n  let intensity = viewU[1].w;\n  let bloom = textureSampleLevel(bloomTex, bloomSamp, bloomUv, 0.0).rgb * tint * intensity;\n  let combined = straight + bloom;\n  let exposed = combined * exp2(viewU[0].x);\n  let tm = vec3f(filmic(exposed.r), filmic(exposed.g), filmic(exposed.b));\n  var disp = max(tm, vec3f(0.0));\n  if (APPLY_GAMMA) {\n    disp = pow(disp, vec3f(viewU[0].y));\n  }\n  // Composite over the background in display space (premultiplied out).\n  let bg = viewU[2];\n  var bgRgb = bg.rgb;\n  var bgA = select(0.0, 1.0, bg.w > 0.5);\n  if (bg.w > 1.5) {\n    // 360 equirect: rebuild this pixel's world-space view ray from the camera\n    // basis, then latitude/longitude-map into the panorama. The dome sits at\n    // infinity (no parallax) \u2014 PhotoDome-style, display-only.\n    let ndc = vec2f(fragCoord.x / fullSz.x * 2.0 - 1.0, 1.0 - fragCoord.y / fullSz.y * 2.0);\n    let dir = normalize(viewU[5].xyz + ndc.x * viewU[3].w * viewU[3].xyz + ndc.y * viewU[4].w * viewU[4].xyz);\n    // LH world (+Z forward): longitude = atan2(x, z), Babylon-PhotoDome convention.\n    let su = 0.5 + atan2(dir.x, dir.z) * 0.15915494309;  // 1/(2\u03C0)\n    let sv = 0.5 - asin(clamp(dir.y, -1.0, 1.0)) * 0.31830988618;  // 1/\u03C0\n    bgRgb = textureSampleLevel(bgEquirect, bloomSamp, vec2f(su, sv), 0.0).rgb;\n  }\n  return vec4f(disp * alpha + bgRgb * bgA * (1.0 - alpha), alpha + bgA * (1.0 - alpha));\n}\n";
+/** What a user background effect must define, documented once:
+ *
+ *    fn background(ray: vec3f, uv: vec2f, time: f32) -> vec4f
+ *
+ *  - `ray`  — normalized world-space view direction of this pixel (left-handed,
+ *             +Z forward; identical to what the 360 skybox samples by).
+ *  - `uv`   — 0..1 across the canvas, origin bottom-left (shadertoy-style).
+ *  - `time` — seconds since the effect was applied.
+ *  - `bgResolution()` — canvas size in pixels, for aspect correction.
+ *  - declared params arrive as `params.<name>` (f32 or vec3f).
+ *  Return display-space sRGB + alpha, 0..1. The effect is a LAYER: it is
+ *  over-composited onto the base background (solid color / 360 equirect /
+ *  transparent) and sits behind the scene — alpha 0 lets the base show
+ *  through, so e.g. a starfield returns stars with a transparent sky. */
+export type CompositeEffectSource = {
+    /** User WGSL defining `background(...)` (plus any helpers it wants). */
+    wgsl: string;
+    /** Codegen'd `struct BgParams {...}` + binding decl; empty when no params. */
+    paramsDecl: string;
+};
+export declare function buildCompositeShader(effect?: CompositeEffectSource | null): string;
+/** Kept for compatibility with existing imports (the base, no-effect shader). */
+export declare const COMPOSITE_SHADER_WGSL: string;
 //# sourceMappingURL=composite.d.ts.map

package/dist/shaders/passes/composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,yvKA4FjC,CAAA"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;yEAayE;AACzE,MAAM,MAAM,qBAAqB,GAAG;IAClC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AA8HD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAWlF;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}

package/dist/shaders/passes/composite.js

@@ -1,6 +1,12 @@
 // Composite: HDR scene + bloom pyramid → Filmic tone map → gamma → swapchain.
 // Bloom tint/intensity applied at combine (EEVEE treats them as combine-stage params, not prefilter).
-export const COMPOSITE_SHADER_WGSL = /* wgsl */ `
+//
+// The shader is a TEMPLATE: buildCompositeShader() emits either the base pass or
+// a variant with a user background effect injected (setBackgroundEffect). The
+// effect is background mode 3, a sibling of the 360 equirect (mode 2) — it reuses
+// the same per-pixel view-ray reconstruction and composites in display space
+// under the scene, so it never affects lighting, bloom, or tonemapping.
+const COMPOSITE_HEAD = /* wgsl */ `
 // Pipeline-override constant: the engine creates two composite pipelines, one
 // with APPLY_GAMMA=false (gamma=1 fast path) and one with APPLY_GAMMA=true.
 // The 'if (APPLY_GAMMA)' below is resolved at pipeline-compile time — the
@@ -11,7 +17,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 6>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 7>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -28,10 +34,12 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(5) var filmicLut: texture_2d<f32>;
 // viewU[0] = (exposure, invGamma, _, _);  viewU[1] = (tint.rgb, intensity)
 // viewU[2] = (background.rgb, mode) — display-space sRGB, composited UNDER the
-//            scene post-tonemap. mode: 0 transparent (DOM shows), 1 solid color,
-//            2 = 360 equirect skybox sampled by view ray.
+//            scene post-tonemap. BASE-layer mode: 0 transparent (DOM shows),
+//            1 solid color, 2 = 360 equirect skybox sampled by view ray. A user
+//            WGSL effect is a separate LAYER over the base (viewU[6].y flag).
 // viewU[3] = (camera right, tanHalfFov·aspect); viewU[4] = (camera up, tanHalfFov);
-// viewU[5] = (camera forward, _) — refreshed per frame while the skybox is active.
+// viewU[5] = (camera forward, _) — refreshed per frame while skybox/effect active.
+// viewU[6] = (time seconds, effect on/off, canvas width, canvas height).
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
 
@@ -49,6 +57,10 @@ fn filmic(x: f32) -> f32 {
   return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;
 }
 
+/** Canvas size in pixels — for user background effects (aspect correction). */
+fn bgResolution() -> vec2f { return viewU[6].zw; }
+`;
+const COMPOSITE_BODY = /* wgsl */ `
 @vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
   let x = f32((vi & 1u) << 2u) - 1.0;
   let y = f32((vi & 2u) << 1u) - 1.0;
@@ -75,21 +87,55 @@ fn filmic(x: f32) -> f32 {
   if (APPLY_GAMMA) {
     disp = pow(disp, vec3f(viewU[0].y));
   }
-  // Composite over the background in display space (premultiplied out).
+  // Composite over the background in display space (premultiplied out). The
+  // background is TWO layers: a base (transparent / solid color / 360 equirect)
+  // and an optional user WGSL effect over-composited onto it.
   let bg = viewU[2];
-  var bgRgb = bg.rgb;
   var bgA = select(0.0, 1.0, bg.w > 0.5);
-  if (bg.w > 1.5) {
-    // 360 equirect: rebuild this pixel's world-space view ray from the camera
-    // basis, then latitude/longitude-map into the panorama. The dome sits at
-    // infinity (no parallax) — PhotoDome-style, display-only.
+  var bgPm = bg.rgb * bgA;  // premultiplied accumulator
+  let fxOn = viewU[6].y > 0.5;
+  if (bg.w > 1.5 || fxOn) {
+    // The equirect and any effect both need this pixel's world-space view ray,
+    // rebuilt from the camera basis. The dome sits at infinity (no parallax) —
+    // PhotoDome-style, display-only.
     let ndc = vec2f(fragCoord.x / fullSz.x * 2.0 - 1.0, 1.0 - fragCoord.y / fullSz.y * 2.0);
     let dir = normalize(viewU[5].xyz + ndc.x * viewU[3].w * viewU[3].xyz + ndc.y * viewU[4].w * viewU[4].xyz);
-    // LH world (+Z forward): longitude = atan2(x, z), Babylon-PhotoDome convention.
-    let su = 0.5 + atan2(dir.x, dir.z) * 0.15915494309;  // 1/(2π)
-    let sv = 0.5 - asin(clamp(dir.y, -1.0, 1.0)) * 0.31830988618;  // 1/π
-    bgRgb = textureSampleLevel(bgEquirect, bloomSamp, vec2f(su, sv), 0.0).rgb;
+    if (bg.w > 1.5) {
+      // LH world (+Z forward): longitude = atan2(x, z), Babylon-PhotoDome convention.
+      let su = 0.5 + atan2(dir.x, dir.z) * 0.15915494309;  // 1/(2π)
+      let sv = 0.5 - asin(clamp(dir.y, -1.0, 1.0)) * 0.31830988618;  // 1/π
+      bgPm = textureSampleLevel(bgEquirect, bloomSamp, vec2f(su, sv), 0.0).rgb;
+    }
+    BG_EFFECT_CALL
   }
-  return vec4f(disp * alpha + bgRgb * bgA * (1.0 - alpha), alpha + bgA * (1.0 - alpha));
+  return vec4f(disp * alpha + bgPm * (1.0 - alpha), alpha + bgA * (1.0 - alpha));
 }
 `;
+// Base variant: no effect installed, the flag is never set — the ray block only
+// runs for the equirect, and there is nothing to add. (`dir` may go unused when
+// this compiles with mode<2 shaders; WGSL is fine with an unused let.)
+const NO_EFFECT_CALL = `_ = dir;`;
+// uv flipped to bottom-left origin (shadertoy convention); clamped so a stray
+// effect can't push negatives/NaN into the premultiplied composite. Standard
+// OVER onto the base layer.
+const EFFECT_CALL = /* wgsl */ `
+    if (fxOn) {
+      let bgUv = vec2f(fragCoord.x / fullSz.x, 1.0 - fragCoord.y / fullSz.y);
+      let fx = clamp(background(dir, bgUv, viewU[6].x), vec4f(0.0), vec4f(1.0));
+      bgPm = fx.rgb * fx.a + bgPm * (1.0 - fx.a);
+      bgA = fx.a + bgA * (1.0 - fx.a);
+    }
+`;
+export function buildCompositeShader(effect) {
+    if (!effect)
+        return COMPOSITE_HEAD + COMPOSITE_BODY.replace("BG_EFFECT_CALL", NO_EFFECT_CALL);
+    return (COMPOSITE_HEAD +
+        "\n// ── user background effect (setBackgroundEffect) ──\n" +
+        effect.paramsDecl +
+        "\n" +
+        effect.wgsl +
+        "\n" +
+        COMPOSITE_BODY.replace("BG_EFFECT_CALL", EFFECT_CALL.trim()));
+}
+/** Kept for compatibility with existing imports (the base, no-effect shader). */
+export const COMPOSITE_SHADER_WGSL = buildCompositeShader(null);

package/dist/shaders/passes/ground.d.ts

@@ -1,2 +1,2 @@
-export declare const GROUND_SHADOW_SHADER_WGSL = "\nstruct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };\nstruct Light { direction: vec4f, color: vec4f, };\nstruct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, };\nstruct GroundShadowMat {\n  diffuseColor: vec3f, fadeStart: f32,\n  fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,\n  gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,\n  gridLineColor: vec3f, _pad2: f32,\n};\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n@group(0) @binding(1) var<uniform> light: LightUniforms;\n@group(0) @binding(2) var shadowMap: texture_depth_2d;\n@group(0) @binding(3) var shadowSampler: sampler_comparison;\n@group(0) @binding(4) var<uniform> material: GroundShadowMat;\n@group(0) @binding(5) var<uniform> lightVP: LightVP;\n\nfn hash2(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn valueNoise(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash2(i), hash2(i + vec2f(1.0, 0.0)), u.x),\n             mix(hash2(i + vec2f(0.0, 1.0)), hash2(i + vec2f(1.0, 1.0)), u.x), u.y);\n}\nfn fbmNoise(p: vec2f) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var pp = p;\n  for (var i = 0; i < 4; i++) {\n    v += a * valueNoise(pp);\n    pp *= 2.0;\n    a *= 0.5;\n  }\n  return v;\n}\n\nstruct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {\n  var o: VO; o.worldPos = position; o.normal = normal;\n  o.position = camera.projection * camera.view * vec4f(position, 1.0); return o;\n}\nstruct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };\n@fragment fn fs(i: VO) -> FSOut {\n  let n = normalize(i.normal);\n  let centerDist = length(i.worldPos.xz);\n  let edgeFade = 1.0 - smoothstep(0.0, 1.0, clamp((centerDist - material.fadeStart) / max(material.fadeEnd - material.fadeStart, 0.001), 0.0, 1.0));\n\n  let lclip = lightVP.viewProj * vec4f(i.worldPos, 1.0);\n  let ndc = lclip.xyz / max(lclip.w, 1e-6);\n  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);\n  let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));\n  let st = material.pcfTexel;\n  let compareZ = ndc.z - 0.0035;\n  var vis = 0.0;\n  for (var y = -2; y <= 2; y++) {\n    for (var x = -2; x <= 2; x++) {\n      vis += textureSampleCompare(shadowMap, shadowSampler, suv_c + vec2f(f32(x), f32(y)) * st, compareZ);\n    }\n  }\n  vis *= 0.04;\n\n  // Frosted/matte micro-texture\n  let noiseVal = fbmNoise(i.worldPos.xz * 3.0);\n  let noiseTint = 1.0 + (noiseVal - 0.5) * material.noiseStrength;\n\n  // Grid lines \u2014 anti-aliased via screen-space derivatives\n  let gp = i.worldPos.xz / material.gridSpacing;\n  let gridFrac = abs(fract(gp - 0.5) - 0.5);\n  let gridDeriv = fwidth(gp);\n  let halfLine = material.gridLineWidth * 0.5;\n  let gridLine = 1.0 - min(\n    smoothstep(halfLine - gridDeriv.x, halfLine + gridDeriv.x, gridFrac.x),\n    smoothstep(halfLine - gridDeriv.y, halfLine + gridDeriv.y, gridFrac.y)\n  );\n  let sun = light.ambientColor.xyz + light.lights[0].color.xyz * light.lights[0].color.w * max(dot(n, -light.lights[0].direction.xyz), 0.0);\n  let dark = (1.0 - vis) * material.shadowStrength;\n  var baseColor = material.diffuseColor * sun * (1.0 - dark * 0.65);\n  baseColor *= noiseTint;\n  let finalColor = mix(baseColor, material.gridLineColor, gridLine * material.gridLineOpacity * edgeFade);\n  // Whole-ground opacity fades the SURFACE (color, grid) but the shadow stays \u2014\n  // as opacity drops, the received shadow becomes a translucent dark layer\n  // (Blender's Shadow Catcher), so models still feel grounded on a photo or\n  // 360 backdrop. At opacity 1 this reduces exactly to the plain surface.\n  let surfA = edgeFade * material.opacity;\n  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity);\n  let outA = surfA + catchA;\n  var out: FSOut;\n  out.color = vec4f(finalColor * surfA, outA);\n  // mask.r = 0: ground never contributes to bloom. mask.g = 1.0 with src.a =\n  // outA turns the aux blend into alpha-over, so the drawable alpha goes\n  // from outA at the center to 0 at the radial edge \u2014 letting the page\n  // background show through under the premultiplied canvas alphaMode.\n  out.mask = vec4f(0.0, 1.0, 0.0, outA);\n  return out;\n}\n";
+export declare const GROUND_SHADOW_SHADER_WGSL = "\nstruct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };\nstruct Light { direction: vec4f, color: vec4f, };\nstruct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, };\nstruct GroundShadowMat {\n  diffuseColor: vec3f, fadeStart: f32,\n  fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,\n  gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,\n  gridLineColor: vec3f, _pad2: f32,\n};\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n@group(0) @binding(1) var<uniform> light: LightUniforms;\n@group(0) @binding(2) var shadowMap: texture_depth_2d;\n@group(0) @binding(3) var shadowSampler: sampler_comparison;\n@group(0) @binding(4) var<uniform> material: GroundShadowMat;\n@group(0) @binding(5) var<uniform> lightVP: LightVP;\n\nfn hash2(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn valueNoise(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash2(i), hash2(i + vec2f(1.0, 0.0)), u.x),\n             mix(hash2(i + vec2f(0.0, 1.0)), hash2(i + vec2f(1.0, 1.0)), u.x), u.y);\n}\nfn fbmNoise(p: vec2f) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var pp = p;\n  for (var i = 0; i < 4; i++) {\n    v += a * valueNoise(pp);\n    pp *= 2.0;\n    a *= 0.5;\n  }\n  return v;\n}\n\nstruct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {\n  var o: VO; o.worldPos = position; o.normal = normal;\n  o.position = camera.projection * camera.view * vec4f(position, 1.0); return o;\n}\nstruct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };\n@fragment fn fs(i: VO) -> FSOut {\n  let n = normalize(i.normal);\n  let centerDist = length(i.worldPos.xz);\n  let edgeFade = 1.0 - smoothstep(0.0, 1.0, clamp((centerDist - material.fadeStart) / max(material.fadeEnd - material.fadeStart, 0.001), 0.0, 1.0));\n\n  let lclip = lightVP.viewProj * vec4f(i.worldPos, 1.0);\n  let ndc = lclip.xyz / max(lclip.w, 1e-6);\n  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);\n  let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));\n  let st = material.pcfTexel;\n  let compareZ = ndc.z - 0.0035;\n  var vis = 0.0;\n  for (var y = -2; y <= 2; y++) {\n    for (var x = -2; x <= 2; x++) {\n      vis += textureSampleCompare(shadowMap, shadowSampler, suv_c + vec2f(f32(x), f32(y)) * st, compareZ);\n    }\n  }\n  vis *= 0.04;\n  // Outside the light's frustum there IS no shadow information \u2014 the clamped\n  // border samples above compare against unrelated depths and read \"shadowed\",\n  // darkening the whole far plane with a visible band at the frustum edge\n  // (masked by the opaque surface normally, glaring in green-screen mode where\n  // only the shadow-catcher term renders). Fade to fully lit near the border.\n  let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);\n  let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;\n  vis = mix(1.0, vis, frustum);\n\n  // Frosted/matte micro-texture\n  let noiseVal = fbmNoise(i.worldPos.xz * 3.0);\n  let noiseTint = 1.0 + (noiseVal - 0.5) * material.noiseStrength;\n\n  // Grid lines \u2014 anti-aliased via screen-space derivatives\n  let gp = i.worldPos.xz / material.gridSpacing;\n  let gridFrac = abs(fract(gp - 0.5) - 0.5);\n  let gridDeriv = fwidth(gp);\n  let halfLine = material.gridLineWidth * 0.5;\n  let gridLine = 1.0 - min(\n    smoothstep(halfLine - gridDeriv.x, halfLine + gridDeriv.x, gridFrac.x),\n    smoothstep(halfLine - gridDeriv.y, halfLine + gridDeriv.y, gridFrac.y)\n  );\n  let sun = light.ambientColor.xyz + light.lights[0].color.xyz * light.lights[0].color.w * max(dot(n, -light.lights[0].direction.xyz), 0.0);\n  let dark = (1.0 - vis) * material.shadowStrength;\n  var baseColor = material.diffuseColor * sun * (1.0 - dark * 0.65);\n  baseColor *= noiseTint;\n  let finalColor = mix(baseColor, material.gridLineColor, gridLine * material.gridLineOpacity * edgeFade);\n  // Whole-ground opacity fades the SURFACE (color, grid) but the shadow stays \u2014\n  // as opacity drops, the received shadow becomes a translucent dark layer\n  // (Blender's Shadow Catcher), so models still feel grounded on a photo or\n  // 360 backdrop. At opacity 1 this reduces exactly to the plain surface.\n  let surfA = edgeFade * material.opacity;\n  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity);\n  let outA = surfA + catchA;\n  var out: FSOut;\n  out.color = vec4f(finalColor * surfA, outA);\n  // mask.r = 0: ground never contributes to bloom. mask.g = 1.0 with src.a =\n  // outA turns the aux blend into alpha-over, so the drawable alpha goes\n  // from outA at the center to 0 at the radial edge \u2014 letting the page\n  // background show through under the premultiplied canvas alphaMode.\n  out.mask = vec4f(0.0, 1.0, 0.0, outA);\n  return out;\n}\n";
 //# sourceMappingURL=ground.d.ts.map

package/dist/shaders/passes/ground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yBAAyB,2+IAqGrC,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yBAAyB,2kKA6GrC,CAAA"}

package/dist/shaders/passes/ground.js

@@ -66,6 +66,14 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
     }
   }
   vis *= 0.04;
+  // Outside the light's frustum there IS no shadow information — the clamped
+  // border samples above compare against unrelated depths and read "shadowed",
+  // darkening the whole far plane with a visible band at the frustum edge
+  // (masked by the opaque surface normally, glaring in green-screen mode where
+  // only the shadow-catcher term renders). Fade to fully lit near the border.
+  let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);
+  let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;
+  vis = mix(1.0, vis, frustum);
 
   // Frosted/matte micro-texture
   let noiseVal = fbmNoise(i.worldPos.xz * 3.0);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "reze-engine",
-    "version": "0.24.1",
+    "version": "0.25.0",
     "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",