@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/baseline/atmosphere.js

@@ -0,0 +1,301 @@
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { fragmentKernel } from "@aethervtt/shard-shader/fragment-kernel";
+import { MULTISCATTER_SIZE, TRANSMITTANCE_H, TRANSMITTANCE_W } from "../atmosphere-model.js";
+import {
+  AtmosphereGpuResource,
+  LUT_LAYERS,
+  packParams
+} from "../atmosphere-nodes.js";
+import { ATMOSPHERE_SHADERS } from "../atmosphere-shaders.js";
+import { Shaders } from "../plugin.js";
+import { baselineBakers } from "./environment.js";
+const SLOT = 256;
+const fragment = (root) => fragmentKernel(ATMOSPHERE_SHADERS[root], "main", root).source;
+const BASELINE_ATMOSPHERE_SHADERS = {
+  "shard::atmosphere::transmittance_lut::fragment": fragment(
+    "shard::atmosphere::transmittance_lut"
+  ),
+  "shard::atmosphere::multiscatter_lut::fragment": fragment("shard::atmosphere::multiscatter_lut"),
+  "shard::atmosphere::sky_view::fragment": fragment("shard::atmosphere::sky_view"),
+  "shard::atmosphere::bake::fragment": fragment("shard::atmosphere::bake"),
+  "shard::atmosphere::baseline::aerial": `
+import shard::atmosphere::{ AtmosphereView, KCD, integrate, froxel_distance, ray_at };
+
+@group(0) @binding(0) var<uniform> atmo: AtmosphereView;
+@group(0) @binding(1) var tlut: texture_2d_array<f32>;
+@group(0) @binding(2) var mlut: texture_2d_array<f32>;
+@group(0) @binding(3) var lut_sampler: sampler;
+/** The froxel grid's size, and the slice this pass renders. */
+@group(0) @binding(4) var<uniform> shard_target: vec4u;
+
+struct Froxel {
+  @location(0) scatter: vec4f,
+  @location(1) transmittance: vec4f,
+}
+
+/**
+ * One slice of the aerial-perspective froxels: in-scattering (kcd/m\xB2) and transmittance from the
+ * camera to the slice's far end, along the froxel column's ray.
+ */
+@fragment fn main(@builtin(position) p: vec4f) -> Froxel {
+  let size = shard_target.xyz;
+  let a = atmo.atmospheres[u32(atmo.info.y)];
+  let uv = (floor(p.xy) + 0.5) / vec2f(size.xy);
+  let d = ray_at(atmo, uv);
+  let o = a.origin.xyz;
+  var L = vec3f(0.0);
+  var T = vec3f(1.0);
+  var t_prev = 0.0;
+  for (var k = 0u; k <= shard_target.w; k++) {
+    let t = froxel_distance(atmo.froxels, (f32(k) + 1.0) / f32(size.z));
+    // Two steps per slice, from where the last one ended.
+    let seg = integrate(tlut, mlut, lut_sampler, a, atmo.suns[0], atmo.suns[1], u32(atmo.info.z), o + d * t_prev, d, t - t_prev, 2u, false);
+    L += T * seg.luminance;
+    T *= seg.transmittance;
+    t_prev = t;
+  }
+  var out: Froxel;
+  out.scatter = vec4f(L / KCD, 1.0);
+  out.transmittance = vec4f(T, 1.0);
+  return out;
+}`
+};
+const ROOTS = {
+  transmittance: "shard::atmosphere::transmittance_lut::fragment",
+  multiscatter: "shard::atmosphere::multiscatter_lut::fragment",
+  skyView: "shard::atmosphere::sky_view::fragment",
+  aerial: "shard::atmosphere::baseline::aerial",
+  bake: "shard::atmosphere::bake::fragment"
+};
+const kernels = /* @__PURE__ */ new WeakMap();
+function kernelsOf(gpu) {
+  let k = kernels.get(gpu);
+  if (k && k.generation === gpu.generation) return k;
+  const F = GPUShaderStage.FRAGMENT;
+  const uniform = (binding) => ({
+    binding,
+    visibility: F,
+    buffer: { type: "uniform" }
+  });
+  const target = (binding) => ({
+    binding,
+    visibility: F,
+    buffer: { type: "uniform", hasDynamicOffset: true }
+  });
+  const array = (binding) => ({
+    binding,
+    visibility: F,
+    texture: { sampleType: "float", viewDimension: "2d-array" }
+  });
+  const sampler = (binding) => ({
+    binding,
+    visibility: F,
+    sampler: { type: "filtering" }
+  });
+  const layout = (label, entries) => gpu.layouts.bindGroupLayout({ label: `atmosphere/baseline/${label}`, entries });
+  const view = [uniform(0), array(1), array(2), sampler(3), target(4)];
+  k = {
+    generation: gpu.generation,
+    layouts: {
+      transmittance: layout("transmittance", [uniform(0), target(1)]),
+      multiscatter: layout("multiscatter", [uniform(0), array(1), sampler(2), target(3)]),
+      skyView: layout("sky-view", view),
+      aerial: layout("aerial", view),
+      bake: layout("bake", view)
+    },
+    pipelines: {}
+  };
+  kernels.set(gpu, k);
+  return k;
+}
+function pipeline(ctx, k, name) {
+  const cached = k.pipelines[name];
+  if (cached) return cached;
+  const gpu = ctx.gpu;
+  const shaders = ctx.world.resource(Shaders);
+  const fs = shaders.module(gpu, { root: ROOTS[name] });
+  const vs = shaders.module(gpu, { root: "shard::fullscreen" });
+  if (!fs || !vs) {
+    gpu.pipelines.skipped++;
+    return void 0;
+  }
+  const made = gpu.pipelines.render({
+    label: `atmosphere/baseline/${name}`,
+    layout: gpu.layouts.pipelineLayout({
+      label: `atmosphere/baseline/${name}`,
+      bindGroupLayouts: [k.layouts[name]]
+    }),
+    vertex: { module: vs, entryPoint: "vs" },
+    fragment: {
+      module: fs,
+      entryPoint: "main",
+      targets: name === "aerial" ? [{ format: "rgba16float" }, { format: "rgba16float" }] : [{ format: "rgba16float" }]
+    }
+  });
+  if (made) k.pipelines[name] = made;
+  return made;
+}
+function targetBuffer(gpu, label, slots) {
+  const data = new Uint32Array(Math.max(1, slots.length) * SLOT / 4);
+  for (let i = 0; i < slots.length; i++) data.set(slots[i], i * SLOT / 4);
+  const buffer = new GpuBuffer(gpu, { label, usage: GPUBufferUsage.UNIFORM, size: data.byteLength });
+  buffer.write(data);
+  return buffer;
+}
+function draw(ctx, label, p, group, offset, attachments) {
+  const pass = ctx.encoder.beginRenderPass({ label, colorAttachments: attachments });
+  pass.setPipeline(p);
+  pass.setBindGroup(0, group, [offset]);
+  pass.draw(3);
+  pass.end();
+}
+function color(view, depthSlice) {
+  return { view, depthSlice, loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 0] };
+}
+const paramScratch = new Float32Array(32);
+function runLuts(ctx, s) {
+  const k = kernelsOf(ctx.gpu);
+  const t = pipeline(ctx, k, "transmittance");
+  const m = pipeline(ctx, k, "multiscatter");
+  if (!t || !m) return false;
+  const gpu = ctx.gpu;
+  const targets = targetBuffer(gpu, "atmosphere/baseline/luts", [
+    [TRANSMITTANCE_W, TRANSMITTANCE_H, 1, 0],
+    [MULTISCATTER_SIZE, MULTISCATTER_SIZE, 1, 0]
+  ]);
+  ctx.afterSubmit(() => targets.destroy());
+  const target = { buffer: targets.buffer, size: 16 };
+  for (let i = 0; i < LUT_LAYERS; i++) {
+    const rec = s.owners[i];
+    if (!rec || rec.layerVersion === rec.version) continue;
+    packParams(rec, paramScratch, 0, void 0, 0);
+    s.params[i].write(paramScratch);
+    const layer = (texture) => texture.createView({ dimension: "2d", baseArrayLayer: i, arrayLayerCount: 1 });
+    const params = { buffer: s.params[i].buffer };
+    draw(
+      ctx,
+      "atmosphere/transmittance",
+      t,
+      gpu.device.createBindGroup({
+        layout: k.layouts.transmittance,
+        entries: [
+          { binding: 0, resource: params },
+          { binding: 1, resource: target }
+        ]
+      }),
+      0,
+      [color(layer(s.transmittance))]
+    );
+    draw(
+      ctx,
+      "atmosphere/multiscatter",
+      m,
+      gpu.device.createBindGroup({
+        layout: k.layouts.multiscatter,
+        entries: [
+          { binding: 0, resource: params },
+          { binding: 1, resource: s.transmittanceArray },
+          { binding: 2, resource: s.clamp },
+          { binding: 3, resource: target }
+        ]
+      }),
+      SLOT,
+      [color(layer(s.multiscatter))]
+    );
+    rec.layerVersion = rec.version;
+    s.lutComputes++;
+  }
+  return true;
+}
+function viewGroup(gpu, layout, s, uniform, targets) {
+  return gpu.device.createBindGroup({
+    layout,
+    entries: [
+      { binding: 0, resource: { buffer: uniform } },
+      { binding: 1, resource: s.transmittanceArray },
+      { binding: 2, resource: s.multiscatterArray },
+      { binding: 3, resource: s.clamp },
+      { binding: 4, resource: { buffer: targets, size: 16 } }
+    ]
+  });
+}
+const viewPasses = /* @__PURE__ */ new WeakMap();
+function runView(ctx, s, ca, c) {
+  const k = kernelsOf(ctx.gpu);
+  const sky = pipeline(ctx, k, "skyView");
+  const aerial = pipeline(ctx, k, "aerial");
+  if (!sky || !aerial) return false;
+  const gpu = ctx.gpu;
+  const depth = c.scatter.depthOrArrayLayers;
+  let v = viewPasses.get(c);
+  if (!v || v.uniform !== c.uniform.version || v.skyView !== c.skyView || v.scatter !== c.scatter || v.transmittance !== c.transmittance || v.luts !== s.transmittance || v.generation !== gpu.generation) {
+    v?.targets.destroy();
+    const slots = [[c.skyView.width, c.skyView.height, 1, 0]];
+    for (let slice = 0; slice < depth; slice++) {
+      slots.push([c.scatter.width, c.scatter.height, depth, slice]);
+    }
+    const targets = targetBuffer(gpu, "atmosphere/baseline/view", slots);
+    v = {
+      uniform: c.uniform.version,
+      skyView: c.skyView,
+      scatter: c.scatter,
+      transmittance: c.transmittance,
+      luts: s.transmittance,
+      generation: gpu.generation,
+      targets,
+      sky: viewGroup(gpu, k.layouts.skyView, s, c.uniform.buffer, targets.buffer),
+      aerial: viewGroup(gpu, k.layouts.aerial, s, c.uniform.buffer, targets.buffer),
+      skyViewView: c.skyView.createView(),
+      scatterView: c.scatter.createView(),
+      transmittanceView: c.transmittance.createView()
+    };
+    viewPasses.set(c, v);
+  }
+  draw(ctx, "atmosphere/sky-view", sky, v.sky, 0, [color(v.skyViewView)]);
+  if (ca.aerialPerspective) {
+    for (let slice = 0; slice < depth; slice++) {
+      draw(ctx, "atmosphere/aerial", aerial, v.aerial, (1 + slice) * SLOT, [
+        color(v.scatterView, slice),
+        color(v.transmittanceView, slice)
+      ]);
+    }
+  }
+  return true;
+}
+const bakeTargets = /* @__PURE__ */ new WeakMap();
+function bake(ctx, env, face, view) {
+  const ca = env.atmosphere;
+  const s = ctx.world.resource(AtmosphereGpuResource);
+  const primary = ca?.primary;
+  if (!ca || !primary || primary.layerVersion !== primary.version) return false;
+  const c = s.cameras.get(ca.camera);
+  if (!c?.packed) return false;
+  const k = kernelsOf(ctx.gpu);
+  const p = pipeline(ctx, k, "bake");
+  if (!p) return false;
+  const gpu = ctx.gpu;
+  let sizes = bakeTargets.get(gpu);
+  if (!sizes) {
+    sizes = /* @__PURE__ */ new Map();
+    bakeTargets.set(gpu, sizes);
+  }
+  let targets = sizes.get(env.size);
+  if (!targets || targets.generation !== gpu.generation) {
+    const faces = [0, 1, 2, 3, 4, 5].map((f) => [env.size, env.size, 1, f]);
+    const buffer = gpu.withOwner("gpu", () => targetBuffer(gpu, "atmosphere/baseline/bake", faces));
+    targets = { generation: gpu.generation, buffer };
+    sizes.set(env.size, targets);
+  }
+  const group = viewGroup(gpu, k.layouts.bake, s, c.uniform.buffer, targets.buffer.buffer);
+  draw(ctx, "atmosphere/bake", p, group, face * SLOT, [color(view)]);
+  return true;
+}
+function installAtmosphereBaseline() {
+  baselineBakers.set("atmosphere", bake);
+}
+export {
+  BASELINE_ATMOSPHERE_SHADERS,
+  installAtmosphereBaseline,
+  runLuts,
+  runView
+};

package/dist/baseline/data-texture.d.ts

@@ -0,0 +1,36 @@
+import { type GpuContext } from '@aethervtt/shard-gpu';
+/** Uploads what every data texture of `gpu` was written this frame. */
+export declare function flushDataTextures(gpu: GpuContext): void;
+/** Forgets `owner`'s data textures on `gpu`: the ledger destroys them, so they mustn't flush. */
+export declare function releaseDataTextures(gpu: GpuContext, owner: string): void;
+export declare class DataTexture {
+    readonly owner: string;
+    version: number;
+    private readonly gpu;
+    private readonly label;
+    private texture;
+    private view;
+    private mirror;
+    private mirrorWords;
+    size: number;
+    private rows;
+    private generation;
+    private dirtyStart;
+    private dirtyEnd;
+    private readonly destination;
+    private readonly layout;
+    private readonly extent;
+    constructor(gpu: GpuContext, label: string, size: number);
+    get currentVersion(): number;
+    ensureCapacity(bytes: number): boolean;
+    write(data: ArrayBufferView & ArrayLike<number>, byteOffset: number, start: number, count: number | undefined): void;
+    resource(): GPUBindingResource;
+    flush(): void;
+    destroy(): void;
+    private setMirror;
+    private upload;
+    /** A texture for the current size (plus the length texel), everything uploaded again. */
+    private recreate;
+    /** After device loss (or on first use) the texture is made again from the CPU copy. */
+    private checkGeneration;
+}

package/dist/baseline/data-texture.js

@@ -0,0 +1,181 @@
+import { DATA_TEXTURE_PREFIX } from "@aethervtt/shard-gpu";
+import { DATA_TEXTURE_WIDTH as DATA_WIDTH } from "@aethervtt/shard-shader";
+const textures = /* @__PURE__ */ new WeakMap();
+const bytesOf = /* @__PURE__ */ new WeakMap();
+const wordsOf = /* @__PURE__ */ new WeakMap();
+function bytes(buffer) {
+  let view = bytesOf.get(buffer);
+  if (!view) {
+    view = new Uint8Array(buffer);
+    bytesOf.set(buffer, view);
+  }
+  return view;
+}
+function words(buffer) {
+  let view = wordsOf.get(buffer);
+  if (!view) {
+    view = new Uint32Array(buffer, 0, buffer.byteLength >> 2);
+    wordsOf.set(buffer, view);
+  }
+  return view;
+}
+function flushDataTextures(gpu) {
+  const list = textures.get(gpu);
+  if (!list) return;
+  for (let i = 0; i < list.length; i++) list[i].flush();
+}
+function releaseDataTextures(gpu, owner) {
+  const list = textures.get(gpu);
+  if (!list) return;
+  let n = 0;
+  for (let i = 0; i < list.length; i++) if (list[i].owner !== owner) list[n++] = list[i];
+  list.length = n;
+}
+class DataTexture {
+  owner;
+  version = 0;
+  gpu;
+  label;
+  texture;
+  view;
+  mirror;
+  mirrorWords;
+  size;
+  rows = 0;
+  generation = -1;
+  dirtyStart = Number.POSITIVE_INFINITY;
+  dirtyEnd = 0;
+  // Reused upload descriptors: flushing allocates nothing.
+  destination;
+  layout = { offset: 0, bytesPerRow: DATA_WIDTH * 16 };
+  extent = { width: 0, height: 0 };
+  constructor(gpu, label, size) {
+    this.gpu = gpu;
+    this.label = label;
+    this.owner = gpu.owner;
+    this.size = size;
+    this.mirror = new Uint8Array(size);
+    this.mirrorWords = new Uint32Array(this.mirror.buffer);
+    this.destination = { texture: void 0, origin: { x: 0, y: 0 } };
+    let list = textures.get(gpu);
+    if (!list) {
+      list = [];
+      textures.set(gpu, list);
+    }
+    list.push(this);
+  }
+  get currentVersion() {
+    this.checkGeneration();
+    return this.version;
+  }
+  ensureCapacity(bytes2) {
+    this.checkGeneration();
+    if (bytes2 <= this.size) return false;
+    let size = this.size;
+    while (size < bytes2) size *= 2;
+    const mirror = new Uint8Array(size);
+    mirror.set(this.mirror.subarray(0, this.size));
+    this.setMirror(mirror);
+    this.size = size;
+    this.recreate();
+    return true;
+  }
+  write(data, byteOffset, start, count) {
+    const bytesPerElement = data.BYTES_PER_ELEMENT;
+    const elements = count ?? data.length - start;
+    const length = elements * bytesPerElement;
+    this.ensureCapacity(byteOffset + length);
+    if (elements === 0) return;
+    this.checkGeneration();
+    const from = data.byteOffset + start * bytesPerElement;
+    if (((from | byteOffset | length) & 3) === 0) {
+      const src = words(data.buffer);
+      const dst = this.mirrorWords;
+      const s = from >> 2;
+      const d = byteOffset >> 2;
+      for (let i = 0, n = length >> 2; i < n; i++) dst[d + i] = src[s + i];
+    } else {
+      const src = bytes(data.buffer);
+      const dst = this.mirror;
+      for (let i = 0; i < length; i++) dst[byteOffset + i] = src[from + i];
+    }
+    if (byteOffset < this.dirtyStart) this.dirtyStart = byteOffset;
+    if (byteOffset + length > this.dirtyEnd) this.dirtyEnd = byteOffset + length;
+  }
+  resource() {
+    this.checkGeneration();
+    return this.view;
+  }
+  flush() {
+    if (this.dirtyEnd <= this.dirtyStart) return;
+    this.checkGeneration();
+    const first = Math.floor(this.dirtyStart / 16);
+    const last = Math.ceil(this.dirtyEnd / 16);
+    this.dirtyStart = Number.POSITIVE_INFINITY;
+    this.dirtyEnd = 0;
+    const row0 = Math.floor(first / DATA_WIDTH);
+    const row1 = Math.floor((last - 1) / DATA_WIDTH);
+    if (row0 === row1) {
+      this.upload(first % DATA_WIDTH, row0, last - first, 1);
+      return;
+    }
+    this.upload(first % DATA_WIDTH, row0, DATA_WIDTH - first % DATA_WIDTH, 1);
+    if (row1 > row0 + 1) this.upload(0, row0 + 1, DATA_WIDTH, row1 - row0 - 1);
+    this.upload(0, row1, last - row1 * DATA_WIDTH, 1);
+  }
+  destroy() {
+    this.texture?.destroy();
+    const list = textures.get(this.gpu);
+    const i = list ? list.indexOf(this) : -1;
+    if (i !== -1) list.splice(i, 1);
+  }
+  setMirror(mirror) {
+    this.mirror = mirror;
+    this.mirrorWords = new Uint32Array(mirror.buffer);
+  }
+  upload(x, y, width, height) {
+    this.destination.texture = this.texture;
+    this.destination.origin.x = x;
+    this.destination.origin.y = y;
+    this.layout.offset = (y * DATA_WIDTH + x) * 16;
+    this.extent.width = width;
+    this.extent.height = height;
+    this.gpu.device.queue.writeTexture(this.destination, this.mirror, this.layout, this.extent);
+  }
+  /** A texture for the current size (plus the length texel), everything uploaded again. */
+  recreate() {
+    this.texture?.destroy();
+    const texels = this.size / 16 + 1;
+    this.rows = Math.ceil(texels / DATA_WIDTH);
+    if (this.mirror.byteLength < this.rows * DATA_WIDTH * 16) {
+      const mirror = new Uint8Array(this.rows * DATA_WIDTH * 16);
+      mirror.set(this.mirror);
+      this.setMirror(mirror);
+    }
+    this.mirrorWords[(this.rows * DATA_WIDTH - 1) * 4] = this.size;
+    this.texture = this.gpu.withOwner(
+      this.owner,
+      () => this.gpu.device.createTexture({
+        label: `${DATA_TEXTURE_PREFIX}${this.label}`,
+        size: [DATA_WIDTH, this.rows],
+        format: "rgba32uint",
+        // COPY_SRC: tools and tests read a data texture back.
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC
+      })
+    );
+    this.view = this.texture.createView();
+    this.generation = this.gpu.generation;
+    this.version++;
+    this.dirtyStart = 0;
+    this.dirtyEnd = this.rows * DATA_WIDTH * 16;
+  }
+  /** After device loss (or on first use) the texture is made again from the CPU copy. */
+  checkGeneration() {
+    if (this.generation !== this.gpu.generation) this.recreate();
+  }
+}
+export {
+  DataTexture,
+  flushDataTextures,
+  releaseDataTextures
+};

package/dist/baseline/environment.d.ts

@@ -0,0 +1,14 @@
+import type { Environment, EnvironmentStore } from '../environment-state.js';
+import type { NodeContext } from '../graph.js';
+export declare const BASELINE_ENVIRONMENT_SHADERS: Record<string, string>;
+/**
+ * A pass that fills one face of an atmosphere environment's source (level 0) on baseline, or false
+ * when its inputs aren't ready. The atmosphere plugin registers `atmosphere`.
+ */
+export type BaselineEnvironmentBaker = (ctx: NodeContext, env: Environment, face: number, target: GPUTextureView) => boolean;
+export declare const baselineBakers: Map<"atmosphere" | "map", BaselineEnvironmentBaker>;
+/**
+ * Prefilters every pending environment (and the BRDF LUT, once) with fragment passes. Runs once
+ * per frame, before any view draws; an environment whose input isn't ready stays pending.
+ */
+export declare function runBaselineEnvironment(ctx: NodeContext, store: EnvironmentStore): void;