@aethervtt/shard-render 0.1.0 → 0.2.0

package/dist/post-nodes.js

@@ -9,7 +9,7 @@ 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,
@@ -18,8 +18,11 @@ import {
   HDR,
   idOf,
   PostCache,
+  postFormat,
+  roundsRg11,
   sampler,
   scratch,
+  targetsFor,
   tex,
   uniform
 } from "./post-common.js";
@@ -44,7 +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"];
+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],
@@ -53,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",
@@ -63,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), depthTex(gpu, 1), tex(2, "unfilterable-float"), uniform(3)]
-          }),
-          up: gpu.layouts.bindGroupLayout({
-            label: "ssao/upsample",
-            entries: [uniform(0), depthTex(gpu, 1), 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];
@@ -113,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() },
@@ -127,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;
@@ -160,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 } }],
@@ -177,14 +158,16 @@ function fogNode() {
         });
       }
       const alpha = v.cam.alphaOutput;
+      const out = ctx.texture("fog-out");
+      const rg11 = out.format === "rg11b10ufloat";
       const pipeline = cache.render(
         ctx,
-        FOG_KEYS[(alpha ? 1 : 0) + (state.interiorMode !== 0 ? 2 : 0)],
+        FOG_KEYS[(alpha ? 1 : 0) + (state.interiorMode !== 0 ? 2 : 0) + (rg11 ? 4 : 0)],
         "shard::post::fog",
         "fs",
         [state.layouts.view, layout],
-        HDR,
-        { TRANSPARENT: alpha }
+        targetsFor(out),
+        { TRANSPARENT: alpha, RG11_ROUND: roundsRg11(gpu, out) }
       );
       if (!pipeline) return;
       const f = v.cam.post.fog;
@@ -254,12 +237,11 @@ function taaNode() {
         "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();
@@ -267,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);
@@ -301,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")
@@ -310,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;
     }
@@ -344,13 +326,15 @@ function motionBlurNode() {
           ]
         });
       }
+      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;
@@ -407,14 +391,24 @@ function dofNode() {
         });
       }
       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);
@@ -422,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}`,
@@ -465,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;
@@ -474,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) => {
@@ -534,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(
@@ -545,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;
@@ -560,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.",
@@ -613,21 +617,24 @@ function autoExposureNode(baseline) {
     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,
-          "post/exposure-meter",
+          bloom ? "post/exposure-meter/bloom" : "post/exposure-meter",
           "shard::post::baseline::meter",
           "main",
           [layout2],
-          [{ format: "rg16float" }]
+          [{ format: "rg16float" }],
+          { BLOOM: bloom }
         );
         if (!pipeline2) return;
         let m = meterViews.get(ctx.view.name);
@@ -636,7 +643,8 @@ function autoExposureNode(baseline) {
           meterViews.set(ctx.view.name, m);
         }
         const input2 = ctx.texture("post-hdr");
-        const key = `${idOf(input2)}/${v.pv.uniform.version}`;
+        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({
@@ -645,7 +653,9 @@ function autoExposureNode(baseline) {
             entries: [
               { binding: 0, resource: { buffer: v.pv.uniform.buffer } },
               { binding: 1, resource: input2.createView() },
-              { binding: 2, resource: { buffer: m.params } }
+              { binding: 2, resource: { buffer: m.params } },
+              { binding: 3, resource: level02.createView({ mipLevelCount: 1 }) },
+              { binding: 4, resource: cache.sampler(gpu) }
             ]
           });
         }
@@ -653,7 +663,15 @@ function autoExposureNode(baseline) {
         scratch[1] = METER_BINS_PER_EV;
         scratch[2] = v.cam.post.exposure.metering;
         scratch[3] = 0;
-        const k2 = baseline.renderMeter(ctx, m, pipeline2, m.group, scratch.subarray(0, 4));
+        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;
@@ -685,14 +703,21 @@ function autoExposureNode(baseline) {
             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) {
@@ -720,20 +745,24 @@ function autoExposureNode(baseline) {
       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);
@@ -825,13 +854,15 @@ const halfSize = { divide: 2 };
 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({
@@ -935,6 +966,7 @@ export {
   POST_NODES,
   adaptExposure,
   addPostNodes,
+  bloomGlow,
   bloomLevels,
   describePost,
   histogramEv

package/dist/post-scene.d.ts

@@ -0,0 +1,130 @@
+import { type World } from '@aethervtt/shard-core';
+/** Each post effect's component and settings, by the name `?effects=` uses. */
+export declare const POST_EFFECTS: {
+    readonly bloom: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly threshold: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly knee: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, {
+        readonly intensity: 0.12;
+    }];
+    readonly exposure: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly minEv: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly maxEv: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly compensation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly speedUp: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly speedDown: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly metering: import("@aethervtt/shard-core").FieldType<"average" | "center" | "spot", "u8">;
+    }>, {
+        readonly compensation: 0.5;
+    }];
+    readonly dof: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly mode: import("@aethervtt/shard-core").FieldType<"bokeh" | "gaussian", "u8">;
+        readonly focusDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly maxBlur: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, {
+        readonly focusDistance: 9;
+        readonly maxBlur: 0.012;
+    }];
+    readonly 'motion-blur': readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly samples: import("@aethervtt/shard-core").FieldType<number, "u32">;
+        readonly maxBlur: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, {}];
+    readonly taa: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly mode: import("@aethervtt/shard-core").FieldType<"fxaa" | "msaa" | "none" | "taa", "u8">;
+    }>, {
+        readonly mode: 'taa';
+    }];
+    readonly fxaa: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly mode: import("@aethervtt/shard-core").FieldType<"fxaa" | "msaa" | "none" | "taa", "u8">;
+    }>, {
+        readonly mode: 'fxaa';
+    }];
+    readonly noaa: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly mode: import("@aethervtt/shard-core").FieldType<"fxaa" | "msaa" | "none" | "taa", "u8">;
+    }>, {
+        readonly mode: 'none';
+    }];
+    readonly ssao: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly quality: import("@aethervtt/shard-core").FieldType<"high" | "low" | "medium", "u8">;
+    }>, {
+        readonly radius: 0.6;
+    }];
+    readonly fog: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+        readonly density: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly heightFalloff: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly start: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly sunScattering: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly mode: import("@aethervtt/shard-core").FieldType<"add" | "default", "u8">;
+    }>, {
+        readonly density: 0.015;
+        readonly heightFalloff: 0.08;
+        readonly sunScattering: 0.6;
+    }];
+    readonly grading: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly temperature: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly tint: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly saturation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly contrast: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly lift: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+        readonly gamma: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+        readonly gain: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+        readonly lut: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Texture"> | null, "object">;
+    }>, {
+        readonly temperature: 0.1;
+        readonly saturation: 1.1;
+        readonly contrast: 1.05;
+    }];
+    readonly vignette: readonly [import("@aethervtt/shard-core").ComponentDef<{
+        readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        readonly smoothness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, {
+        readonly intensity: 0.25;
+    }];
+};
+export type PostEffectName = keyof typeof POST_EFFECTS;
+/** The full stack: every effect but the other anti-aliasing modes (TAA is on). */
+export declare const ALL_POST_EFFECTS: readonly PostEffectName[];
+/** The components for effect names; unknown names are skipped. */
+export declare function postEffects(names: readonly string[]): unknown[];
+/** A ball on a circle round the courtyard. */
+export declare const PostSpin: import("@aethervtt/shard-core").ComponentDef<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32"> & ((options?: import("@aethervtt/shard-core").FieldOptions<number> | undefined) => import("@aethervtt/shard-core").FieldType<number, "f32">);
+    readonly speed: import("@aethervtt/shard-core").FieldType<number, "f32"> & ((options?: import("@aethervtt/shard-core").FieldOptions<number> | undefined) => import("@aethervtt/shard-core").FieldType<number, "f32">);
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32"> & ((options?: import("@aethervtt/shard-core").FieldOptions<number> | undefined) => import("@aethervtt/shard-core").FieldType<number, "f32">);
+}>;
+/** Moves PostSpin balls along their circles by `Time.elapsed`. */
+export declare const postSpin: import("@aethervtt/shard-core").SystemDef<{
+    q: import("@aethervtt/shard-core").Query;
+}>;
+/** The courtyard's moving parts: PostSpin and its system. Add it with the render plugins. */
+export declare const postScenePlugin: import("@aethervtt/shard-runtime").Plugin;
+/** Where the courtyard is looked at from: 9 m out, 2.2 m up. */
+export declare const POST_EYE: [number, number, number];
+export declare const POST_TARGET: [number, number, number];
+/**
+ * The `post-stack` camera path: from POST_EYE, swinging 30° either side of the courtyard's axis
+ * once every 20 s and drifting 1.5 m in and out, always looking at POST_TARGET. `seconds` along it.
+ */
+export declare function postCamera(seconds: number): {
+    eye: [number, number, number];
+    target: [number, number, number];
+};
+/** The camera's lens: a physical exposure, so auto exposure and DoF read real values. */
+export declare const POST_LENS: readonly [import("@aethervtt/shard-core").ComponentDef<{
+    readonly aperture: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shutterSpeed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly iso: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly sensorHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly focalLength: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>, {
+    readonly aperture: 5.6;
+    readonly shutterSpeed: number;
+    readonly iso: 100;
+}];
+/** The courtyard, its sun and sky; the camera is the caller's. */
+export declare function spawnPostScene(world: World): void;