@aethervtt/shard-render 0.0.1

package/dist/post-nodes.js

@@ -0,0 +1,849 @@
+import {
+  defineResource,
+  defineSystem,
+  mat4,
+  ProfilerResource
+} from "@aethervtt/shard-core";
+import { Time } from "@aethervtt/shard-runtime";
+import { Exposure } from "./camera.js";
+import { drawMaterials, ForwardStateResource, PASS_PREPASS, viewBindGroup } from "./forward.js";
+import { RenderPhase } from "./graph.js";
+import { Graph, Views } from "./plugin.js";
+import { AutoExposure, cocParams, hasEffect, needsPrepass, PostEffect } from "./post.js";
+import {
+  beginPass,
+  forwardView,
+  HDR,
+  idOf,
+  PostCache,
+  sampler,
+  scratch,
+  tex,
+  uniform
+} from "./post-common.js";
+import { RenderCounters } from "./stats.js";
+import { cameraOf } from "./view.js";
+const prepassNode = {
+  kind: "render",
+  phase: RenderPhase.Prepass,
+  enabled: needsPrepass,
+  reads: ["culled"],
+  writes: ["prepass-normal", "velocity", "prepass-depth"],
+  color: [
+    { resource: "prepass-normal", clear: { r: 0, g: 0, b: 0, a: 0 } },
+    { resource: "velocity", clear: { r: 0, g: 0, b: 0, a: 0 } }
+  ],
+  depth: { resource: "prepass-depth", clear: 0 },
+  run: (ctx) => {
+    const v = forwardView(ctx);
+    if (!v) return;
+    const state = ctx.world.resource(ForwardStateResource);
+    drawMaterials(ctx, state, v.pv, v.cam, v.cam.draws, PASS_PREPASS);
+    if (v.cam.deferred) drawMaterials(ctx, state, v.pv, v.cam, v.cam.forwardOnly, PASS_PREPASS);
+  }
+};
+const SSAO_STEPS = [
+  [1, 4],
+  [2, 4],
+  [3, 6]
+];
+const invProj = mat4.create();
+function ssaoNode(phase, deferred) {
+  const cache = new PostCache();
+  let layouts;
+  let layoutGen = -1;
+  return {
+    kind: "raw",
+    phase,
+    enabled: (view) => {
+      const cam = cameraOf(view);
+      return cam !== void 0 && cam.deferred === deferred && (cam.post.effects & PostEffect.Ssao) !== 0;
+    },
+    reads: ["ssao-normal", "ssao-depth"],
+    writes: ["ssao", "ssao-half"],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      if (!layouts || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layouts = {
+          gtao: gpu.layouts.bindGroupLayout({
+            label: "ssao/gtao",
+            entries: [uniform(0), tex(1, "depth"), tex(2, "unfilterable-float"), uniform(3)]
+          }),
+          up: gpu.layouts.bindGroupLayout({
+            label: "ssao/upsample",
+            entries: [uniform(0), tex(1, "depth"), uniform(3), tex(4, "unfilterable-float")]
+          })
+        };
+      }
+      const gtao = cache.render(
+        ctx,
+        "ssao/gtao",
+        "shard::post::ssao",
+        "gtao",
+        [layouts.gtao],
+        [{ format: "rg16float" }]
+      );
+      const up = cache.render(
+        ctx,
+        "ssao/upsample",
+        "shard::post::ssao",
+        "upsample",
+        [layouts.up],
+        [{ format: "r8unorm" }]
+      );
+      if (!gtao || !up) return;
+      const { cam, pv } = v;
+      const s = cam.post.ssao;
+      const steps = SSAO_STEPS[s.quality] ?? SSAO_STEPS[1];
+      scratch[0] = s.radius;
+      scratch[1] = s.intensity;
+      scratch[2] = steps[0];
+      scratch[3] = steps[1];
+      scratch[4] = cam.proj[5] * cam.height * 0.5;
+      scratch[5] = scratch[6] = scratch[7] = 0;
+      mat4.invert(invProj, cam.proj);
+      scratch.set(invProj, 8);
+      const params = cache.buffer(gpu, `${ctx.view.name}/ssao`, 96);
+      params.write(scratch, 0, 0, 24);
+      const depth = ctx.texture("ssao-depth");
+      const normal = ctx.texture("ssao-normal");
+      const half = ctx.texture("ssao-half");
+      const out = ctx.texture("ssao");
+      const g1 = cache.group(
+        gpu,
+        `${ctx.view.name}/gtao`,
+        `${idOf(depth)}/${idOf(normal)}/${pv.uniform.version}/${params.version}`,
+        layouts.gtao,
+        () => [
+          { binding: 0, resource: { buffer: pv.uniform.buffer } },
+          { binding: 1, resource: depth.createView() },
+          { binding: 2, resource: normal.createView() },
+          { binding: 3, resource: { buffer: params.buffer } }
+        ]
+      );
+      let pass = beginPass(ctx, "ssao", half.createView());
+      pass.setPipeline(gtao);
+      pass.setBindGroup(0, g1);
+      pass.draw(3);
+      pass.end();
+      const g2 = cache.group(
+        gpu,
+        `${ctx.view.name}/ssao-up`,
+        `${idOf(depth)}/${idOf(half)}/${pv.uniform.version}/${params.version}`,
+        layouts.up,
+        () => [
+          { binding: 0, resource: { buffer: pv.uniform.buffer } },
+          { binding: 1, resource: depth.createView() },
+          { binding: 3, resource: { buffer: params.buffer } },
+          { binding: 4, resource: half.createView() }
+        ]
+      );
+      pass = beginPass(ctx, "ssao/upsample", out.createView());
+      pass.setPipeline(up);
+      pass.setBindGroup(0, g2);
+      pass.draw(3);
+      pass.end();
+      pv.ao = out;
+    }
+  };
+}
+function fogNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  return {
+    kind: "render",
+    phase: RenderPhase.Post,
+    enabled: hasEffect(PostEffect.Fog),
+    reads: ["fog-in", "depth", "environment", "clusters"],
+    writes: ["fog-out"],
+    color: [{ resource: "fog-out", clear: { r: 0, g: 0, b: 0, a: 1 } }],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      const state = ctx.world.resource(ForwardStateResource);
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "fog",
+          entries: [tex(0, "unfilterable-float"), tex(1, "depth"), uniform(2)]
+        });
+      }
+      const pipeline = cache.render(
+        ctx,
+        "post/fog",
+        "shard::post::fog",
+        "fs",
+        [state.layouts.view, layout],
+        HDR
+      );
+      if (!pipeline) return;
+      const f = v.cam.post.fog;
+      scratch.set(f.color, 0);
+      scratch[4] = f.density;
+      scratch[5] = f.heightFalloff;
+      scratch[6] = f.start;
+      scratch[7] = f.sunScattering;
+      const params = cache.buffer(gpu, `${ctx.view.name}/fog`, 32);
+      params.write(scratch, 0, 0, 8);
+      const input = ctx.texture("fog-in");
+      const depth = ctx.texture("depth");
+      const group = cache.group(
+        gpu,
+        `${ctx.view.name}/fog`,
+        `${idOf(input)}/${idOf(depth)}/${params.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: input.createView() },
+          { binding: 1, resource: depth.createView() },
+          { binding: 2, resource: { buffer: params.buffer } }
+        ]
+      );
+      const pass = ctx.renderPass;
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, viewBindGroup(gpu, ctx.world, v.pv, v.cam));
+      pass.setBindGroup(1, group);
+      pass.draw(3);
+    }
+  };
+}
+function taaNode() {
+  const cache = new PostCache();
+  const histories = /* @__PURE__ */ new Map();
+  let layout;
+  let layoutGen = -1;
+  return {
+    kind: "raw",
+    phase: RenderPhase.Post + 10,
+    enabled: hasEffect(PostEffect.Taa),
+    reads: ["taa-in", "depth", "velocity"],
+    writes: ["taa-out"],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "taa",
+          entries: [
+            uniform(0),
+            tex(1, "unfilterable-float"),
+            tex(2, "depth"),
+            tex(3, "unfilterable-float"),
+            tex(4),
+            sampler(5),
+            uniform(6)
+          ]
+        });
+        histories.clear();
+      }
+      const pipeline = cache.render(
+        ctx,
+        "post/taa",
+        "shard::post::taa",
+        "fs",
+        [layout],
+        [{ format: "rgba16float" }, { format: "rgba16float" }]
+      );
+      if (!pipeline) return;
+      const input = ctx.texture("taa-in");
+      const out = ctx.texture("taa-out");
+      let h = histories.get(ctx.view.name);
+      if (!h || h.generation !== gpu.generation || h.textures[0].width !== input.width || h.textures[0].height !== input.height) {
+        for (const t of h?.textures ?? []) t.destroy();
+        const make = (i) => gpu.device.createTexture({
+          label: `${ctx.view.name}/taa-history-${i}`,
+          size: [input.width, input.height],
+          format: "rgba16float",
+          usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+        });
+        h = { textures: [make(0), make(1)], index: 0, valid: false, generation: gpu.generation };
+        histories.set(ctx.view.name, h);
+      }
+      if (v.cam.frames === 1) h.valid = false;
+      const read = h.textures[h.index];
+      const write = h.textures[1 - h.index];
+      scratch[0] = 0.1;
+      scratch[1] = h.valid ? 0 : 1;
+      if (!h.valid) ctx.world.initResource(RenderCounters).taaResets++;
+      scratch[2] = scratch[3] = 0;
+      const params = cache.buffer(gpu, `${ctx.view.name}/taa`, 16);
+      params.write(scratch, 0, 0, 4);
+      const depth = ctx.texture("depth");
+      const velocity = ctx.texture("velocity");
+      const group = cache.group(
+        gpu,
+        `${ctx.view.name}/taa/${h.index}`,
+        `${idOf(input)}/${idOf(depth)}/${idOf(velocity)}/${idOf(read)}/${v.pv.uniform.version}/${params.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
+          { binding: 1, resource: input.createView() },
+          { binding: 2, resource: depth.createView() },
+          { binding: 3, resource: velocity.createView() },
+          { binding: 4, resource: read.createView() },
+          { binding: 5, resource: cache.sampler(gpu) },
+          { binding: 6, resource: { buffer: params.buffer } }
+        ]
+      );
+      const pass = ctx.encoder.beginRenderPass({
+        label: `${ctx.view.name}/taa`,
+        colorAttachments: [
+          { view: out.createView(), loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 1] },
+          { view: write.createView(), loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 1] }
+        ],
+        timestampWrites: ctx.timestamps("post/taa")
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, group);
+      pass.draw(3);
+      pass.end();
+      h.index = 1 - h.index;
+      h.valid = true;
+    }
+  };
+}
+function motionBlurNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  return {
+    kind: "render",
+    phase: RenderPhase.Post + 20,
+    enabled: hasEffect(PostEffect.MotionBlur),
+    reads: ["motion-blur-in", "depth", "velocity"],
+    writes: ["motion-blur-out"],
+    color: [{ resource: "motion-blur-out", clear: { r: 0, g: 0, b: 0, a: 1 } }],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "motion-blur",
+          entries: [
+            uniform(0),
+            tex(1),
+            tex(2, "depth"),
+            tex(3, "unfilterable-float"),
+            uniform(4),
+            sampler(5)
+          ]
+        });
+      }
+      const pipeline = cache.render(
+        ctx,
+        "post/motion-blur",
+        "shard::post::motion_blur",
+        "fs",
+        [layout],
+        HDR
+      );
+      if (!pipeline) return;
+      const m = v.cam.post.motionBlur;
+      scratch[0] = m.shutter;
+      scratch[1] = m.maxBlur * v.cam.height;
+      scratch[2] = m.samples;
+      scratch[3] = 0;
+      const params = cache.buffer(gpu, `${ctx.view.name}/motion-blur`, 16);
+      params.write(scratch, 0, 0, 4);
+      const input = ctx.texture("motion-blur-in");
+      const depth = ctx.texture("depth");
+      const velocity = ctx.texture("velocity");
+      const group = cache.group(
+        gpu,
+        `${ctx.view.name}/motion-blur`,
+        `${idOf(input)}/${idOf(depth)}/${idOf(velocity)}/${v.pv.uniform.version}/${params.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
+          { binding: 1, resource: input.createView() },
+          { binding: 2, resource: depth.createView() },
+          { binding: 3, resource: velocity.createView() },
+          { binding: 4, resource: { buffer: params.buffer } },
+          { binding: 5, resource: cache.sampler(gpu) }
+        ]
+      );
+      const pass = ctx.renderPass;
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, group);
+      pass.draw(3);
+    }
+  };
+}
+function dofNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  const cocScratch = new Float32Array(4);
+  return {
+    kind: "raw",
+    phase: RenderPhase.Post + 30,
+    enabled: hasEffect(PostEffect.DepthOfField),
+    reads: ["dof-in", "depth"],
+    writes: ["dof-out", "dof-half", "dof-blur"],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "dof",
+          entries: [uniform(0), tex(1), tex(2, "depth"), uniform(3), tex(4), sampler(5)]
+        });
+      }
+      const prepare = cache.render(ctx, "dof/prepare", "shard::post::dof", "prepare", [layout], HDR);
+      const gather = cache.render(ctx, "dof/gather", "shard::post::dof", "gather", [layout], HDR);
+      const composite = cache.render(
+        ctx,
+        "dof/composite",
+        "shard::post::dof",
+        "composite",
+        [layout],
+        HDR
+      );
+      if (!prepare || !gather || !composite) return;
+      const params = cache.buffer(gpu, `${ctx.view.name}/dof`, 16);
+      params.write(cocParams(v.cam, cocScratch));
+      const input = ctx.texture("dof-in");
+      const depth = ctx.texture("depth");
+      const half = ctx.texture("dof-half");
+      const blur = ctx.texture("dof-blur");
+      const out = ctx.texture("dof-out");
+      const group = (slot, secondary) => cache.group(
+        gpu,
+        `${ctx.view.name}/dof/${slot}`,
+        `${idOf(input)}/${idOf(depth)}/${idOf(secondary)}/${v.pv.uniform.version}/${params.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
+          { binding: 1, resource: input.createView() },
+          { binding: 2, resource: depth.createView() },
+          { binding: 3, resource: { buffer: params.buffer } },
+          { binding: 4, resource: secondary.createView() },
+          { binding: 5, resource: cache.sampler(gpu) }
+        ]
+      );
+      const run = (name, pipeline, target, bound) => {
+        const pass = beginPass(ctx, name, target.createView());
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, group(name, bound));
+        pass.draw(3);
+        pass.end();
+      };
+      run("post/dof", prepare, half, blur);
+      run("post/dof-gather", gather, blur, half);
+      run("post/dof-composite", composite, out, blur);
+    }
+  };
+}
+function bloomLevels(cam) {
+  const max = Math.max(1, Math.floor(Math.log2(Math.min(cam.width, cam.height) / 2)) - 1);
+  return Math.max(1, Math.min(max, Math.round(3 + cam.post.bloom.radius * (max - 3))));
+}
+function bloomNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  const params = new Float32Array(64 * 20);
+  return {
+    kind: "raw",
+    phase: RenderPhase.Post + 40,
+    enabled: hasEffect(PostEffect.Bloom),
+    reads: ["bloom-in"],
+    writes: ["bloom-out", "bloom"],
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "bloom",
+          entries: [tex(0), sampler(1), uniform(2), tex(3, "unfilterable-float")]
+        });
+      }
+      const add = { srcFactor: "one", dstFactor: "one", operation: "add" };
+      const prefilter = cache.render(
+        ctx,
+        "bloom/prefilter",
+        "shard::post::bloom",
+        "prefilter",
+        [layout],
+        HDR
+      );
+      const down = cache.render(
+        ctx,
+        "bloom/downsample",
+        "shard::post::bloom",
+        "downsample",
+        [layout],
+        HDR
+      );
+      const up = cache.render(
+        ctx,
+        "bloom/upsample",
+        "shard::post::bloom",
+        "upsample",
+        [layout],
+        [{ format: "rgba16float", blend: { color: add, alpha: add } }]
+      );
+      const composite = cache.render(
+        ctx,
+        "bloom/composite",
+        "shard::post::bloom",
+        "composite",
+        [layout],
+        HDR
+      );
+      if (!prefilter || !down || !up || !composite) return;
+      const { cam } = v;
+      const b = cam.post.bloom;
+      const input = ctx.texture("bloom-in");
+      const chain = ctx.texture("bloom");
+      const out = ctx.texture("bloom-out");
+      const levels = Math.min(chain.mipLevelCount, bloomLevels(cam));
+      const buffer = cache.buffer(gpu, `${ctx.view.name}/bloom`, 256 * 20);
+      const slot = (i2, w, h) => {
+        const o = i2 * 64;
+        params[o] = b.threshold * cam.exposure;
+        params[o + 1] = b.knee * b.threshold * cam.exposure;
+        params[o + 2] = 1 / w;
+        params[o + 3] = 1 / h;
+        params[o + 4] = b.intensity;
+        params[o + 5] = levels;
+        params[o + 6] = b.threshold > 0 ? 0 : 1;
+        params[o + 7] = 0;
+      };
+      const mipSize = (k) => [Math.max(1, chain.width >> k), Math.max(1, chain.height >> k)];
+      let n = 0;
+      slot(n++, input.width, input.height);
+      for (let k = 1; k < levels; k++) slot(n++, ...mipSize(k - 1));
+      for (let k = levels - 2; k >= 0; k--) slot(n++, ...mipSize(k + 1));
+      slot(n++, chain.width, chain.height);
+      buffer.write(params, 0, 0, n * 64);
+      const view = (k) => chain.createView({ baseMipLevel: k, mipLevelCount: 1 });
+      const group = (i2, source, mip) => cache.group(
+        gpu,
+        `${ctx.view.name}/bloom/${i2}`,
+        `${idOf(source)}/${mip}/${idOf(input)}/${buffer.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: source === chain ? view(mip) : source.createView() },
+          { binding: 1, resource: cache.sampler(gpu) },
+          { binding: 2, resource: { buffer: buffer.buffer, offset: i2 * 256, size: 32 } },
+          { binding: 3, resource: input.createView() }
+        ]
+      );
+      let i = 0;
+      const draw = (name, pipeline, target, source, mip, load = false) => {
+        const pass = beginPass(ctx, name, target, load);
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, group(i++, source, mip));
+        pass.draw(3);
+        pass.end();
+      };
+      draw("post/bloom", prefilter, view(0), input, 0);
+      for (let k = 1; k < levels; k++) draw("post/bloom-down", down, view(k), chain, k - 1);
+      for (let k = levels - 2; k >= 0; k--) draw("post/bloom-up", up, view(k), chain, k + 1, true);
+      draw("post/bloom-composite", composite, out.createView(), chain, 0);
+    }
+  };
+}
+const METER_READBACKS = 3;
+const ExposureMeters = defineResource("render/ExposureMeters", {
+  description: "Auto exposure per camera: the last metered EV100 and the adapted one.",
+  init: () => /* @__PURE__ */ new Map()
+});
+const METER_MIN_EV = -8;
+const METER_BINS_PER_EV = 8;
+const METER_BYTES = 256 * 4;
+function histogramEv(bins) {
+  let total = 0;
+  for (let i = 0; i < bins.length; i++) total += bins[i];
+  if (total === 0) return void 0;
+  const lo = total * 0.1;
+  const hi = total * 0.98;
+  let seen = 0;
+  let sum = 0;
+  let weight = 0;
+  for (let i = 0; i < bins.length; i++) {
+    const n = bins[i];
+    const a = Math.max(seen, lo);
+    const b = Math.min(seen + n, hi);
+    if (b > a) {
+      sum += (b - a) * (METER_MIN_EV + (i + 0.5) / METER_BINS_PER_EV);
+      weight += b - a;
+    }
+    seen += n;
+  }
+  return weight > 0 ? sum / weight : void 0;
+}
+function autoExposureNode() {
+  const cache = new PostCache();
+  let layout;
+  let layoutGen = -1;
+  const perView = /* @__PURE__ */ new Map();
+  const zero = new Uint32Array(256);
+  return {
+    kind: "raw",
+    phase: RenderPhase.Post + 50,
+    enabled: hasEffect(PostEffect.AutoExposure),
+    reads: ["post-hdr"],
+    sideEffects: true,
+    run: (ctx) => {
+      const v = forwardView(ctx);
+      if (!v) return;
+      const gpu = ctx.gpu;
+      const C = GPUShaderStage.COMPUTE;
+      if (!layout || layoutGen !== gpu.generation) {
+        layoutGen = gpu.generation;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "exposure",
+          entries: [
+            uniform(0, C),
+            { binding: 1, visibility: C, texture: { sampleType: "unfilterable-float" } },
+            { binding: 2, visibility: C, buffer: { type: "storage" } },
+            uniform(3, C)
+          ]
+        });
+        perView.clear();
+      }
+      const pipeline = cache.compute(ctx, "post/exposure", "shard::post::exposure", "meter", [
+        layout
+      ]);
+      if (!pipeline) return;
+      let state = perView.get(ctx.view.name);
+      if (!state || state.generation !== gpu.generation) {
+        state = {
+          histogram: gpu.device.createBuffer({
+            label: `${ctx.view.name}/exposure-histogram`,
+            size: METER_BYTES,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+          }),
+          readbacks: Array.from(
+            { length: METER_READBACKS },
+            (_, i) => gpu.device.createBuffer({
+              label: `${ctx.view.name}/exposure-readback-${i}`,
+              size: METER_BYTES,
+              usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+            })
+          ),
+          busy: Array.from({ length: METER_READBACKS }, () => false),
+          generation: gpu.generation
+        };
+        perView.set(ctx.view.name, state);
+      }
+      const e = v.cam.post.exposure;
+      scratch[0] = METER_MIN_EV;
+      scratch[1] = METER_BINS_PER_EV;
+      scratch[2] = e.metering;
+      scratch[3] = 0;
+      const params = cache.buffer(gpu, `${ctx.view.name}/exposure`, 16);
+      params.write(scratch, 0, 0, 4);
+      const input = ctx.texture("post-hdr");
+      const histogram = state.histogram;
+      const group = cache.group(
+        gpu,
+        `${ctx.view.name}/exposure`,
+        `${idOf(input)}/${idOf(histogram)}/${v.pv.uniform.version}/${params.version}`,
+        layout,
+        () => [
+          { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
+          { binding: 1, resource: input.createView() },
+          { binding: 2, resource: { buffer: histogram } },
+          { binding: 3, resource: { buffer: params.buffer } }
+        ]
+      );
+      gpu.device.queue.writeBuffer(histogram, 0, zero);
+      const pass = ctx.encoder.beginComputePass({
+        label: `${ctx.view.name}/exposure`,
+        timestampWrites: ctx.timestamps("post/exposure")
+      });
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, group);
+      pass.dispatchWorkgroups(Math.ceil(input.width / 64), Math.ceil(input.height / 64));
+      pass.end();
+      const k = state.busy.indexOf(false);
+      if (k < 0) return;
+      const readback = state.readbacks[k];
+      ctx.encoder.copyBufferToBuffer(histogram, 0, readback, 0, METER_BYTES);
+      state.busy[k] = true;
+      const busy = state.busy;
+      const meters = ctx.world.resource(ExposureMeters);
+      const entity = v.cam.entity;
+      const meter = meters.get(entity);
+      const index = meter ? ++meter.submitted : 0;
+      ctx.afterSubmit(() => {
+        readback.mapAsync(GPUMapMode.READ).then(
+          () => {
+            const ev = histogramEv(new Uint32Array(readback.getMappedRange().slice(0)));
+            readback.unmap();
+            busy[k] = false;
+            const m = meters.get(entity);
+            if (m && ev !== void 0 && index > m.reading) {
+              m.metered = ev;
+              m.reading = index;
+              m.readings++;
+            }
+          },
+          () => {
+            busy[k] = false;
+          }
+        );
+      });
+    }
+  };
+}
+const adaptExposure = defineSystem({
+  name: "render/auto-exposure",
+  description: "Adapts Exposure.ev100 of AutoExposure cameras toward their metered brightness.",
+  setup: (world) => ({ q: world.query({ with: [AutoExposure, Exposure] }) }),
+  run: ({ q }, world) => {
+    const meters = world.resource(ExposureMeters);
+    const dt = world.resource(Time).delta;
+    for (const table of q.tables) {
+      const ev = table.column(Exposure, "ev100");
+      const minEv = table.column(AutoExposure, "minEv");
+      const maxEv = table.column(AutoExposure, "maxEv");
+      const comp = table.column(AutoExposure, "compensation");
+      const upSpeed = table.column(AutoExposure, "speedUp");
+      const downSpeed = table.column(AutoExposure, "speedDown");
+      for (let i = 0; i < table.count; i++) {
+        const entity = table.entities[i];
+        let m = meters.get(entity);
+        if (!m) {
+          m = {
+            metered: void 0,
+            readings: 0,
+            submitted: 0,
+            reading: 0,
+            ev: ev[i],
+            started: true
+          };
+          meters.set(entity, m);
+        }
+        if (m.metered !== void 0) {
+          const target = Math.min(maxEv[i], Math.max(minEv[i], m.metered - comp[i]));
+          const speed = target > m.ev ? upSpeed[i] : downSpeed[i];
+          const step = speed * dt;
+          const d = target - m.ev;
+          m.ev += Math.abs(d) <= step ? d : Math.sign(d) * step;
+        }
+        ev[i] = m.ev;
+      }
+      table.markChanged(Exposure);
+    }
+  }
+});
+const POST_NODES = [
+  ["post/fog", PostEffect.Fog],
+  ["post/taa", PostEffect.Taa],
+  ["post/motion-blur", PostEffect.MotionBlur],
+  ["post/dof", PostEffect.DepthOfField],
+  ["post/bloom", PostEffect.Bloom],
+  ["post/exposure", PostEffect.AutoExposure],
+  ["post/fxaa", PostEffect.Fxaa]
+];
+const halfSize = { divide: 2 };
+function addPostNodes(world) {
+  const graph = world.resource(Graph);
+  world.initResource(ExposureMeters);
+  graph.declare({ name: "prepass-normal", format: "rgba16float" });
+  graph.declare({ name: "velocity", format: "rg16float" });
+  graph.declare({ name: "prepass-depth", format: "depth32float" });
+  graph.declare({ name: "ssao", format: "r8unorm" });
+  graph.declare({ name: "ssao-half", format: "rg16float", size: halfSize });
+  graph.declare({ name: "post-a", format: "rgba16float" });
+  graph.declare({ name: "post-b", format: "rgba16float" });
+  graph.declare({ name: "dof-half", format: "rgba16float", size: halfSize });
+  graph.declare({ name: "dof-blur", format: "rgba16float", size: halfSize });
+  graph.declare({
+    name: "bloom",
+    format: "rgba16float",
+    size: halfSize,
+    mipLevelCount: (view) => {
+      const cam = cameraOf(view);
+      return cam ? bloomLevels(cam) : 1;
+    }
+  });
+  graph.addNode("prepass", prepassNode);
+  graph.addNode("ssao", ssaoNode(RenderPhase.Prepass + 50, false));
+  graph.addNode("ssao-deferred", ssaoNode(RenderPhase.Opaque + 20, true));
+  graph.addNode("post/fog", fogNode());
+  graph.addNode("post/taa", taaNode());
+  graph.addNode("post/motion-blur", motionBlurNode());
+  graph.addNode("post/dof", dofNode());
+  graph.addNode("post/bloom", bloomNode());
+  graph.addNode("post/exposure", autoExposureNode());
+}
+const DESCRIBED = [
+  ["ssao", "ssao", PostEffect.Ssao],
+  ["fog", "post/fog", PostEffect.Fog],
+  ["taa", "post/taa", PostEffect.Taa],
+  ["motion-blur", "post/motion-blur", PostEffect.MotionBlur],
+  ["dof", "post/dof", PostEffect.DepthOfField],
+  ["bloom", "post/bloom", PostEffect.Bloom],
+  ["auto-exposure", "post/exposure", PostEffect.AutoExposure],
+  ["color-grading", "tonemap", PostEffect.Grading],
+  ["vignette", "tonemap", PostEffect.Vignette],
+  ["fxaa", "post/fxaa", PostEffect.Fxaa]
+];
+function gpuMs(timings, prefix) {
+  let total;
+  const key = `gpu:${prefix}`;
+  for (const name in timings) {
+    if (name === key || name.startsWith(`${key}-`) || name.startsWith(`${key}/`)) {
+      total = (total ?? 0) + timings[name].avg;
+    }
+  }
+  return total;
+}
+function describePost(world) {
+  const profiler = world.tryResource(ProfilerResource);
+  const timings = profiler?.all() ?? {};
+  const meters = world.tryResource(ExposureMeters);
+  const views = {};
+  for (const view of world.resource(Views).list) {
+    const cam = cameraOf(view);
+    if (!cam) continue;
+    const effects = [];
+    for (const [name, node, bit] of DESCRIBED) {
+      if ((cam.post.effects & bit) === 0) continue;
+      const shared = node === "tonemap";
+      effects.push({ name, gpuMs: shared ? void 0 : gpuMs(timings, node) });
+    }
+    const meter = meters?.get(cam.entity);
+    views[view.name] = {
+      effects,
+      antialiasing: cam.post.effects & PostEffect.Taa ? "taa" : cam.post.effects & PostEffect.Fxaa ? "fxaa" : cam.msaa > 1 ? `msaa x${cam.msaa}` : "none",
+      prepass: needsPrepass(view),
+      ev100: cam.ev100,
+      meteredEv100: meter?.metered,
+      // Per-pass times overlap on tile-based GPUs; these spans don't.
+      gpuMs: {
+        prepass: timings["gpu:prepass"]?.avg,
+        ssao: timings["gpu:span/ssao"]?.avg,
+        post: timings["gpu:span/post"]?.avg
+      }
+    };
+  }
+  return { views };
+}
+export {
+  ExposureMeters,
+  METER_READBACKS,
+  POST_NODES,
+  adaptExposure,
+  addPostNodes,
+  bloomLevels,
+  describePost,
+  histogramEv
+};