reze-engine 0.68.0 → 0.68.2

package/src/engine.ts

@@ -27,6 +27,7 @@ import {
 } 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, type ParamKey, type ParamValue } from "./param-track"
 import {
   advanceSim,
@@ -471,6 +472,38 @@ export type ModelTransform = {
 }
 
 /** How a model rides another — MMD's 外部親 (outside parent). See setModelParent. */
+/**
+ * The frame read back as numbers (Engine.readAovs). `data` holds `stride`
+ * floats per texel, row-major from the top-left, named by `fields`; `ids` one
+ * word per texel, material id in the low 16 bits and object id in the high
+ * (Engine.getIdLegend names them; 0 is nothing). Colour is LINEAR and before
+ * `exposure` (stops) is applied.
+ */
+export type SceneAovs = {
+  width: number
+  height: number
+  stride: number
+  fields: typeof AOV_PIXEL_FIELDS
+  data: Float32Array
+  ids: Uint32Array
+  exposure: number
+}
+
+/** The light arriving at one point (Engine.probeLight). Colours are linear
+ *  light, before the surface's albedo: the sun's is its colour times strength,
+ *  unshadowed and unfaced — multiply by sunShadow and max(sunFacing, 0). */
+export type LightProbe = {
+  sunShadow: number
+  sunFacing: number
+  sun: [number, number, number]
+  ambient: [number, number, number]
+  /** Each lamp's light here, in the engine's lamp order. */
+  lamps: [number, number, number][]
+  /** How many of `lamps` are the document's (setLights, non-directional, in
+   *  order); the rest an effect emits. */
+  documentLamps: number
+}
+
 export type ModelAttachment = {
   /** Model key of the parent. */
   model: string
@@ -967,6 +1000,10 @@ interface ModelInstance {
    * change reads as a glitch rather than as a cut.
    */
   simulateWhileHidden: boolean
+  /** The host's per-model switch over the shadow map — see setModelCastShadow.
+   *  Off drops every draw from the shadow list; on hands it back to the PMX
+   *  flag on each material. */
+  castShadow: boolean
   basePath: string
   assetReader: AssetReader
   gpuBuffers: GPUBuffer[]
@@ -2275,6 +2312,11 @@ export class Engine {
   private idDebugBindGroupLayout: GPUBindGroupLayout | null = null
   private idDebugBindGroup: GPUBindGroup | null = null
   private idDebug = false
+  /** Store ids and depth for readAovs — see setAovCapture. */
+  private aovCapture = false
+  private aovPixelsPipeline: GPUComputePipeline | null = null
+  private aovProbePipeline: GPUComputePipeline | null = null
+  private aovSampler: GPUSampler | null = null
   private multisampleMaskTexture!: GPUTexture
   private maskResolveTexture!: GPUTexture
   private maskResolveView!: GPUTextureView
@@ -3421,6 +3463,189 @@ export class Engine {
     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: boolean): boolean {
+    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(): { objectId: number; model: string; materials: { id: number; name: string }[] }[] {
+    const out: { objectId: number; model: string; materials: { id: number; name: string }[] }[] = []
+    for (const [name, inst] of this.modelInstances) {
+      const materials: { id: number; name: string }[] = []
+      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(): Promise<SceneAovs | null> {
+    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.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: readonly { position: { x: number; y: number; z: number }; normal: { x: number; y: number; z: number } }[]): Promise<LightProbe[]> {
+    if (points.length === 0) return []
+    const pipeline = 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: [number, number, number][] = []
+        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. */
+  private aovLightEntries(): GPUBindGroupEntry[] {
+    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. */
   private ensureIdDebugPipeline(): boolean {
@@ -7094,6 +7319,12 @@ 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(): number {
+    return this.effects.length
+  }
+
   setEffectInfluence(index: number, influence: number): void {
     const fx = this.effects[index]
     if (!fx) return
@@ -13482,6 +13713,27 @@ export class Engine {
     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: string, on: boolean): boolean {
+    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: string): boolean {
+    return this.modelInstances.get(modelName)?.castShadow ?? true
+  }
+
   getPhysicsFloor(): boolean {
     return this.physicsFloor
   }
@@ -13732,7 +13984,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".
@@ -14889,6 +15141,7 @@ export class Engine {
       name,
       model,
       simulateWhileHidden: false,
+      castShadow: true,
       basePath,
       assetReader,
       gpuBuffers,
@@ -17220,7 +17473,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()
 
@@ -17242,7 +17495,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"
     }
 
@@ -18265,9 +18518,9 @@ export class Engine {
     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/src/index.ts

@@ -23,6 +23,8 @@ export {
   RENDERING_LAYER_DEFAULT,
   RENDERING_LAYER_CHARACTER,
   type ModelAttachment,
+  type SceneAovs,
+  type LightProbe,
   type GizmoDragEvent,
   type GizmoDragCallback,
   type GizmoDragKind,
@@ -227,3 +229,5 @@ 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"

package/src/shaders/passes/aov.ts

@@ -0,0 +1,187 @@
+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
+] as const
+
+/** 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/dist/graph/presets/pool_floor.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const POOL_FLOOR_GRAPH: ShaderGraph;
-//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -1,42 +0,0 @@
-// Pool floor — the tiled bottom seen through water, with caustics on it.
-//
-// The other half of a pool, and the half that does most of the work. A water
-// surface can be tuned for a long time without the shot reading as a pool;
-// putting the focused-light web on the FLOOR is what settles it, because that
-// is the cue a photograph actually carries. It is a floor material, so it is
-// applied to the tile under the water rather than to the water itself.
-//
-// Caustics land between the albedo and the shading deliberately: they are
-// light, so they should still be dimmed by the floor's own shadow rather than
-// glowing through it. That is the difference between water-focused sun and a
-// decal.
-export const POOL_FLOOR_GRAPH = {
-    version: 1,
-    name: "Pool floor",
-    tags: ["stage", "water", "pool"],
-    nodes: [
-        { id: "tex", type: "texture" },
-        { id: "mat", type: "material_diffuse" },
-        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
-        { id: "caust", type: "caustics" },
-        {
-            id: "principled",
-            type: "principled",
-            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
-        },
-    ],
-    links: [
-        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
-        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
-        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
-        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
-    ],
-    output: { node: "principled", socket: "color" },
-    params: [
-        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
-        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
-        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
-        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
-        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
-    ],
-};

package/dist/graph/presets/water.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const WATER_GRAPH: ShaderGraph;
-//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -1,31 +0,0 @@
-// Water — a planar reflection, rippled, seen through Fresnel.
-//
-// Put a stage's water materials in a style group carrying this graph and the
-// pool starts reflecting. The reflection itself is the engine's mirror pass,
-// which this is the only graph to read; everything else here is the shaping
-// that keeps it from reading as a mirror laid flat in the floor.
-//
-// The exposed params are the ones worth a slider while judging a shot. Scale
-// and speed are the ripple; a real pool's surface is slow and broad, so both
-// defaults sit low. Tint is the water's own colour — a game rip carries that
-// in its material, and the converter hands it straight over.
-//
-// How see-through the water is belongs to the MATERIAL's alpha, not to this
-// graph, which is where every other group's coverage comes from too.
-export const WATER_GRAPH = {
-    version: 1,
-    name: "Water",
-    tags: ["water", "stage"],
-    nodes: [{ id: "water", type: "water" }],
-    links: [],
-    output: { node: "water", socket: "color" },
-    params: [
-        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
-        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
-        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
-        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
-        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
-        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
-        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
-    ],
-};