reze-engine 0.60.4 → 0.61.0

package/dist/engine.js

@@ -731,7 +731,13 @@ export class Engine {
         this.cameraMatrixData = new Float32Array(40);
         // ambient vec4 (4) + 4 lights x 2 vec4 (32) + 9 irradiance-SH vec4s (36),
         // padded to 80. sh[0].w is the IBL flag: 0 = flat world colour, 1 = the sky.
-        this.lightData = new Float32Array(80);
+        // …then the scene fog at [72..87] — see setSceneFog — and the cast's
+        // shadow on a stage at [88..107] (colour, amount; its view-projection).
+        this.lightData = new Float32Array(112);
+        this.castShadow = null;
+        this.castShadowBundle = null;
+        this.castShadowCleared = false;
+        this.castSphereScratch = new Float32Array(4);
         this.lightCount = 0;
         this.resizeObserver = null;
         this.resizePending = false;
@@ -1029,6 +1035,7 @@ export class Engine {
         this.cullReadbackInFlight = false;
         this.depthOfField = { ...DEFAULT_DEPTH_OF_FIELD_OPTIONS };
         this.dofUniformData = new Float32Array(12);
+        this.sceneFog = null;
         this.dofFocusScratch = new Vec3(0, 0, 0);
         /** Depth-only view of the scene's MSAA depth buffer, read by the DoF gather. */
         this.depthReadView = null;
@@ -1061,6 +1068,9 @@ export class Engine {
         this.worldGradientSH = null;
         /** The installed HDRI's folded irradiance SH (27 floats), or null. */
         this.worldSH = null;
+        /** A diffuse ambient stated outright (setWorldAmbient), outranking the one
+         *  fitted to the picture; the picture still answers reflections. */
+        this.worldAmbientSH = null;
         // The scene's user WGSL effect (setEffect). ONE per scene, mounted under the
         // scene, over it, or both — whichever of background()/foreground() the code
         // defines. The composite pipelines are REBUILT with the user code injected;
@@ -1121,6 +1131,10 @@ export class Engine {
          *  character samples in lockstep and their paths stay comparable. */
         this.trailDue = 0;
         this.agxLutTexture = null;
+        /** The scene's own grade (setStageGrade): the cube as handed over, kept so a
+         *  call before init() still lands, and its texture once uploaded. */
+        this.stageGradeCube = null;
+        this.stageGradeTexture = null;
         /** time=0 origin for the active effect — reset each setEffect. */
         /** Scene-clock reading when the current effect was installed. The effect's
          *  `time` is measured from here — see where it is written. */
@@ -1650,6 +1664,57 @@ export class Engine {
         if (this.device && this.compositeUniformBuffer)
             this.writeCompositeViewUniforms();
     }
+    /**
+     * The grade a scene arrived with, as a cube — a game's own colour grading,
+     * baked by the converter that brought its stage. Applied to the formed frame
+     * before setColorGrading's, which stays the author's to lay on top. Looked up
+     * as the game looks it up: the view transform's output, linear, trilinear
+     * between texel centres. Null takes it off.
+     *
+     * Bytes are the cube as that game stored it: 8-bit sRGB-encoded, red fastest,
+     * then green, then blue; three bytes a texel or four. A cube whose byte count
+     * does not match its size is refused rather than drawn wrong.
+     */
+    setStageGrade(lut) {
+        if (lut) {
+            const stride = lut.data.byteLength / lut.size ** 3;
+            if (!Number.isInteger(lut.size) || lut.size < 2 || lut.size > 64 || (stride !== 3 && stride !== 4)) {
+                throw new Error(`setStageGrade: ${lut.data.byteLength} bytes is not a ${lut.size}³ cube`);
+            }
+        }
+        this.stageGradeCube = lut;
+        if (this.device && this.stageGradeFallback)
+            this.uploadStageGrade();
+    }
+    uploadStageGrade() {
+        const lut = this.stageGradeCube;
+        this.stageGradeTexture?.destroy();
+        this.stageGradeTexture = null;
+        if (lut) {
+            const n = lut.size;
+            const texels = n ** 3;
+            const stride = lut.data.byteLength / texels;
+            const rgba = new Uint8Array(texels * 4);
+            for (let i = 0; i < texels; i++) {
+                rgba[i * 4] = lut.data[i * stride];
+                rgba[i * 4 + 1] = lut.data[i * stride + 1];
+                rgba[i * 4 + 2] = lut.data[i * stride + 2];
+                rgba[i * 4 + 3] = 255;
+            }
+            const tex = this.device.createTexture({
+                label: `stage grade ${n}³`,
+                size: [n, n, n],
+                dimension: "3d",
+                format: "rgba8unorm-srgb",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            this.device.queue.writeTexture({ texture: tex }, rgba, { bytesPerRow: n * 4, rowsPerImage: n }, [n, n, n]);
+            this.stageGradeTexture = tex;
+        }
+        this.rebuildCompositeBindGroup();
+        if (this.compositeUniformBuffer)
+            this.writeCompositeViewUniforms();
+    }
     /** Current grade (for serialization into a scene descriptor). */
     getColorGrading() {
         const g = this.colorGrading;
@@ -1786,7 +1851,8 @@ export class Engine {
             u[32] === 1 && u[33] === 1 && u[34] === 1 &&
             u[36] === 1 && u[37] === 1 && u[38] === 1 &&
             g.contrast === 1 && g.saturation === 1;
-        u[39] = neutral ? 0 : 1;
+        // Bit 0 the CDL above, bit 1 the scene's own cube — see _rzGradeScene.
+        u[39] = (neutral ? 0 : 1) | (this.stageGradeTexture ? 2 : 0);
         this.device.queue.writeBuffer(this.compositeUniformBuffer, 0, u);
     }
     /**
@@ -1898,8 +1964,9 @@ export class Engine {
      */
     getWorldLighting() {
         const s = this.world.strength;
-        if (this.worldSH) {
-            const at = (n) => evalIrradianceSH(this.worldSH, n).map((v) => Math.max(v * s, 0));
+        const fitted = this.worldAmbientSH ?? this.worldSH;
+        if (fitted) {
+            const at = (n) => evalIrradianceSH(fitted, n).map((v) => Math.max(v * s, 0));
             return { source: "hdri", strength: s, up: at({ x: 0, y: 1, z: 0 }), down: at({ x: 0, y: -1, z: 0 }) };
         }
         const c = this.world.color;
@@ -2561,6 +2628,7 @@ export class Engine {
                 { binding: 8, resource: this.depthReadView },
                 { binding: 9, resource: { buffer: this.dofUniformBuffer } },
                 { binding: 10, resource: (this.agxLutTexture ?? this.agxFallbackTexture).createView({ dimension: "3d" }) },
+                { binding: 12, resource: (this.stageGradeTexture ?? this.stageGradeFallback).createView({ dimension: "3d" }) },
                 { binding: 11, resource: { buffer: this.castBuffer } },
                 { binding: 13, resource: { buffer: this.audioBuffer } },
                 { binding: 19, resource: { buffer: this.midiBuffer } },
@@ -2985,6 +3053,7 @@ export class Engine {
                 { binding: 2, resource: this.bloomSampler },
                 { binding: 5, resource: this.filmicLutView },
                 { binding: 10, resource: (this.agxLutTexture ?? this.agxFallbackTexture).createView({ dimension: "3d" }) },
+                { binding: 12, resource: (this.stageGradeTexture ?? this.stageGradeFallback).createView({ dimension: "3d" }) },
                 { binding: 1, resource: bloom },
                 { binding: 4, resource: this.maskResolveView },
             ],
@@ -5849,6 +5918,7 @@ export class Engine {
                 { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
                 { binding: 5, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
                 { binding: 10, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "3d" } },
+                { binding: 12, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "3d" } },
                 // And the scene's COVERAGE and bloom, without which the tap cannot
                 // reconstruct a pixel: the HDR target is premultiplied, so colour alone
                 // reads a half-transparent ground as a dark opaque one.
@@ -5999,7 +6069,8 @@ export class Engine {
             label: "main per-frame bind group layout",
             entries: [
                 { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
-                { binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+                // The vertex stage reads it too: the scene fog is per vertex (setSceneFog).
+                { binding: 1, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
                 { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
                 { binding: 3, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
                 { binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } },
@@ -6013,6 +6084,8 @@ export class Engine {
                 { binding: 7, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
                 { binding: 8, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
                 { binding: 9, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+                // The cast's shadow on a stage — setStageCastShadow.
+                { binding: 10, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
             ],
         });
         // group 1: per-instance (skinMats) — bound once per model
@@ -6226,6 +6299,22 @@ export class Engine {
             usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
         }));
         this.shadowMapDepthViews = this.shadowMapTextures.map((t) => t.createView());
+        // The cast's shadow on a stage (setStageCastShadow): one map, only the cast
+        // in it, from the stage's own direction. Always allocated so every material
+        // bind group and every instance's shadow bind group stays one shape; drawn
+        // only while a stage asks for it.
+        this.castShadowTexture = this.device.createTexture({
+            label: "stage cast shadow map",
+            size: [1024, 1024],
+            format: Engine.SHADOW_DEPTH_FORMAT,
+            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+        });
+        this.castShadowView = this.castShadowTexture.createView();
+        this.castShadowVPBuffer = this.device.createBuffer({
+            label: "stage cast shadow view-projection",
+            size: 64,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
         // One-shot bake of Blender EEVEE's combined BRDF LUT (DFG + LTC packed rgba8unorm).
         this.bakeBrdfLut();
         this.bakeGroundNoise();
@@ -6237,6 +6326,14 @@ export class Engine {
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
         });
         void this.loadAgxLut();
+        this.stageGradeFallback = this.device.createTexture({
+            label: "stage grade fallback",
+            size: [1, 1, 1],
+            dimension: "3d",
+            format: "rgba8unorm-srgb",
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+        });
+        this.uploadStageGrade();
         this.bakeFilmicLut();
         // BEFORE the bind group below, which binds it. Full size from the start:
         // every material pipeline binds this, so sizing it to the light count would
@@ -6649,6 +6746,9 @@ export class Engine {
                 // AgX's 57³ cube. Decompressed and uploaded off the critical path, so a
                 // 1×1×1 stand-in keeps the bind group valid until it arrives.
                 { binding: 10, visibility: GPUShaderStage.FRAGMENT, texture: { viewDimension: "3d" } },
+                // The scene's own grade cube (setStageGrade) — 1×1×1 stand-in while it
+                // has none, which the flag bit keeps from ever being sampled.
+                { binding: 12, visibility: GPUShaderStage.FRAGMENT, texture: { viewDimension: "3d" } },
                 // The cast, for rzSubject/rzAnchor. Always bound so the base shader's
                 // layout matches; the base shader simply never reads it.
                 { binding: 11, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "read-only-storage" } },
@@ -8318,7 +8418,7 @@ export class Engine {
     setupLighting() {
         this.lightUniformBuffer = this.device.createBuffer({
             label: "light uniforms",
-            size: 80 * 4, // ambient (4) + 4 lights x 2 vec4 (32) + irradiance SH 9 x vec4 (36), padded to 80
+            size: 112 * 4, // ambient (4) + 4 lights x 2 vec4 (32) + irradiance SH 9 x vec4 (36) + fog 4 x vec4 (16) + cast shadow (4 + 16)
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         });
         this.lightData.fill(0);
@@ -8367,6 +8467,7 @@ export class Engine {
                 { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: env },
                 { binding: 9, resource: this.brdfLutView },
+                { binding: 10, resource: this.castShadowView },
             ],
         });
         this.mirrorPerFrameBindGroup = this.device.createBindGroup({
@@ -8383,6 +8484,7 @@ export class Engine {
                 { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: env },
                 { binding: 9, resource: this.brdfLutView },
+                { binding: 10, resource: this.castShadowView },
             ],
         });
         return true;
@@ -8406,7 +8508,7 @@ export class Engine {
         // replaces the colour, strength applies to either).
         // An HDRI outranks a gradient outranks the flat colour, which is the order
         // of how much each one knows about the sky.
-        const sh = this.worldSH ?? this.worldGradientSH;
+        const sh = this.worldAmbientSH ?? this.worldSH ?? this.worldGradientSH;
         for (let i = 0; i < 9; i++) {
             const b = 36 + i * 4;
             if (sh) {
@@ -8450,6 +8552,118 @@ export class Engine {
         this.updateLightBuffer();
     }
     /** Update the world environment (Blender: World Background). Ambient recomputes immediately. */
+    /**
+     * Distance fog on every lit surface, as a game on SimPipeline lays it: per
+     * layer, t = saturate(f − (1 − f)·h) with f = saturate(depth·distance[0] +
+     * distance[1]) and h = clamp((height[0] − y) / height[1], −1, 1), and the
+     * colour pulled toward the layer's by (1 − t)·amount — the haze first, then
+     * `dyn`, which X340 uses to darken toward black. Depth is along the view
+     * axis and y the world height, both in this engine's units; colours linear.
+     *
+     * PER VERTEX, as the game computes it, and that is load-bearing rather than
+     * a saving: a floor built of long triangles carries the fog of its far
+     * corners into the near half, which is most of what X340's checker floor
+     * shows of its haze. Emission-only graphs take none, as the game's effect
+     * shaders take none. Null clears.
+     */
+    setSceneFog(fog) {
+        this.sceneFog = fog;
+        const u = this.lightData;
+        const layer = (at, l) => {
+            u[at] = l?.color.x ?? 0;
+            u[at + 1] = l?.color.y ?? 0;
+            u[at + 2] = l?.color.z ?? 0;
+            u[at + 3] = l ? Math.max(l.amount, 0) : 0;
+            u[at + 4] = l?.distance[0] ?? 0;
+            u[at + 5] = l?.distance[1] ?? 1;
+            u[at + 6] = l?.height[0] ?? 0;
+            u[at + 7] = l?.height[1] ?? 1;
+        };
+        layer(72, fog);
+        layer(80, fog?.dyn);
+        this.updateLightBuffer();
+    }
+    /**
+     * The cast's shadow on a stage, as a game on SimPipeline lays its ground
+     * shadow: the characters drawn into a map of their own from `direction` (the
+     * way TO the light, this engine's axes), and every Unity-mode stage surface
+     * multiplied toward `color` (linear) by amount × how much of the cast stands
+     * in the way. Independent of the sun — X340's is dim moonlight, which left a
+     * kneeling figure no shadow at all. Only stage materials read it; a scene
+     * without a stage is untouched. Null turns it off.
+     */
+    setStageCastShadow(opts) {
+        this.castShadow = opts;
+        const u = this.lightData;
+        u[88] = opts?.color.x ?? 1;
+        u[89] = opts?.color.y ?? 1;
+        u[90] = opts?.color.z ?? 1;
+        u[91] = 0; // lit per frame by updateCastShadowVP, once there is a cast to fit
+        this.updateLightBuffer();
+    }
+    /** Fit the cast map to this frame's cast; false when there is nothing to draw. */
+    updateCastShadowVP(stage) {
+        const opts = this.castShadow;
+        let on = false;
+        if (opts && stage) {
+            let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+            for (const inst of this.modelInstances.values()) {
+                if (inst.isStage || inst.isPlane || inst.isProp || !inst.model.visible)
+                    continue;
+                const s = this.castSphereScratch;
+                this.writeCullSphere(inst, s, 0);
+                if (!(s[3] < 1e6))
+                    continue;
+                minX = Math.min(minX, s[0] - s[3]);
+                maxX = Math.max(maxX, s[0] + s[3]);
+                minY = Math.min(minY, s[1] - s[3]);
+                maxY = Math.max(maxY, s[1] + s[3]);
+                minZ = Math.min(minZ, s[2] - s[3]);
+                maxZ = Math.max(maxZ, s[2] + s[3]);
+            }
+            if (minX <= maxX) {
+                const c = new Vec3((minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2);
+                const r = Math.max(maxX - minX, maxY - minY, maxZ - minZ) / 2;
+                const d = new Vec3(opts.direction.x, opts.direction.y, opts.direction.z).normalize();
+                // Wide enough for the shadow a low light throws, deep enough to reach
+                // the floor under the figure from well above it.
+                const half = r * 2.5;
+                const reach = r * 8;
+                const eye = new Vec3(c.x + d.x * reach, c.y + d.y * reach, c.z + d.z * reach);
+                const up = Math.abs(d.y) > 0.99 ? new Vec3(0, 0, 1) : new Vec3(0, 1, 0);
+                const vp = Mat4.orthographicLh(-half, half, -half, half, 1, reach * 2).multiply(Mat4.lookAt(eye, c, up)).values;
+                this.device.queue.writeBuffer(this.castShadowVPBuffer, 0, new Float32Array(vp));
+                this.lightData.set(vp, 92);
+                on = true;
+            }
+        }
+        const amount = on ? Math.max(opts.amount, 0) : 0;
+        if (this.lightData[91] !== amount || on) {
+            this.lightData[91] = amount;
+            this.device.queue.writeBuffer(this.lightUniformBuffer, 88 * 4, this.lightData, 88, 20);
+        }
+        return on;
+    }
+    /**
+     * The world's DIFFUSE light, stated rather than fitted: nine RGB coefficients
+     * (27 floats) in the form rzWorldAmbient evaluates — c0 + c1·y + c2·z + c3·x +
+     * c4·xy + c5·yz + c6·(3z²−1) + c7·xz + c8·(x²−y²), in this engine's axes, the
+     * value a white surface facing n takes. Null goes back to the SH fitted to
+     * the world's picture or gradient.
+     *
+     * A game lights a room's surfaces from an ambient probe that is not its
+     * reflection probe — X340's is a dim blue trilight while its reflections
+     * carry every lamp the probe baked — and one picture cannot be both. With
+     * this set, the picture answers reflections alone. World strength scales it
+     * as it scales the fitted one.
+     */
+    setWorldAmbient(sh) {
+        if (sh && sh.length !== 27)
+            throw new Error(`setWorldAmbient: ${sh.length} floats, not 27`);
+        this.worldAmbientSH = sh ? Float32Array.from(sh) : null;
+        if (this.device && this.lightUniformBuffer)
+            this.writeWorld();
+    }
     setWorld(options) {
         if (options.color)
             this.world.color = options.color;
@@ -8680,6 +8894,8 @@ export class Engine {
             this.canvas.removeEventListener("dblclick", this.handleCanvasDoubleClick);
             this.canvas.removeEventListener("touchend", this.handleCanvasTouch);
         }
+        this.stageGradeTexture?.destroy();
+        this.stageGradeTexture = null;
         this.overlayDepthTexture?.destroy();
         this.overlayDepthTexture = null;
         this.overlayMsaaTexture?.destroy();
@@ -11110,6 +11326,18 @@ export class Engine {
             this.forEachInstance((inst) => this.drawInstanceShadow(shadow, inst, ci));
             return shadow.finish({ label: `shadow pass, cascade ${ci}` });
         });
+        // The cast alone, for the shadow it lays on a stage.
+        const cast = this.device.createRenderBundleEncoder({
+            label: "stage cast shadow pass",
+            colorFormats: [],
+            depthStencilFormat: Engine.SHADOW_DEPTH_FORMAT,
+        });
+        cast.setPipeline(this.shadowDepthPipeline);
+        this.forEachInstance((inst) => {
+            if (!inst.isStage && !inst.isPlane && !inst.isProp)
+                this.drawInstanceShadow(cast, inst, SHADOW_CASCADES.length);
+        });
+        this.castShadowBundle = cast.finish({ label: "stage cast shadow pass" });
         this.bundleRecords++;
     }
     /** The two query slots for a pass, or undefined where the device has no
@@ -11543,6 +11771,16 @@ export class Engine {
                 { binding: 2, resource: this.materialSampler },
             ],
         }));
+        // …and one more past the cascades, for the cast's shadow on a stage.
+        shadowBindGroups.push(this.device.createBindGroup({
+            label: `${name}: shadow bind, stage cast shadow`,
+            layout: this.shadowDepthPipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: this.castShadowVPBuffer } },
+                { binding: 1, resource: { buffer: skinMatrixBuffer } },
+                { binding: 2, resource: this.materialSampler },
+            ],
+        }));
         const mainPerInstanceBindGroup = this.perInstanceBindGroup(name, skinMatrixBuffer, null);
         const pickPerInstanceBindGroup = this.device.createBindGroup({
             label: `${name}: pick per-instance bind group`,
@@ -13576,6 +13814,19 @@ export class Engine {
                 sp.end();
                 this.shadowCascadeCleared[ci] = !wanted;
             }
+            // The cast's shadow on a stage: drawn while a stage asks for it and has a
+            // cast to shade it with; cleared once when it stops, then left alone.
+            const castOn = this.updateCastShadowVP(stage);
+            if (castOn || !this.castShadowCleared) {
+                const cp = encoder.beginRenderPass({
+                    colorAttachments: [],
+                    depthStencilAttachment: { view: this.castShadowView, depthClearValue: 1.0, depthLoadOp: "clear", depthStoreOp: "store" },
+                });
+                if (castOn && this.castShadowBundle)
+                    cp.executeBundles([this.castShadowBundle]);
+                cp.end();
+                this.castShadowCleared = !castOn;
+            }
             this.shadowMapPopulated = hasModels;
         }
         // Before the particles and before the field pass: both may read the grid,
@@ -14652,27 +14903,41 @@ export class Engine {
      * each for a reason that would change pixels: EYE front-culls and gates on a
      * bone read, and pre-filled hair depth over the socket would depth-reject
      * the eye before it could write the stencil the see-through-hair pass needs
-     * — which is also why HAIR stays out entirely. HASHED alpha (stockings)
-     * discards by a position hash this pass does not run, so priming it would
-     * punch its cutout into the depth buffer at the wrong texels. They all still
-     * BENEFIT: their fragments early-z against the primed depth of whatever
-     * plain opaque surface sits in front of them.
+     * — which is also why HAIR stays out entirely. They all still BENEFIT:
+     * their fragments early-z against the primed depth of whatever plain opaque
+     * surface sits in front of them.
+     *
+     * HASHED alpha primes through the SOLID pipeline (cutoff 1.0). Its colour
+     * pass discards by a position hash this pass does not run, but that threshold
+     * is clamped to at most 1, so a texel at alpha exactly 1 survives it always —
+     * those are the only texels the solid prime claims, and it can never punch
+     * the cutout into the wrong ones. A stage's foliage and railings are mostly
+     * such texels, and without the prime every room surface behind them shaded
+     * its full lamp walk and was then painted over.
      */
     drawOpaqueDepthPrepass(pass, inst, view) {
-        let bound = false;
+        let bound = null;
         for (const draw of inst.drawCalls) {
             if (draw.type !== "opaque")
                 continue;
+            let pipeline = this.depthPrepassPipeline;
             if (draw.groupId) {
                 const install = inst.styleGroups.get(draw.groupId);
-                if (install && !(install.renderClass === "auto" && install.alphaMode === "opaque"))
+                if (install && install.renderClass !== "auto")
+                    continue;
+                if (install?.alphaMode === "hashed")
+                    pipeline = this.solidPrepassPipeline;
+                else if (install && install.alphaMode !== "opaque")
                     continue;
             }
-            if (!bound) {
-                pass.setPipeline(this.depthPrepassPipeline);
-                pass.setBindGroup(0, view.perFrame);
-                pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
-                bound = true;
+            if (bound !== pipeline) {
+                pass.setPipeline(pipeline);
+                // One layout for both prepass pipelines, so groups 0 and 1 carry over.
+                if (!bound) {
+                    pass.setBindGroup(0, view.perFrame);
+                    pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
+                }
+                bound = pipeline;
             }
             pass.setBindGroup(2, draw.bindGroup);
             this.issueDraw(pass, draw, view.args);

package/dist/graph/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/graph/compile.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAA0B,WAAW,EAAE,MAAM,UAAU,CAAA;AAI7F,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAExE,MAAM,MAAM,cAAc,GAAG;IAC3B;8EAC0E;IAC1E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;6DACyD;IACzD,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C;0EACsE;IACtE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,OAAO,CAAA;IACX,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAcD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,SAAS,EAAE,CAuBpE;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,GAAE,cAAmB,GAAG,UAAU,EAAE,CA4GzF;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,GAAE,cAAmB,GAAG,aAAa,CAmKzF"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/graph/compile.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAA0B,WAAW,EAAE,MAAM,UAAU,CAAA;AAI7F,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAExE,MAAM,MAAM,cAAc,GAAG;IAC3B;8EAC0E;IAC1E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;6DACyD;IACzD,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C;0EACsE;IACtE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,OAAO,CAAA;IACX,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAcD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,SAAS,EAAE,CAuBpE;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,GAAE,cAAmB,GAAG,UAAU,EAAE,CA4GzF;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,GAAE,cAAmB,GAAG,aAAa,CAsKzF"}

package/dist/graph/compile.js

@@ -309,6 +309,9 @@ export function compileGraph(graph, opts = {}) {
     if (opacity)
         lines.push(`  let final_opacity = saturate(${outputExpr(opacity, "float")}); // @node:${opacity.node}`);
     const fsBody = lines.join("\n");
-    const wgsl = assembleModule(opts.renderClass ?? "auto", opts.alphaMode ?? "opaque", fsBody, usesStyle.current, !!opacity, opts.blend ?? "over");
+    // A graph takes light when its body reads any: the four shading nodes all
+    // pass `sun, amb`, and a hand-written node reaching for the lamps names them.
+    const takesLight = /\bsun\b|\bamb\b|rzLight|rzLamp/.test(fsBody);
+    const wgsl = assembleModule(opts.renderClass ?? "auto", opts.alphaMode ?? "opaque", fsBody, usesStyle.current, !!opacity, opts.blend ?? "over", takesLight);
     return { ok: true, wgsl, fsBody, slotMap, diagnostics, prunedNodes };
 }

package/dist/graph/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/graph/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEzD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAA;IAC/C,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAYD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAoBhE;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAIpE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAM1D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE;AAyCD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CA0tBlD,CAAA"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/graph/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEzD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAA;IAC/C,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAYD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAoBhE;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAIpE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAM1D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE;AAyCD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAsuBlD,CAAA"}

package/dist/graph/registry.js

@@ -791,6 +791,14 @@ export const NODE_REGISTRY = {
             /** Ours, not Blender's: caps firefly speculars from noise-bumped NDF
              *  aliasing, which EEVEE hides behind TAA and we have none. */
             spec_clamp: F(1e30),
+            /** Ours: how roughness picks the reflection's blur. 0 is the engine's
+             *  sqrt ramp; 1 is Unity's probe curve, p·(1.7−0.7p) mip-steps per
+             *  eighth, stopping where a cube's last face texel does — what a stage
+             *  ripped from a Unity game was authored against. See rzWorldSpecularLod. */
+            reflection_lod: F(0),
+            /** Ours: 1 shades the sun's and the lamps' highlights with URP's
+             *  direct-light BRDF, as a stage from a Unity game was lit — see bsdf_urp. */
+            unity_direct: F(0),
         },
         outputs: { color: "color" },
         emit: (a) => {
@@ -801,11 +809,15 @@ export const NODE_REGISTRY = {
             const spec = foldSpecular(a.ior, a.specular_ior_level);
             const bsdf = `eval_principled(PrincipledIn(${a.base_color}, ${a.metallic}, ` +
                 `${spec}, ${a.roughness}, ` +
-                `${a.spec_clamp}, ${a.sheen_weight}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow, input.worldPos)`;
+                `${a.spec_clamp}, ${a.sheen_weight}, ${a.sheen_tint}, ${a.reflection_lod}, ${a.unity_direct}), ${a.normal}, l, v, sun, amb, shadow, input.worldPos)`;
             // v2 defaults Emission Strength to 0, which is the overwhelming case. Emit
             // the term only when it can do something, so the common shader carries no
             // dead add and the output stays readable.
-            return a.emission_strength === "0.0" ? bsdf : `${bsdf} + ${a.emission_color} * ${a.emission_strength}`;
+            const lit = a.emission_strength === "0.0" ? bsdf : `${bsdf} + ${a.emission_color} * ${a.emission_strength}`;
+            // Unity mode also ends as SimPipeline's surfaces end: saturate()d, so no
+            // lit or glowing surface passes 1.0 before the post — its bloom works on
+            // what is left under that. A literal, as every stage graph states it.
+            return a.unity_direct === "1.0" ? `min(${lit}, vec3f(1.0))` : lit;
         },
     },
 };

package/dist/graph/slots.d.ts

@@ -4,5 +4,5 @@ import type { AlphaMode, RenderClass, StyleBlend } from "./render-class";
  * StyleUniforms, render-class/alpha-mode declarations, the composed fs() shell, and the
  * graph's node body.
  */
-export declare function assembleModule(renderClass: RenderClass, alphaMode: AlphaMode, fsBody: string, includeStyleUniforms: boolean, hasOpacity?: boolean, blend?: StyleBlend): string;
+export declare function assembleModule(renderClass: RenderClass, alphaMode: AlphaMode, fsBody: string, includeStyleUniforms: boolean, hasOpacity?: boolean, blend?: StyleBlend, takesLight?: boolean): string;
 //# sourceMappingURL=slots.d.ts.map

package/dist/graph/slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/graph/slots.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAiMxE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,OAAO,EAC7B,UAAU,UAAQ,EAClB,KAAK,GAAE,UAAmB,GACzB,MAAM,CAgBR"}
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/graph/slots.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AA+MxE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,OAAO,EAC7B,UAAU,UAAQ,EAClB,KAAK,GAAE,UAAmB,EAC1B,UAAU,UAAO,GAChB,MAAM,CAgBR"}

package/dist/graph/slots.js

@@ -132,13 +132,16 @@ ${gate}
   let amb = rzWorldAmbient(n) + modelLight.fill.rgb;
   let shadow = sampleShadow(input.worldPos, n);
   let tex_color = tex_s.rgb;
+  // The normal the lamps' diffuse layer is lit by, for a principled walk to
+  // compute it on the way (rzLightsDiffuseOnce). n is final from here on.
+  _rzLampN = n;
 
 `;
 }
 // Tail of fs(): consumes `final_color` + locals, writes FSOut. hashed forces output
 // alpha to 1 (the discard already did the cutout); hair scales alpha for the over-eyes
 // pass when IS_OVER_EYES is compiled true.
-function epilogue(renderClass, alphaMode, hasOpacity, blend) {
+function epilogue(renderClass, alphaMode, hasOpacity, blend, takesLight) {
     // A graph that computes its own opacity wins, including over hashed: hashed
     // writes 1 because its discard already decided the cutout, and a graph asking
     // for a curve is asking for the opposite of a cutout. Additive writes 1 for a
@@ -164,7 +167,12 @@ function epilogue(renderClass, alphaMode, hasOpacity, blend) {
     // so the fix has an address — when graphs gain an optional albedo output
     // (material-track era), it lands here and every light is corrected at once,
     // instead of a hunt through the epilogue's string templates.
-    const LIT = ` + rzLightsDiffuse(input.worldPos, n) * albedo`;
+    //
+    // ONLY ON A GRAPH THAT TAKES LIGHT. An emission-only graph — Unlit, a stage's
+    // painted sheet — is Blender's Emission shader, which no lamp reaches; adding
+    // the lamps to it turned X340's floor shadow, a white-RGB picture at a soft
+    // alpha, into a glowing disc under the spot above it.
+    const LIT = takesLight ? ` + rzLightsDiffuseOnce(input.worldPos, n) * albedo` : "";
     const ALBEDO = `  let albedo = tex_color;
 `;
     // The dissolve's burning edge, ADDED after the graph and after the lights —
@@ -172,19 +180,24 @@ function epilogue(renderClass, alphaMode, hasOpacity, blend) {
     // on every fragment of every material that is not dissolving, which is what
     // keeps this out of the way of a scene that never uses it.
     const BURN = ` + RZ_BURN_COLOR * rz_burn`;
+    // The scene fog, last, as the game lays it over a lit surface; an
+    // emission-only graph takes none (the game's effect shaders have no fog).
+    const FOG = takesLight
+        ? `  out.color = vec4f(mix(mix(out.color.rgb, light.fog[0].rgb, input.fog.x), light.fog[2].rgb, input.fog.y), out.color.a);\n`
+        : "";
     if (renderClass === "hair") {
         return `${ALBEDO}  var outAlpha = ${alphaBase};
   if (IS_OVER_EYES) { outAlpha = ${alphaBase} * 0.25; }
 
   var out: FSOut;
   out.color = vec4f(final_color${LIT}${BURN}, outAlpha);
-  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+${FOG}  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${ID_WRITE}  return out;
 `;
     }
     return `${ALBEDO}  var out: FSOut;
   out.color = vec4f(final_color${LIT}${BURN}, ${alphaBase});
-  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+${FOG}  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${ID_WRITE}  return out;
 `;
 }
@@ -193,7 +206,7 @@ ${ID_WRITE}  return out;
  * StyleUniforms, render-class/alpha-mode declarations, the composed fs() shell, and the
  * graph's node body.
  */
-export function assembleModule(renderClass, alphaMode, fsBody, includeStyleUniforms, hasOpacity = false, blend = "over") {
+export function assembleModule(renderClass, alphaMode, fsBody, includeStyleUniforms, hasOpacity = false, blend = "over", takesLight = true) {
     return (NODES_WGSL +
         COMMON_MATERIAL_PRELUDE_WGSL +
         // Exactly where it sat inside the prelude constant. It moved out because
@@ -205,6 +218,6 @@ export function assembleModule(renderClass, alphaMode, fsBody, includeStyleUnifo
         prelude(renderClass, alphaMode, blend) +
         fsBody +
         "\n" +
-        epilogue(renderClass, alphaMode, hasOpacity, blend) +
+        epilogue(renderClass, alphaMode, hasOpacity, blend, takesLight) +
         "}\n");
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Engine, DEFAULT_BLOOM_OPTIONS, DEFAULT_DEPTH_OF_FIELD_OPTIONS, DEFAULT_VIEW_TRANSFORM, DEFAULT_COLOR_GRADING, type ColorGradingOptions, type EngineStats, type EngineOptions, type BloomOptions, type DepthOfFieldOptions, type ViewTransformOptions, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type SceneLight, type ModelAttachment, type GizmoDragEvent, type GizmoDragCallback, type GizmoDragKind, type DissolveCycle, type EffectParamValue, type EffectResult, type CullDiagnostics, type MidiNote, } from "./engine";
+export { Engine, DEFAULT_BLOOM_OPTIONS, DEFAULT_DEPTH_OF_FIELD_OPTIONS, DEFAULT_VIEW_TRANSFORM, DEFAULT_COLOR_GRADING, type ColorGradingOptions, type StageGradeLut, type SceneFog, type StageCastShadow, type SceneFogLayer, type EngineStats, type EngineOptions, type BloomOptions, type DepthOfFieldOptions, type ViewTransformOptions, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type SceneLight, type ModelAttachment, type GizmoDragEvent, type GizmoDragCallback, type GizmoDragKind, type DissolveCycle, type EffectParamValue, type EffectResult, type CullDiagnostics, type MidiNote, } from "./engine";
 export { parsePmxFolderInput, pmxFileAtRelativePath, type PmxFolderInputResult } from "./folder-upload";
 export { parseMidi } from "./midi-loader";
 export { parseHDR, type HdrImage } from "./hdr";