@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/post-nodes.js

@@ -6,18 +6,23 @@ import {
 } from "@aethervtt/shard-core";
 import { Time } from "@aethervtt/shard-runtime";
 import { Exposure } from "./camera.js";
+import { addRenderFeatures } from "./features.js";
 import { drawMaterials, ForwardStateResource, PASS_PREPASS, viewBindGroup } from "./forward.js";
 import { RenderPhase } from "./graph.js";
-import { Graph, Views } from "./plugin.js";
+import { Gpu, Graph, Views } from "./plugin.js";
 import { AutoExposure, cocParams, hasEffect, needsPrepass, PostEffect } from "./post.js";
 import {
   beginPass,
+  depthTex,
   forwardView,
   HDR,
   idOf,
   PostCache,
+  postFormat,
+  roundsRg11,
   sampler,
   scratch,
+  targetsFor,
   tex,
   uniform
 } from "./post-common.js";
@@ -42,6 +47,16 @@ const prepassNode = {
     if (v.cam.deferred) drawMaterials(ctx, state, v.pv, v.cam, v.cam.forwardOnly, PASS_PREPASS);
   }
 };
+const FOG_KEYS = [
+  "post/fog",
+  "post/fog/alpha",
+  "post/fog/interior",
+  "post/fog/alpha/interior",
+  "post/fog/rg11",
+  "post/fog/alpha/rg11",
+  "post/fog/interior/rg11",
+  "post/fog/alpha/interior/rg11"
+];
 const SSAO_STEPS = [
   [1, 4],
   [2, 4],
@@ -50,7 +65,7 @@ const SSAO_STEPS = [
 const invProj = mat4.create();
 function ssaoNode(phase, deferred) {
   const cache = new PostCache();
-  let layouts;
+  let layout;
   let layoutGen = -1;
   return {
     kind: "raw",
@@ -60,41 +75,27 @@ function ssaoNode(phase, deferred) {
       return cam !== void 0 && cam.deferred === deferred && (cam.post.effects & PostEffect.Ssao) !== 0;
     },
     reads: ["ssao-normal", "ssao-depth"],
-    writes: ["ssao", "ssao-half"],
+    writes: ["ssao"],
     run: (ctx) => {
       const v = forwardView(ctx);
       if (!v) return;
       const gpu = ctx.gpu;
-      if (!layouts || layoutGen !== gpu.generation) {
+      if (!layout || 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")]
-          })
-        };
+        layout = gpu.layouts.bindGroupLayout({
+          label: "ssao/gtao",
+          entries: [uniform(0), depthTex(gpu, 1), tex(2, "unfilterable-float"), uniform(3)]
+        });
       }
       const gtao = cache.render(
         ctx,
         "ssao/gtao",
         "shard::post::ssao",
         "gtao",
-        [layouts.gtao],
+        [layout],
         [{ format: "rg16float" }]
       );
-      const up = cache.render(
-        ctx,
-        "ssao/upsample",
-        "shard::post::ssao",
-        "upsample",
-        [layouts.up],
-        [{ format: "r8unorm" }]
-      );
-      if (!gtao || !up) return;
+      if (!gtao) return;
       const { cam, pv } = v;
       const s = cam.post.ssao;
       const steps = SSAO_STEPS[s.quality] ?? SSAO_STEPS[1];
@@ -110,13 +111,12 @@ function ssaoNode(phase, deferred) {
       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(
+      const group = cache.group(
         gpu,
         `${ctx.view.name}/gtao`,
         `${idOf(depth)}/${idOf(normal)}/${pv.uniform.version}/${params.version}`,
-        layouts.gtao,
+        layout,
         () => [
           { binding: 0, resource: { buffer: pv.uniform.buffer } },
           { binding: 1, resource: depth.createView() },
@@ -124,26 +124,9 @@ function ssaoNode(phase, deferred) {
           { binding: 3, resource: { buffer: params.buffer } }
         ]
       );
-      let pass = beginPass(ctx, "ssao", half.createView());
+      const pass = beginPass(ctx, "ssao", out.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.setBindGroup(0, group);
       pass.draw(3);
       pass.end();
       pv.ao = out;
@@ -157,7 +140,8 @@ function fogNode() {
   return {
     kind: "render",
     phase: RenderPhase.Post,
-    enabled: hasEffect(PostEffect.Fog),
+    // With aerial perspective, the atmosphere's composite applies fog in its own pass.
+    enabled: (view) => ((cameraOf(view)?.post.effects ?? 0) & (PostEffect.Fog | PostEffect.Atmosphere)) === PostEffect.Fog,
     reads: ["fog-in", "depth", "environment", "clusters"],
     writes: ["fog-out"],
     color: [{ resource: "fog-out", clear: { r: 0, g: 0, b: 0, a: 1 } }],
@@ -170,16 +154,20 @@ function fogNode() {
         layoutGen = gpu.generation;
         layout = gpu.layouts.bindGroupLayout({
           label: "fog",
-          entries: [tex(0, "unfilterable-float"), tex(1, "depth"), uniform(2)]
+          entries: [tex(0, "unfilterable-float"), depthTex(gpu, 1), uniform(2)]
         });
       }
+      const alpha = v.cam.alphaOutput;
+      const out = ctx.texture("fog-out");
+      const rg11 = out.format === "rg11b10ufloat";
       const pipeline = cache.render(
         ctx,
-        "post/fog",
+        FOG_KEYS[(alpha ? 1 : 0) + (state.interiorMode !== 0 ? 2 : 0) + (rg11 ? 4 : 0)],
         "shard::post::fog",
         "fs",
         [state.layouts.view, layout],
-        HDR
+        targetsFor(out),
+        { TRANSPARENT: alpha, RG11_ROUND: roundsRg11(gpu, out) }
       );
       if (!pipeline) return;
       const f = v.cam.post.fog;
@@ -233,7 +221,7 @@ function taaNode() {
           entries: [
             uniform(0),
             tex(1, "unfilterable-float"),
-            tex(2, "depth"),
+            depthTex(gpu, 2),
             tex(3, "unfilterable-float"),
             tex(4),
             sampler(5),
@@ -242,17 +230,18 @@ function taaNode() {
         });
         histories.clear();
       }
+      const alpha = cameraOf(ctx.view)?.alphaOutput === true;
       const pipeline = cache.render(
         ctx,
-        "post/taa",
+        alpha ? "post/taa/alpha" : "post/taa",
         "shard::post::taa",
         "fs",
         [layout],
-        [{ format: "rgba16float" }, { format: "rgba16float" }]
+        HDR,
+        { TRANSPARENT: alpha }
       );
       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();
@@ -260,7 +249,7 @@ function taaNode() {
           label: `${ctx.view.name}/taa-history-${i}`,
           size: [input.width, input.height],
           format: "rgba16float",
-          usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+          usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
         });
         h = { textures: [make(0), make(1)], index: 0, valid: false, generation: gpu.generation };
         histories.set(ctx.view.name, h);
@@ -294,7 +283,6 @@ function taaNode() {
       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")
@@ -303,6 +291,7 @@ function taaNode() {
       pass.setBindGroup(0, group);
       pass.draw(3);
       pass.end();
+      ctx.provide("taa-out", write);
       h.index = 1 - h.index;
       h.valid = true;
     }
@@ -330,20 +319,22 @@ function motionBlurNode() {
           entries: [
             uniform(0),
             tex(1),
-            tex(2, "depth"),
+            depthTex(gpu, 2),
             tex(3, "unfilterable-float"),
             uniform(4),
             sampler(5)
           ]
         });
       }
+      const out = ctx.texture("motion-blur-out");
       const pipeline = cache.render(
         ctx,
-        "post/motion-blur",
+        out.format === "rg11b10ufloat" ? "post/motion-blur/rg11" : "post/motion-blur",
         "shard::post::motion_blur",
         "fs",
         [layout],
-        HDR
+        targetsFor(out),
+        { RG11_ROUND: roundsRg11(gpu, out) }
       );
       if (!pipeline) return;
       const m = v.cam.post.motionBlur;
@@ -396,18 +387,28 @@ function dofNode() {
         layoutGen = gpu.generation;
         layout = gpu.layouts.bindGroupLayout({
           label: "dof",
-          entries: [uniform(0), tex(1), tex(2, "depth"), uniform(3), tex(4), sampler(5)]
+          entries: [uniform(0), tex(1), depthTex(gpu, 2), 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 blur = ctx.texture("dof-blur");
+      const out = ctx.texture("dof-out");
+      const gather = cache.render(
+        ctx,
+        blur.format === "rg11b10ufloat" ? "dof/gather/rg11" : "dof/gather",
+        "shard::post::dof",
+        "gather",
+        [layout],
+        targetsFor(blur)
+      );
       const composite = cache.render(
         ctx,
-        "dof/composite",
+        out.format === "rg11b10ufloat" ? "dof/composite/rg11" : "dof/composite",
         "shard::post::dof",
         "composite",
         [layout],
-        HDR
+        targetsFor(out),
+        { RG11_ROUND: roundsRg11(gpu, out) }
       );
       if (!prepare || !gather || !composite) return;
       const params = cache.buffer(gpu, `${ctx.view.name}/dof`, 16);
@@ -415,8 +416,6 @@ function dofNode() {
       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}`,
@@ -458,7 +457,8 @@ function bloomNode() {
     phase: RenderPhase.Post + 40,
     enabled: hasEffect(PostEffect.Bloom),
     reads: ["bloom-in"],
-    writes: ["bloom-out", "bloom"],
+    // The tonemap composites level 0 over the image (and auto exposure meters the same mix).
+    writes: ["bloom"],
     run: (ctx) => {
       const v = forwardView(ctx);
       if (!v) return;
@@ -467,48 +467,40 @@ function bloomNode() {
         layoutGen = gpu.generation;
         layout = gpu.layouts.bindGroupLayout({
           label: "bloom",
-          entries: [tex(0), sampler(1), uniform(2), tex(3, "unfilterable-float")]
+          entries: [tex(0), sampler(1), uniform(2)]
         });
       }
       const add = { srcFactor: "one", dstFactor: "one", operation: "add" };
+      const chain = ctx.texture("bloom");
+      const rg11 = chain.format === "rg11b10ufloat";
       const prefilter = cache.render(
         ctx,
-        "bloom/prefilter",
+        rg11 ? "bloom/prefilter/rg11" : "bloom/prefilter",
         "shard::post::bloom",
         "prefilter",
         [layout],
-        HDR
+        targetsFor(chain)
       );
       const down = cache.render(
         ctx,
-        "bloom/downsample",
+        rg11 ? "bloom/downsample/rg11" : "bloom/downsample",
         "shard::post::bloom",
         "downsample",
         [layout],
-        HDR
+        targetsFor(chain)
       );
       const up = cache.render(
         ctx,
-        "bloom/upsample",
+        rg11 ? "bloom/upsample/rg11" : "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
+        [{ format: chain.format, blend: { color: add, alpha: add } }]
       );
-      if (!prefilter || !down || !up || !composite) return;
+      if (!prefilter || !down || !up) 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) => {
@@ -527,7 +519,6 @@ function bloomNode() {
       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(
@@ -538,8 +529,7 @@ function bloomNode() {
         () => [
           { 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() }
+          { binding: 2, resource: { buffer: buffer.buffer, offset: i2 * 256, size: 32 } }
         ]
       );
       let i = 0;
@@ -553,10 +543,31 @@ function bloomNode() {
       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);
     }
   };
 }
+function bloomGlow(cam, chain, out, at) {
+  const b = cam.post.bloom;
+  out[at] = chain ? b.intensity : 0;
+  out[at + 1] = chain ? chain.mipLevelCount : 1;
+  out[at + 2] = chain && b.threshold <= 0 ? 1 : 0;
+  out[at + 3] = 0;
+}
+const whites = /* @__PURE__ */ new WeakMap();
+function whiteTexture(gpu) {
+  let t = whites.get(gpu.device);
+  if (!t) {
+    t = gpu.device.createTexture({
+      label: "post/white",
+      size: [1, 1],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    });
+    gpu.device.queue.writeTexture({ texture: t }, new Uint8Array([255, 255, 255, 255]), {}, [1, 1]);
+    whites.set(gpu.device, t);
+  }
+  return t;
+}
 const METER_READBACKS = 3;
 const ExposureMeters = defineResource("render/ExposureMeters", {
   description: "Auto exposure per camera: the last metered EV100 and the adapted one.",
@@ -586,22 +597,103 @@ function histogramEv(bins) {
   }
   return weight > 0 ? sum / weight : void 0;
 }
-function autoExposureNode() {
+function landReading(meters, entity, index, ev) {
+  const m = meters.get(entity);
+  if (m && ev !== void 0 && index > m.reading) {
+    m.metered = ev;
+    m.reading = index;
+    m.readings++;
+  }
+}
+function autoExposureNode(baseline) {
   const cache = new PostCache();
   let layout;
   let layoutGen = -1;
   const perView = /* @__PURE__ */ new Map();
+  const meterViews = /* @__PURE__ */ new Map();
   const zero = new Uint32Array(256);
+  const bins = new Uint32Array(256);
   return {
     kind: "raw",
     phase: RenderPhase.Post + 50,
     enabled: hasEffect(PostEffect.AutoExposure),
-    reads: ["post-hdr"],
+    reads: ["post-hdr", "bloom"],
     sideEffects: true,
     run: (ctx) => {
       const v = forwardView(ctx);
       if (!v) return;
       const gpu = ctx.gpu;
+      const bloom = (v.cam.post.effects & PostEffect.Bloom) !== 0;
+      const chain = bloom ? ctx.texture("bloom") : void 0;
+      if (baseline) {
+        const layout2 = baseline.meterLayout(gpu);
+        const pipeline2 = cache.render(
+          ctx,
+          bloom ? "post/exposure-meter/bloom" : "post/exposure-meter",
+          "shard::post::baseline::meter",
+          "main",
+          [layout2],
+          [{ format: "rg16float" }],
+          { BLOOM: bloom }
+        );
+        if (!pipeline2) return;
+        let m = meterViews.get(ctx.view.name);
+        if (!m || m.generation !== gpu.generation) {
+          m = baseline.meterView(gpu, ctx.view.name, METER_READBACKS);
+          meterViews.set(ctx.view.name, m);
+        }
+        const input2 = ctx.texture("post-hdr");
+        const level02 = chain ?? whiteTexture(gpu);
+        const key = `${idOf(input2)}/${v.pv.uniform.version}/${idOf(level02)}`;
+        if (!m.group || m.groupKey !== key) {
+          m.groupKey = key;
+          m.group = gpu.device.createBindGroup({
+            label: `${ctx.view.name}/exposure`,
+            layout: layout2,
+            entries: [
+              { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
+              { binding: 1, resource: input2.createView() },
+              { binding: 2, resource: { buffer: m.params } },
+              { binding: 3, resource: level02.createView({ mipLevelCount: 1 }) },
+              { binding: 4, resource: cache.sampler(gpu) }
+            ]
+          });
+        }
+        scratch[0] = METER_MIN_EV;
+        scratch[1] = METER_BINS_PER_EV;
+        scratch[2] = v.cam.post.exposure.metering;
+        scratch[3] = 0;
+        bloomGlow(v.cam, chain, scratch, 4);
+        const k2 = baseline.renderMeter(
+          ctx,
+          m,
+          pipeline2,
+          m.group,
+          scratch.subarray(0, 4),
+          scratch.subarray(4, 8)
+        );
+        if (k2 === void 0) return;
+        const meters2 = ctx.world.resource(ExposureMeters);
+        const entity2 = v.cam.entity;
+        const meter2 = meters2.get(entity2);
+        const index2 = meter2 ? ++meter2.submitted : 0;
+        const readback2 = m.readbacks[k2];
+        const busy2 = m.busy;
+        ctx.afterSubmit(() => {
+          readback2.mapAsync(GPUMapMode.READ).then(
+            () => {
+              baseline.binMeter(readback2.getMappedRange(), METER_MIN_EV, METER_BINS_PER_EV, bins);
+              readback2.unmap();
+              busy2[k2] = false;
+              landReading(meters2, entity2, index2, histogramEv(bins));
+            },
+            () => {
+              busy2[k2] = false;
+            }
+          );
+        });
+        return;
+      }
       const C = GPUShaderStage.COMPUTE;
       if (!layout || layoutGen !== gpu.generation) {
         layoutGen = gpu.generation;
@@ -611,14 +703,21 @@ function autoExposureNode() {
             uniform(0, C),
             { binding: 1, visibility: C, texture: { sampleType: "unfilterable-float" } },
             { binding: 2, visibility: C, buffer: { type: "storage" } },
-            uniform(3, C)
+            uniform(3, C),
+            { binding: 4, visibility: C, texture: { sampleType: "float" } },
+            { binding: 5, visibility: C, sampler: { type: "filtering" } }
           ]
         });
         perView.clear();
       }
-      const pipeline = cache.compute(ctx, "post/exposure", "shard::post::exposure", "meter", [
-        layout
-      ]);
+      const pipeline = cache.compute(
+        ctx,
+        bloom ? "post/exposure/bloom" : "post/exposure",
+        "shard::post::exposure",
+        "meter",
+        [layout],
+        { BLOOM: bloom }
+      );
       if (!pipeline) return;
       let state = perView.get(ctx.view.name);
       if (!state || state.generation !== gpu.generation) {
@@ -646,20 +745,24 @@ function autoExposureNode() {
       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);
+      bloomGlow(v.cam, chain, scratch, 4);
+      const params = cache.buffer(gpu, `${ctx.view.name}/exposure`, 32);
+      params.write(scratch, 0, 0, 8);
       const input = ctx.texture("post-hdr");
       const histogram = state.histogram;
+      const level0 = chain ?? whiteTexture(gpu);
       const group = cache.group(
         gpu,
         `${ctx.view.name}/exposure`,
-        `${idOf(input)}/${idOf(histogram)}/${v.pv.uniform.version}/${params.version}`,
+        `${idOf(input)}/${idOf(histogram)}/${v.pv.uniform.version}/${params.version}/${idOf(level0)}`,
         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 } }
+          { binding: 3, resource: { buffer: params.buffer } },
+          { binding: 4, resource: level0.createView({ mipLevelCount: 1 }) },
+          { binding: 5, resource: cache.sampler(gpu) }
         ]
       );
       gpu.device.queue.writeBuffer(histogram, 0, zero);
@@ -687,12 +790,7 @@ function autoExposureNode() {
             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++;
-            }
+            landReading(meters, entity, index, ev);
           },
           () => {
             busy[k] = false;
@@ -753,16 +851,18 @@ const POST_NODES = [
   ["post/fxaa", PostEffect.Fxaa]
 ];
 const halfSize = { divide: 2 };
-function addPostNodes(world) {
+function addPostNodes(world, baseline) {
   const graph = world.resource(Graph);
   world.initResource(ExposureMeters);
-  graph.declare({ name: "prepass-normal", format: "rgba16float" });
+  graph.declare({ name: "prepass-normal", format: "rg16float" });
   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: "ssao", format: "rg16float", size: halfSize });
+  const gpu = world.resource(Gpu);
+  const chainFormat = (view) => postFormat(gpu, view);
+  graph.declare({ name: "post-a", format: chainFormat });
+  graph.declare({ name: "post-b", format: chainFormat });
+  graph.declare({ name: "taa-history", format: "rgba16float" });
   graph.declare({ name: "dof-half", format: "rgba16float", size: halfSize });
   graph.declare({ name: "dof-blur", format: "rgba16float", size: halfSize });
   graph.declare({
@@ -774,6 +874,29 @@ function addPostNodes(world) {
       return cam ? bloomLevels(cam) : 1;
     }
   });
+  addRenderFeatures(world, {
+    name: "render/post",
+    description: "The prepass, SSAO, fog, TAA, motion blur, depth of field and bloom.",
+    nodes: [
+      "prepass",
+      "ssao",
+      "ssao-deferred",
+      "post/fog",
+      "post/taa",
+      "post/motion-blur",
+      "post/dof",
+      "post/bloom"
+    ],
+    baseline: { strategy: "The same fragment passes" }
+  });
+  addRenderFeatures(world, {
+    name: "render/auto-exposure",
+    description: "Automatic exposure from a luminance histogram.",
+    nodes: ["post/exposure"],
+    baseline: {
+      strategy: "A 64\xD736 meter image read back and binned into the same histogram on the CPU"
+    }
+  });
   graph.addNode("prepass", prepassNode);
   graph.addNode("ssao", ssaoNode(RenderPhase.Prepass + 50, false));
   graph.addNode("ssao-deferred", ssaoNode(RenderPhase.Opaque + 20, true));
@@ -782,7 +905,7 @@ function addPostNodes(world) {
   graph.addNode("post/motion-blur", motionBlurNode());
   graph.addNode("post/dof", dofNode());
   graph.addNode("post/bloom", bloomNode());
-  graph.addNode("post/exposure", autoExposureNode());
+  graph.addNode("post/exposure", autoExposureNode(baseline));
 }
 const DESCRIBED = [
   ["ssao", "ssao", PostEffect.Ssao],
@@ -843,6 +966,7 @@ export {
   POST_NODES,
   adaptExposure,
   addPostNodes,
+  bloomGlow,
   bloomLevels,
   describePost,
   histogramEv

package/dist/post-plugin.js

@@ -1,7 +1,7 @@
 import { PostUpdate } from "@aethervtt/shard-core";
 import { definePlugin } from "@aethervtt/shard-runtime";
 import { applyPhysicalCameras } from "./camera.js";
-import { RenderDescribers, Shaders } from "./plugin.js";
+import { Gpu, RenderDescribers, Shaders } from "./plugin.js";
 import { PostEffect, PostFeatures } from "./post.js";
 import { adaptExposure, addPostNodes, describePost, ExposureMeters } from "./post-nodes.js";
 import { POST_SHADERS } from "./post-shaders.js";
@@ -15,10 +15,12 @@ const postPlugin = definePlugin({
     app.world.initResource(PostFeatures).effects |= POST_EFFECTS;
     app.addSystems(PostUpdate, adaptExposure.after(applyPhysicalCameras));
   },
-  ready(app) {
+  async ready(app) {
+    const baseline = app.world.resource(Gpu).tier === "baseline" ? await import("./baseline/exposure.js") : void 0;
     registerShaders(app.world.resource(Shaders), POST_SHADERS);
+    if (baseline) registerShaders(app.world.resource(Shaders), baseline.BASELINE_EXPOSURE_SHADERS);
     app.world.initResource(RenderDescribers).set("post", (world) => describePost(world));
-    addPostNodes(app.world);
+    addPostNodes(app.world, baseline);
   }
 });
 export {