reze-engine 0.68.0 → 0.68.2

package/dist/engine.js

@@ -17,6 +17,7 @@ import { RezePhysics } from "./physics";
 import { createFetchAssetReader, createFileMapAssetReader, deriveBasePathFromPmxPath, fileListToMap, findFirstPmxFileInList, joinAssetPath, normalizeAssetPath, } from "./asset-reader";
 import { SHADOW_DEPTH_SHADER_WGSL } from "./shaders/passes/shadow";
 import { ID_DEBUG_SHADER_WGSL } from "./shaders/passes/id-debug";
+import { AOV_PIXELS_WGSL, AOV_PIXEL_FIELDS, AOV_PIXEL_STRIDE, AOV_PROBE_HEAD, AOV_PROBE_STRIDE, AOV_PROBE_WGSL } from "./shaders/passes/aov";
 import { paramChanged, sampleParamTrack } from "./param-track";
 import { advanceSim, DISSOLVE_PARAMS, dissolveConstants, dissolveCycleOf, effectState, sampleDissolveCycle, scheduledDissolve, } from "./effect-schedule";
 import { parentKeySpan } from "./parent-keys";
@@ -851,6 +852,11 @@ export class Engine {
         this.idDebugBindGroupLayout = null;
         this.idDebugBindGroup = null;
         this.idDebug = false;
+        /** Store ids and depth for readAovs — see setAovCapture. */
+        this.aovCapture = false;
+        this.aovPixelsPipeline = null;
+        this.aovProbePipeline = null;
+        this.aovSampler = null;
         this.particleFrame = 0;
         /** Reused for the per-frame field-clock upload — one 16-byte write per
          *  drawing effect, and allocating a fresh array for each would be garbage
@@ -2071,6 +2077,187 @@ export class Engine {
     hasObjectIds() {
         return this.idView !== null;
     }
+    /**
+     * Keep the frame's ids and depth for readAovs.
+     *
+     * Both are discarded at the end of an ordinary frame (see the store ops in
+     * renderFrame); while this is on they are stored, on exactly the terms the
+     * id-debug view and a masking effect already get. Turn it on, render the
+     * frame to measure, read it, turn it off — the stores cost real bandwidth
+     * and nothing else reads them.
+     *
+     * Returns false when the device has no id attachment, in which case
+     * readAovs answers null.
+     */
+    setAovCapture(on) {
+        this.aovCapture = on && this.idView !== null;
+        return this.aovCapture || !on;
+    }
+    /**
+     * What drew each id: the model's object id, and its materials' ids in the
+     * order the id attachment counts them (materials that produced a draw,
+     * 1-based). The floor is GROUND_OBJECT_ID / GROUND_MATERIAL_ID.
+     */
+    getIdLegend() {
+        const out = [];
+        for (const [name, inst] of this.modelInstances) {
+            const materials = [];
+            let id = 0;
+            for (const mat of inst.model.getMaterials()) {
+                if (mat.vertexCount === 0)
+                    continue;
+                materials.push({ id: ++id, name: mat.name });
+            }
+            out.push({ objectId: inst.objectId, model: name, materials });
+        }
+        return out;
+    }
+    /**
+     * The last frame, as numbers: per texel its linear colour, what drew it, how
+     * far it is, and the light arriving there — the sun's shadow and facing, the
+     * lamps', the world's. See shaders/passes/aov.ts for what each field is and
+     * how the normal is rebuilt.
+     *
+     * Reads the frame ALREADY RENDERED, at the render size it was rendered at:
+     * call it after renderFrame with setAovCapture on, before anything renders
+     * again (a capture stops the loop for exactly this). Null when the device
+     * has no id attachment or capture was not on.
+     */
+    async readAovs() {
+        if (!this.aovCapture || !this.idView || !this.depthReadView || !this.camera)
+            return null;
+        const width = this.hdrResolveTexture.width;
+        const height = this.hdrResolveTexture.height;
+        const pipeline = this.aovPixelsPipeline ?? (this.aovPixelsPipeline = this.device.createComputePipeline({
+            label: "aov pixels",
+            layout: "auto",
+            compute: { module: this.device.createShaderModule({ label: "aov pixels", code: AOV_PIXELS_WGSL }), entryPoint: "pixels" },
+        }));
+        const invVP = this.camera.getProjectionMatrix().multiply(this.camera.getViewMatrix()).inverse().values;
+        const eye = this.camera.getPosition();
+        const uniform = new ArrayBuffer(64 + 16 + 16);
+        new Float32Array(uniform, 0, 16).set(invVP);
+        new Float32Array(uniform, 64, 4).set([eye.x, eye.y, eye.z, 1]);
+        new Uint32Array(uniform, 80, 4).set([width, height, 0, 0]);
+        const ubuf = this.device.createBuffer({ label: "aov uniforms", size: uniform.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.device.queue.writeBuffer(ubuf, 0, uniform);
+        const texels = width * height;
+        const fBytes = texels * AOV_PIXEL_STRIDE * 4;
+        const idBytes = texels * 4;
+        const fBuf = this.device.createBuffer({ label: "aov out", size: fBytes, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
+        const idBuf = this.device.createBuffer({ label: "aov ids", size: idBytes, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
+        const fRead = this.device.createBuffer({ label: "aov out read", size: fBytes, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+        const idRead = this.device.createBuffer({ label: "aov ids read", size: idBytes, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+        const bind = this.device.createBindGroup({
+            label: "aov pixels",
+            layout: pipeline.getBindGroupLayout(0),
+            entries: [
+                ...this.aovLightEntries(),
+                { binding: 7, resource: this.idView },
+                { binding: 8, resource: this.depthReadView },
+                { binding: 9, resource: this.hdrResolveTexture.createView() },
+                { binding: 10, resource: { buffer: ubuf } },
+                { binding: 11, resource: { buffer: fBuf } },
+                { binding: 12, resource: { buffer: idBuf } },
+            ],
+        });
+        const encoder = this.device.createCommandEncoder({ label: "aov pixels" });
+        const pass = encoder.beginComputePass({ label: "aov pixels" });
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bind);
+        pass.dispatchWorkgroups(Math.ceil(width / 8), Math.ceil(height / 8));
+        pass.end();
+        encoder.copyBufferToBuffer(fBuf, 0, fRead, 0, fBytes);
+        encoder.copyBufferToBuffer(idBuf, 0, idRead, 0, idBytes);
+        this.device.queue.submit([encoder.finish()]);
+        try {
+            await Promise.all([fRead.mapAsync(GPUMapMode.READ), idRead.mapAsync(GPUMapMode.READ)]);
+            const f = new Float32Array(fRead.getMappedRange().slice(0));
+            const ids = new Uint32Array(idRead.getMappedRange().slice(0));
+            const exposure = this.getViewTransformOptions().exposure ?? 0;
+            return { width, height, stride: AOV_PIXEL_STRIDE, fields: AOV_PIXEL_FIELDS, data: f, ids, exposure };
+        }
+        finally {
+            for (const b of [ubuf, fBuf, idBuf, fRead, idRead])
+                b.destroy();
+        }
+    }
+    /**
+     * The light arriving at points the caller names — a face, a hand, a spot on
+     * the floor — facing the normal given: the sun's shadow, facing and colour,
+     * the world's ambient, and EACH LAMP'S share kept apart, in the order the
+     * engine holds them (the document's lamps first, as setLights got them,
+     * then any an effect emits).
+     *
+     * Reads the shadow atlas and lamp records of the last frame rendered.
+     */
+    async probeLight(points) {
+        if (points.length === 0)
+            return [];
+        const pipeline = this.aovProbePipeline ?? (this.aovProbePipeline = this.device.createComputePipeline({
+            label: "aov probe",
+            layout: "auto",
+            compute: { module: this.device.createShaderModule({ label: "aov probe", code: AOV_PROBE_WGSL }), entryPoint: "probe" },
+        }));
+        const data = new Float32Array(points.length * 8);
+        points.forEach((pt, i) => data.set([pt.position.x, pt.position.y, pt.position.z, 1, pt.normal.x, pt.normal.y, pt.normal.z, 0], i * 8));
+        const inBuf = this.device.createBuffer({ label: "aov probe points", size: data.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+        this.device.queue.writeBuffer(inBuf, 0, data);
+        const outBytes = points.length * AOV_PROBE_STRIDE * 4;
+        const outBuf = this.device.createBuffer({ label: "aov probe out", size: outBytes, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
+        const readBuf = this.device.createBuffer({ label: "aov probe read", size: outBytes, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+        const bind = this.device.createBindGroup({
+            label: "aov probe",
+            layout: pipeline.getBindGroupLayout(0),
+            entries: [...this.aovLightEntries(), { binding: 7, resource: { buffer: inBuf } }, { binding: 8, resource: { buffer: outBuf } }],
+        });
+        const encoder = this.device.createCommandEncoder({ label: "aov probe" });
+        const pass = encoder.beginComputePass({ label: "aov probe" });
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bind);
+        pass.dispatchWorkgroups(points.length);
+        pass.end();
+        encoder.copyBufferToBuffer(outBuf, 0, readBuf, 0, outBytes);
+        this.device.queue.submit([encoder.finish()]);
+        try {
+            await readBuf.mapAsync(GPUMapMode.READ);
+            const f = new Float32Array(readBuf.getMappedRange().slice(0));
+            return points.map((_, i) => {
+                const o = i * AOV_PROBE_STRIDE;
+                const count = Math.round(f[o + 8]);
+                const lamps = [];
+                for (let l = 0; l < count; l++) {
+                    const b = o + AOV_PROBE_HEAD + l * 4;
+                    lamps.push([f[b], f[b + 1], f[b + 2]]);
+                }
+                return {
+                    sunShadow: f[o],
+                    sunFacing: f[o + 1],
+                    sun: [f[o + 2], f[o + 3], f[o + 4]],
+                    ambient: [f[o + 5], f[o + 6], f[o + 7]],
+                    lamps,
+                    documentLamps: Math.round(f[o + 9]),
+                };
+            });
+        }
+        finally {
+            for (const b of [inBuf, outBuf, readBuf])
+                b.destroy();
+        }
+    }
+    /** The scene light API and the lamps, as aov.ts's prelude binds them. */
+    aovLightEntries() {
+        this.aovSampler ?? (this.aovSampler = this.device.createSampler({ label: "aov cookie sampler", magFilter: "linear", minFilter: "linear" }));
+        return [
+            { binding: 0, resource: { buffer: this.lightUniformBuffer } },
+            { binding: 1, resource: { buffer: this.shadowLightVPBuffer } },
+            { binding: 2, resource: this.shadowAtlasView },
+            { binding: 3, resource: this.shadowComparisonSampler },
+            { binding: 4, resource: { buffer: this.lightsBuffer } },
+            { binding: 5, resource: this.cookieView },
+            { binding: 6, resource: this.aovSampler },
+        ];
+    }
     /** The pass that draws it, built lazily so a scene that never asks for the
      *  debug view never compiles it. */
     ensureIdDebugPipeline() {
@@ -5550,6 +5737,11 @@ export class Engine {
      * frame. Nothing recompiles, so this is safe to drive per frame from a
      * timeline.
      */
+    /** How many effects are installed — the indices setEffectInfluence and its
+     *  siblings address are 0 up to this. */
+    getEffectCount() {
+        return this.effects.length;
+    }
     setEffectInfluence(index, influence) {
         const fx = this.effects[index];
         if (!fx)
@@ -11433,6 +11625,27 @@ export class Engine {
         inst.simulateWhileHidden = on;
         return true;
     }
+    /**
+     * Whether one model casts a shadow at all.
+     *
+     * Off takes it out of the shadow map, the shadow the cast lays on a stage and
+     * the caster sphere the floor fits its shadow to; it still receives shadows
+     * from everything else. On defers to the PMX author's flag per material, so a
+     * material its author excluded stays excluded.
+     */
+    setModelCastShadow(modelName, on) {
+        const inst = this.modelInstances.get(modelName);
+        if (!inst)
+            return false;
+        if (inst.castShadow === on)
+            return true;
+        inst.castShadow = on;
+        this.sortDrawCalls(inst);
+        return true;
+    }
+    getModelCastShadow(modelName) {
+        return this.modelInstances.get(modelName)?.castShadow ?? true;
+    }
     getPhysicsFloor() {
         return this.physicsFloor;
     }
@@ -11657,7 +11870,7 @@ export class Engine {
             this.cullMetaF32[f + 4] = b[3];
             this.cullMetaF32[f + 5] = b[4];
             this.cullMetaF32[f + 6] = b[5];
-            this.cullMetaU32[f + 7] = draw.castsShadow === true ? Engine.CULL_DRAW_CASTS_SHADOW : 0;
+            this.cullMetaU32[f + 7] = inst.castShadow && draw.castsShadow === true ? Engine.CULL_DRAW_CASTS_SHADOW : 0;
             // Everything but instanceCount is structural, so the compute never writes
             // it — one fewer store per draw per frame, and the args stay readable in a
             // capture as "this is the draw, that is whether it survived".
@@ -12762,6 +12975,7 @@ export class Engine {
             name,
             model,
             simulateWhileHidden: false,
+            castShadow: true,
             basePath,
             assetReader,
             gpuBuffers,
@@ -14699,7 +14913,7 @@ export class Engine {
         // The scattering pass is the third reader: it rejects taps across a depth
         // step and scales its width by distance, so a scene wearing a subsurface
         // look stores depth for as long as it does.
-        const depthRead = dofOn || this.effects.some((e) => e.hasForeground) || this.subsurfaceInUse();
+        const depthRead = dofOn || this.aovCapture || this.effects.some((e) => e.hasForeground) || this.subsurfaceInUse();
         this.renderPassDescriptor.depthStencilAttachment.depthStoreOp = depthRead ? "store" : "discard";
         if (depthRead)
             this.writeDepthOfFieldUniforms();
@@ -14721,7 +14935,7 @@ export class Engine {
         if (idAtt) {
             // The flood seeds from the id attachment, so an effect that reads only the
             // DISTANCE still needs the ids kept — it just never names them itself.
-            const idsRead = this.idDebug || this.effects.some((e) => e.readsIds || e.readsCastDistance);
+            const idsRead = this.idDebug || this.aovCapture || this.effects.some((e) => e.readsIds || e.readsCastDistance);
             idAtt.storeOp = idsRead ? "store" : "discard";
         }
         // The stage's reflection probe, when one is due: its own submits, ahead of
@@ -15714,7 +15928,9 @@ export class Engine {
             ground: 4,
         };
         inst.drawCalls.sort((a, b) => typeOrder[a.type] - typeOrder[b.type] || this.drawCallRank(inst, a) - this.drawCallRank(inst, b));
-        inst.shadowDrawCalls = inst.drawCalls.filter((d) => (d.type === "opaque" || d.type === "transparent") && d.castsShadow === true);
+        inst.shadowDrawCalls = inst.castShadow
+            ? inst.drawCalls.filter((d) => (d.type === "opaque" || d.type === "transparent") && d.castsShadow === true)
+            : [];
         // The sort reorders drawCalls, and a draw's position in that array is its
         // slot in every cull buffer.
         this.cullListDirty = true;

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 StageGradeLut, type SceneFog, type StageCastShadow, type SceneFogLayer, type EngineStats, type EngineOptions, type BloomOptions, type DepthOfFieldOptions, type ViewTransformOptions, type ViewTransformName, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type SceneLight, RENDERING_LAYER_DEFAULT, RENDERING_LAYER_CHARACTER, 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 ViewTransformName, type LoadModelFromFilesOptions, type MaterialPreset, type MaterialPresetMap, type ModelTransform, type SceneLight, RENDERING_LAYER_DEFAULT, RENDERING_LAYER_CHARACTER, type ModelAttachment, type SceneAovs, type LightProbe, 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";
@@ -59,4 +59,6 @@ export type { EyeTrackingOptions } from "./model";
 export type { NativeStagePackage, NativeStageReader } from "./unity/stage";
 export type { NativeLook, NativeMaterialSpec, NativeTexture } from "./unity/looks";
 export type { NativeShader, NativeShaderInfo } from "./unity/host";
+export { AOV_PIXEL_FIELDS, AOV_PIXEL_STRIDE } from "./shaders/passes/aov";
+export { GROUND_MATERIAL_ID, GROUND_OBJECT_ID } from "./shaders/passes/ground";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -66,3 +66,5 @@ export { boneOverlay, boneMarkerPositions, rigidbodyOverlay, jointOverlay, build
  * Pure strings, no GPU: importing them costs a host nothing.
  */
 export { EFFECT_MATH_API, PARTICLE_STRUCT_WGSL } from "./shaders/passes/hosted-api";
+export { AOV_PIXEL_FIELDS, AOV_PIXEL_STRIDE } from "./shaders/passes/aov";
+export { GROUND_MATERIAL_ID, GROUND_OBJECT_ID } from "./shaders/passes/ground";

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

@@ -0,0 +1,37 @@
+/**
+ * The frame, read back as numbers — what an agent (or a test) measures instead
+ * of squinting at a picture.
+ *
+ * A screenshot answers "what does it look like". It cannot answer the questions
+ * a lighting artist actually asks of a render: is her face in the sun's shadow,
+ * which lamp is carrying the key, how many stops over is that highlight, which
+ * pixels are skin. Every one of those is a number the frame already computed
+ * and threw away; these passes keep them.
+ *
+ * TWO ENTRY POINTS over one prelude:
+ *
+ *   pixels — one invocation per texel of the frame just rendered. Reads the id
+ *            attachment, the depth and the linear HDR resolve, rebuilds the
+ *            world point from the depth and a normal from its neighbours, and
+ *            asks the same shadow atlas and lamp records the materials asked.
+ *   probe  — the same light questions at points the caller names (a bone, a
+ *            face), with each lamp's share kept apart.
+ *
+ * The normal is RECONSTRUCTED from depth, not the one the material shaded
+ * with: the frame never stores normals, and storing them for every frame to
+ * serve an occasional readback would be the cost the id attachment's
+ * store-only-when-read rule exists to avoid. On a silhouette edge it is the
+ * flatter of the two neighbours, which is right for every texel that is not
+ * the edge itself.
+ */
+/** Floats per texel in the pixels output — see PIXEL_FIELDS. */
+export declare const AOV_PIXEL_STRIDE = 12;
+/** What each of a texel's floats is, in order. */
+export declare const AOV_PIXEL_FIELDS: readonly ["r", "g", "b", "depth", "sunShadow", "sunFacing", "lampR", "lampG", "lampB", "ambR", "ambG", "ambB"];
+/** Floats per probe point before its per-lamp block. */
+export declare const AOV_PROBE_HEAD = 12;
+/** Floats per probe point: the head, then rgb+pad for every lamp slot. */
+export declare const AOV_PROBE_STRIDE: number;
+export declare const AOV_PIXELS_WGSL: string;
+export declare const AOV_PROBE_WGSL: string;
+//# sourceMappingURL=aov.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aov.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/aov.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC,kDAAkD;AAClD,eAAO,MAAM,gBAAgB,gHAOnB,CAAA;AAEV,wDAAwD;AACxD,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,QAAkC,CAAA;AAqB/D,eAAO,MAAM,eAAe,QA6E3B,CAAA;AAED,eAAO,MAAM,cAAc,QAwC1B,CAAA"}

package/dist/shaders/passes/aov.js

@@ -0,0 +1,180 @@
+import { sceneLightApi } from "../scene-light-api";
+import { lightsApi, MAX_LIGHTS } from "../lights";
+/**
+ * The frame, read back as numbers — what an agent (or a test) measures instead
+ * of squinting at a picture.
+ *
+ * A screenshot answers "what does it look like". It cannot answer the questions
+ * a lighting artist actually asks of a render: is her face in the sun's shadow,
+ * which lamp is carrying the key, how many stops over is that highlight, which
+ * pixels are skin. Every one of those is a number the frame already computed
+ * and threw away; these passes keep them.
+ *
+ * TWO ENTRY POINTS over one prelude:
+ *
+ *   pixels — one invocation per texel of the frame just rendered. Reads the id
+ *            attachment, the depth and the linear HDR resolve, rebuilds the
+ *            world point from the depth and a normal from its neighbours, and
+ *            asks the same shadow atlas and lamp records the materials asked.
+ *   probe  — the same light questions at points the caller names (a bone, a
+ *            face), with each lamp's share kept apart.
+ *
+ * The normal is RECONSTRUCTED from depth, not the one the material shaded
+ * with: the frame never stores normals, and storing them for every frame to
+ * serve an occasional readback would be the cost the id attachment's
+ * store-only-when-read rule exists to avoid. On a silhouette edge it is the
+ * flatter of the two neighbours, which is right for every texel that is not
+ * the edge itself.
+ */
+/** Floats per texel in the pixels output — see PIXEL_FIELDS. */
+export const AOV_PIXEL_STRIDE = 12;
+/** What each of a texel's floats is, in order. */
+export const AOV_PIXEL_FIELDS = [
+    "r", "g", "b", // linear HDR, before exposure and the view transform
+    "depth", // distance from the eye, world units; 0 where nothing drew
+    "sunShadow", // 1 lit, 0 in a caster's shadow; -1 where nothing drew
+    "sunFacing", // N·L toward the sun, -1..1 (the toon ramp's input)
+    "lampR", "lampG", "lampB", // every positional lamp's light arriving here
+    "ambR", "ambG", "ambB", // the world's light arriving here
+];
+/** Floats per probe point before its per-lamp block. */
+export const AOV_PROBE_HEAD = 12;
+/** Floats per probe point: the head, then rgb+pad for every lamp slot. */
+export const AOV_PROBE_STRIDE = AOV_PROBE_HEAD + MAX_LIGHTS * 4;
+// Bindings 0..3 are the scene light API, 4..6 the lamps and their cookies.
+const PRELUDE = /* wgsl */ `
+${sceneLightApi(true, 0, 0)}
+${lightsApi(0, 4, "0xffffffffu", { binding: 5, sampler: "_aovSampler" })}
+@group(0) @binding(6) var _aovSampler: sampler;
+
+/** The sun's cast shadow at p, nudged along n off the surface — the
+ *  materials' rzSunOcclusion, without the facing test (sunFacing carries it). */
+fn aovSunShadow(p: vec3f, n: vec3f) -> f32 {
+  let castAmt = _rzLight.lights[0].direction.w;
+  if (castAmt <= 0.0) { return 1.0; }
+  let a = _rzSunLocate(p + n * 0.08);
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
+}
+
+fn aovToSun() -> vec3f { return normalize(-_rzLight.lights[0].direction.xyz); }
+`;
+export const AOV_PIXELS_WGSL = /* wgsl */ `
+${PRELUDE}
+@group(0) @binding(7) var idTex: texture_multisampled_2d<u32>;
+@group(0) @binding(8) var depthTex: texture_depth_multisampled_2d;
+@group(0) @binding(9) var hdrTex: texture_2d<f32>;
+struct AovU { invViewProj: mat4x4f, eye: vec4f, size: vec4u, }
+@group(0) @binding(10) var<uniform> u: AovU;
+@group(0) @binding(11) var<storage, read_write> outF: array<f32>;
+@group(0) @binding(12) var<storage, read_write> outId: array<u32>;
+
+fn worldAt(c: vec2i, z: f32) -> vec3f {
+  let uv = (vec2f(c) + 0.5) / vec2f(u.size.xy);
+  let h = u.invViewProj * vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, z, 1.0);
+  return h.xyz / h.w;
+}
+
+fn drawn(c: vec2i) -> bool {
+  if (any(c < vec2i(0)) || any(c >= vec2i(u.size.xy))) { return false; }
+  let id = textureLoad(idTex, c, 0).xy;
+  return id.x != 0u || id.y != 0u;
+}
+
+/** The step from p to the neighbour at c + d (or c - d, negated), whichever is
+ *  nearer in depth: across a silhouette the far neighbour belongs to something
+ *  else, and a normal built from it tilts toward the background. */
+fn tangent(c: vec2i, d: vec2i, p: vec3f) -> vec3f {
+  let a = c + d;
+  let b = c - d;
+  let okA = drawn(a);
+  let okB = drawn(b);
+  var ta = vec3f(0.0);
+  var tb = vec3f(0.0);
+  if (okA) { ta = worldAt(a, textureLoad(depthTex, a, 0)) - p; }
+  if (okB) { tb = p - worldAt(b, textureLoad(depthTex, b, 0)); }
+  if (okA && okB) { return select(tb, ta, dot(ta, ta) <= dot(tb, tb)); }
+  if (okA) { return ta; }
+  return tb;
+}
+
+@compute @workgroup_size(8, 8)
+fn pixels(@builtin(global_invocation_id) gid: vec3u) {
+  if (gid.x >= u.size.x || gid.y >= u.size.y) { return; }
+  let c = vec2i(gid.xy);
+  let i = gid.y * u.size.x + gid.x;
+  let o = i * ${AOV_PIXEL_STRIDE}u;
+  let id = textureLoad(idTex, c, 0).xy;
+  let rgb = textureLoad(hdrTex, c, 0).rgb;
+  // Material in the low half, object in the high — the attachment's own order
+  // (scene-contract: vec2u(material, object)).
+  outId[i] = (id.y << 16u) | (id.x & 0xffffu);
+  outF[o] = rgb.r;
+  outF[o + 1u] = rgb.g;
+  outF[o + 2u] = rgb.b;
+  for (var k = 3u; k < ${AOV_PIXEL_STRIDE}u; k++) { outF[o + k] = 0.0; }
+  if (id.x == 0u && id.y == 0u) {
+    outF[o + 4u] = -1.0;
+    return;
+  }
+  let p = worldAt(c, textureLoad(depthTex, c, 0));
+  var n = cross(tangent(c, vec2i(0, 1), p), tangent(c, vec2i(1, 0), p));
+  let toEye = u.eye.xyz - p;
+  if (dot(n, n) < 1e-12) { n = toEye; }
+  n = normalize(n);
+  // Toward the eye: the side of the surface this texel shows.
+  if (dot(n, toEye) < 0.0) { n = -n; }
+  let lamps = rzLightsDiffuse(p, n);
+  let amb = rzWorldAmbient(n);
+  outF[o + 3u] = length(toEye);
+  outF[o + 4u] = aovSunShadow(p, n);
+  outF[o + 5u] = dot(n, aovToSun());
+  outF[o + 6u] = lamps.r;
+  outF[o + 7u] = lamps.g;
+  outF[o + 8u] = lamps.b;
+  outF[o + 9u] = amb.r;
+  outF[o + 10u] = amb.g;
+  outF[o + 11u] = amb.b;
+}
+`;
+export const AOV_PROBE_WGSL = /* wgsl */ `
+${PRELUDE}
+struct ProbePoint { p: vec4f, n: vec4f, }
+@group(0) @binding(7) var<storage, read> points: array<ProbePoint>;
+@group(0) @binding(8) var<storage, read_write> outF: array<f32>;
+
+@compute @workgroup_size(1)
+fn probe(@builtin(global_invocation_id) gid: vec3u) {
+  let i = gid.x;
+  if (i >= arrayLength(&points)) { return; }
+  let p = points[i].p.xyz;
+  let n = normalize(points[i].n.xyz);
+  let o = i * ${AOV_PROBE_STRIDE}u;
+  // Colour and strength travel apart in the light uniform (writeSun); the
+  // light arriving is their product.
+  let sun = _rzLight.lights[0].color.rgb * _rzLight.lights[0].color.w;
+  let amb = rzWorldAmbient(n);
+  outF[o] = aovSunShadow(p, n);
+  outF[o + 1u] = dot(n, aovToSun());
+  outF[o + 2u] = sun.r;
+  outF[o + 3u] = sun.g;
+  outF[o + 4u] = sun.b;
+  outF[o + 5u] = amb.r;
+  outF[o + 6u] = amb.g;
+  outF[o + 7u] = amb.b;
+  let count = rzLightCount();
+  outF[o + 8u] = f32(count);
+  // The document's lamps come first (setLights order); the rest are effects'.
+  outF[o + 9u] = f32(_rzLightDocCount());
+  for (var k = 10u; k < ${AOV_PROBE_HEAD}u; k++) { outF[o + k] = 0.0; }
+  for (var l = 0u; l < ${MAX_LIGHTS}u; l++) {
+    var c = vec3f(0.0);
+    if (l < count) { c = _rzLightOne(l, p, n); }
+    let b = o + ${AOV_PROBE_HEAD}u + l * 4u;
+    outF[b] = c.r;
+    outF[b + 1u] = c.g;
+    outF[b + 2u] = c.b;
+    outF[b + 3u] = 0.0;
+  }
+}
+`;

package/package.json

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