@aethervtt/shard-render 0.0.1

package/dist/deferred.js

@@ -0,0 +1,296 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { Culler } from "./culling.js";
+import {
+  drawMaterials,
+  ForwardStateResource,
+  gbufferEmissiveFormat,
+  PASS_GBUFFER,
+  PASS_OPAQUE,
+  sceneColor,
+  viewBindGroup
+} from "./forward.js";
+import { RenderPhase } from "./graph.js";
+import { Gpu, Graph, RenderDescribers, Shaders, Views } from "./plugin.js";
+import { Cameras, cameraOf } from "./view.js";
+const GBUFFER_CHANNELS = ["albedo", "normal", "roughness", "metallic", "emissive"];
+const deferredView = (view) => cameraOf(view)?.deferred === true;
+const needsGBuffer = (view) => {
+  const cam = cameraOf(view);
+  return cam !== void 0 && (cam.deferred || cam.gbufferDebug >= 0);
+};
+const GBUFFER_CLEAR = [
+  { resource: "gbuffer0", clear: { r: 0, g: 0, b: 0, a: 1 } },
+  { resource: "gbuffer1", clear: { r: 0, g: 0, b: 0, a: 0 } },
+  { resource: "gbuffer2", clear: { r: 0, g: 0, b: 0, a: 0 } }
+];
+function fillGBuffer(ctx) {
+  const state = ctx.world.resource(ForwardStateResource);
+  const cam = cameraOf(ctx.view);
+  const pv = state.views.get(ctx.view.name);
+  if (pv) drawMaterials(ctx, state, pv, cam, cam.draws, PASS_GBUFFER);
+}
+const gbufferNode = {
+  kind: "render",
+  phase: RenderPhase.Opaque,
+  enabled: deferredView,
+  writes: ["gbuffer0", "gbuffer1", "gbuffer2", "scene-depth"],
+  color: GBUFFER_CLEAR,
+  depth: { resource: "scene-depth", clear: 0 },
+  run: fillGBuffer
+};
+const gbufferFillNode = {
+  kind: "render",
+  phase: RenderPhase.Opaque,
+  enabled: (view) => needsGBuffer(view) && !deferredView(view),
+  writes: [
+    "gbuffer0",
+    "gbuffer1",
+    "gbuffer2",
+    { name: "gbuffer-depth", format: "depth32float" }
+  ],
+  color: GBUFFER_CLEAR,
+  depth: { resource: "gbuffer-depth", clear: 0 },
+  run: fillGBuffer
+};
+function lightingNode() {
+  let layout;
+  let layoutGeneration = -1;
+  const bindGroups = /* @__PURE__ */ new Map();
+  return {
+    kind: "render",
+    phase: RenderPhase.Lighting,
+    enabled: deferredView,
+    reads: [
+      "gbuffer0",
+      "gbuffer1",
+      "gbuffer2",
+      "scene-depth",
+      "clusters",
+      "environment",
+      "shadow-cascades",
+      "shadow-local",
+      "ssao"
+    ],
+    writes: ["scene-color", "hdr"],
+    color: (view) => sceneColor(view, cameraOf(view)?.clear),
+    run: (ctx) => {
+      const gpu = ctx.gpu;
+      const state = ctx.world.resource(ForwardStateResource);
+      const cam = cameraOf(ctx.view);
+      const pv = state.views.get(ctx.view.name);
+      if (!pv) return;
+      const module = ctx.world.resource(Shaders).module(gpu, { root: "shard::pbr::deferred_lighting" });
+      if (!module) {
+        gpu.pipelines.skipped++;
+        return;
+      }
+      if (!layout || layoutGeneration !== gpu.generation) {
+        const F = GPUShaderStage.FRAGMENT;
+        layout = gpu.layouts.bindGroupLayout({
+          label: "deferred/gbuffer",
+          entries: [
+            { binding: 0, visibility: F, texture: { sampleType: "float" } },
+            { binding: 1, visibility: F, texture: { sampleType: "unfilterable-float" } },
+            { binding: 2, visibility: F, texture: { sampleType: "float" } },
+            { binding: 3, visibility: F, texture: { sampleType: "depth" } }
+          ]
+        });
+        layoutGeneration = gpu.generation;
+        bindGroups.clear();
+      }
+      const pipeline = gpu.pipelines.render({
+        label: "deferred/lighting",
+        layout: gpu.layouts.pipelineLayout({
+          label: "deferred/lighting",
+          bindGroupLayouts: [state.layouts.view, layout]
+        }),
+        vertex: { module, entryPoint: "vs" },
+        fragment: { module, entryPoint: "fs", targets: [{ format: "rgba16float" }] }
+      });
+      if (!pipeline) return;
+      const g0 = ctx.texture("gbuffer0");
+      const g1 = ctx.texture("gbuffer1");
+      const g2 = ctx.texture("gbuffer2");
+      const depth = ctx.texture("scene-depth");
+      const key = `${idOf(g0)}/${idOf(g1)}/${idOf(g2)}/${idOf(depth)}`;
+      let bg = bindGroups.get(ctx.view.name);
+      if (!bg || bg.key !== key) {
+        bg = {
+          key,
+          group: gpu.device.createBindGroup({
+            label: "deferred/gbuffer",
+            layout,
+            entries: [
+              { binding: 0, resource: g0.createView() },
+              { binding: 1, resource: g1.createView() },
+              { binding: 2, resource: g2.createView() },
+              { binding: 3, resource: depth.createView() }
+            ]
+          })
+        };
+        bindGroups.set(ctx.view.name, bg);
+      }
+      const pass = ctx.renderPass;
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, viewBindGroup(gpu, ctx.world, pv, cam));
+      pass.setBindGroup(1, bg.group);
+      pass.draw(3);
+    }
+  };
+}
+const forwardOnlyNode = {
+  kind: "render",
+  phase: RenderPhase.Lighting + 10,
+  enabled: (view) => deferredView(view) && cameraOf(view).forwardOnly.length > 0,
+  reads: ["clusters", "shadow-cascades", "shadow-local", "environment", "ssao"],
+  writes: ["scene-color", "scene-depth", "hdr"],
+  color: (view) => sceneColor(view),
+  depth: { resource: "scene-depth" },
+  run: (ctx) => {
+    const state = ctx.world.resource(ForwardStateResource);
+    const cam = cameraOf(ctx.view);
+    const pv = state.views.get(ctx.view.name);
+    if (pv) drawMaterials(ctx, state, pv, cam, cam.forwardOnly, PASS_OPAQUE);
+  }
+};
+function gbufferDebugNode() {
+  const buffers = /* @__PURE__ */ new Map();
+  const channel = new Uint32Array(4);
+  return {
+    kind: "render",
+    phase: RenderPhase.Debug,
+    enabled: (view) => (cameraOf(view)?.gbufferDebug ?? -1) >= 0,
+    reads: ["gbuffer0", "gbuffer1", "gbuffer2"],
+    writes: [{ name: "gbuffer-debug", format: "rgba8unorm" }],
+    sideEffects: true,
+    color: [{ resource: "gbuffer-debug", clear: { r: 0, g: 0, b: 0, a: 1 } }],
+    run: (ctx) => {
+      const gpu = ctx.gpu;
+      const cam = cameraOf(ctx.view);
+      const module = ctx.world.resource(Shaders).module(gpu, { root: "shard::debug::gbuffer" });
+      if (!module) {
+        gpu.pipelines.skipped++;
+        return;
+      }
+      const F = GPUShaderStage.FRAGMENT;
+      const layout = gpu.layouts.bindGroupLayout({
+        label: "debug/gbuffer",
+        entries: [
+          { binding: 0, visibility: F, texture: { sampleType: "float" } },
+          { binding: 1, visibility: F, texture: { sampleType: "unfilterable-float" } },
+          { binding: 2, visibility: F, texture: { sampleType: "float" } },
+          { binding: 3, visibility: F, buffer: { type: "uniform" } }
+        ]
+      });
+      const pipeline = gpu.pipelines.render({
+        label: "debug/gbuffer",
+        layout: gpu.layouts.pipelineLayout({ label: "debug/gbuffer", bindGroupLayouts: [layout] }),
+        vertex: { module, entryPoint: "vs" },
+        fragment: { module, entryPoint: "fs", targets: [{ format: "rgba8unorm" }] }
+      });
+      if (!pipeline) return;
+      let buffer = buffers.get(ctx.view.name);
+      if (!buffer) {
+        buffer = new GpuBuffer(gpu, {
+          label: "debug/gbuffer",
+          usage: GPUBufferUsage.UNIFORM,
+          size: 16
+        });
+        buffers.set(ctx.view.name, buffer);
+      }
+      channel[0] = cam.gbufferDebug;
+      buffer.write(channel);
+      const pass = ctx.renderPass;
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(
+        0,
+        gpu.device.createBindGroup({
+          layout,
+          entries: [
+            { binding: 0, resource: ctx.texture("gbuffer0").createView() },
+            { binding: 1, resource: ctx.texture("gbuffer1").createView() },
+            { binding: 2, resource: ctx.texture("gbuffer2").createView() },
+            { binding: 3, resource: { buffer: buffer.buffer } }
+          ]
+        })
+      );
+      pass.draw(3);
+    }
+  };
+}
+const textureIds = /* @__PURE__ */ new WeakMap();
+let nextTextureId = 1;
+function idOf(t) {
+  let id = textureIds.get(t);
+  if (id === void 0) {
+    id = nextTextureId++;
+    textureIds.set(t, id);
+  }
+  return id;
+}
+async function captureGBuffer(world, camera, channel) {
+  const cam = world.resource(Cameras).get(camera);
+  if (!cam) {
+    throw new ShardError("render/unknown-camera", `Entity ${camera} is not a rendered camera`);
+  }
+  const index = GBUFFER_CHANNELS.indexOf(channel);
+  if (index < 0) {
+    throw new ShardError("render/unknown-buffer", `Unknown G-buffer channel "${channel}"`, {
+      hint: `Channels: ${GBUFFER_CHANNELS.join(", ")}, or depth.`
+    });
+  }
+  cam.gbufferDebug = index;
+  return await world.resource(Graph).capture(`camera:${camera}`, "gbuffer-debug");
+}
+function forwardReason(cam, world) {
+  const reasons = {};
+  const gpuCounts = cam.forwardOnly.cullView >= 0 ? world.resource(Culler).batchCounts.get(cam.forwardOnly) : void 0;
+  for (let d = 0; d < cam.forwardOnly.length; d++) {
+    const item = cam.forwardOnly.items[d];
+    const type = item.batch.material.type;
+    const why = type.standard ? "not deferrable" : `custom lighting (${type.name})`;
+    const n = gpuCounts ? gpuCounts[item.batch.index] ?? 0 : item.count;
+    if (n > 0) reasons[why] = (reasons[why] ?? 0) + n;
+  }
+  if (cam.transparent.visible > 0) reasons.transparent = cam.transparent.visible;
+  return reasons;
+}
+function describeDeferred(world) {
+  const gpu = world.tryResource(Gpu);
+  if (!gpu) return void 0;
+  const views = {};
+  const emissive = gbufferEmissiveFormat(gpu) === "rg11b10ufloat" ? 4 : 8;
+  for (const view of world.resource(Views).list) {
+    const cam = cameraOf(view);
+    if (!cam) continue;
+    const pixels = cam.width * cam.height;
+    views[view.name] = cam.deferred ? {
+      path: "deferred",
+      gbufferBytes: pixels * (4 + 8 + emissive + 4),
+      deferredMeshes: cam.draws.visible,
+      forwardMeshes: cam.forwardOnly.visible + cam.transparent.visible,
+      forwardReasons: forwardReason(cam, world)
+    } : { path: "forward", msaa: cam.msaa };
+  }
+  return { views };
+}
+function addDeferredNodes(app) {
+  const gpu = app.world.resource(Gpu);
+  const graph = app.world.resource(Graph);
+  graph.declare({ name: "gbuffer0", format: "rgba8unorm-srgb" });
+  graph.declare({ name: "gbuffer1", format: "rgba16float" });
+  graph.declare({ name: "gbuffer2", format: gbufferEmissiveFormat(gpu) });
+  graph.addNode("deferred-gbuffer", gbufferNode);
+  graph.addNode("gbuffer-fill", gbufferFillNode);
+  graph.addNode("deferred-lighting", lightingNode());
+  graph.addNode("deferred-forward", forwardOnlyNode);
+  graph.addNode("gbuffer-debug", gbufferDebugNode());
+  app.world.initResource(RenderDescribers).set("deferred", (world) => describeDeferred(world));
+}
+export {
+  GBUFFER_CHANNELS,
+  addDeferredNodes,
+  captureGBuffer,
+  describeDeferred
+};

package/dist/deform.d.ts

@@ -0,0 +1,80 @@
+import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
+import type { Mesh } from '@aethervtt/shard-mesh';
+/**
+ * Per-slot deform record, 12 words (mirrors `Deform` in `shard::mesh` and `shard::cull`):
+ *
+ *   0-3  world bounding sphere (skinned slots; radius 0 means "use the mesh bounds")
+ *   4    first joint matrix (vec4 index into poses; 3 rows per joint)   5  joint count
+ *   6    first word of the mesh's skin data (joints, weights)           7  first morph delta word
+ *   8    vertex count      9  active morph targets (≤ 8)               10  their (index, weight)
+ *                                                                          pairs (vec4 index)
+ *  11    unused
+ */
+export declare const DEFORM_WORDS = 12;
+/** Words of skin data per vertex: joints packed as two u16 pairs, then four f32 weights. */
+export declare const SKIN_WORDS = 6;
+/** Floats per vertex per morph target: position, normal, and tangent deltas. */
+export declare const MORPH_WORDS = 9;
+/** Where a mesh's static deform data sits in the shared vertex-data buffer. */
+export interface MeshDeform {
+    version: number;
+    /** First word of skin data, or -1 without joints and weights. */
+    skinBase: number;
+    /** First word of morph deltas, or -1 without targets. */
+    morphBase: number;
+    vertexCount: number;
+    targetCount: number;
+    /** Per joint: the farthest vertex it mainly moves, in joint space (bounds padding); by skin. */
+    radii: Float32Array | undefined;
+    radiiFor: object | undefined;
+    /** Frame last used, so meshes that went away are dropped when the buffer repacks. */
+    used: number;
+}
+/**
+ * GPU data for skinned and morphed instances: per-slot records, this frame's joint matrices and
+ * morph weights (`poses`), and every deforming mesh's joints, weights, and morph deltas, packed
+ * into one buffer the vertex stage indexes by vertex. Meshes stay in the instanced path; a slot
+ * with `InstanceFlags.Skinned` or `Morph` reads its record.
+ */
+export declare class DeformStore {
+    records: Uint32Array<ArrayBuffer>;
+    recordF32: Float32Array<ArrayBuffer>;
+    /** vec4s: joint matrix rows and morph (index, weight) pairs, written every frame. */
+    poses: Float32Array<ArrayBuffer>;
+    poseCount: number;
+    private vertexData;
+    private vertexF32;
+    private vertexWords;
+    private wasted;
+    readonly meshes: Map<Mesh, MeshDeform>;
+    readonly recordBuffer: GpuBuffer;
+    readonly poseBuffer: GpuBuffer;
+    readonly vertexBuffer: GpuBuffer;
+    private recordLo;
+    private recordHi;
+    private vertexDirty;
+    private generation;
+    private frame;
+    private readonly gpu;
+    constructor(gpu: GpuContext);
+    /** Slots the record array holds. */
+    get capacity(): number;
+    ensureSlots(slots: number): void;
+    beginFrame(): void;
+    /** Reserves `n` vec4s of this frame's poses; returns the first index. */
+    allocPoses(n: number): number;
+    /** Marks a slot's record for upload (after writing `records` at slot * DEFORM_WORDS). */
+    touch(slot: number): void;
+    /** Clears a slot's record (no joints, no targets, no sphere). */
+    clear(slot: number): void;
+    /** Packs a mesh's joints, weights, and morph deltas (once per mesh version). */
+    meshData(mesh: Mesh): MeshDeform;
+    private wordsOf;
+    private reserve;
+    private pack;
+    private repack;
+    /** Uploads changed records, this frame's poses, and (when it changed) the vertex data. */
+    upload(): void;
+    /** Bytes of deform data on the GPU (for describe). */
+    get vertexBytes(): number;
+}

package/dist/deform.js

@@ -0,0 +1,213 @@
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+const DEFORM_WORDS = 12;
+const DEFORM_BYTES = DEFORM_WORDS * 4;
+const SKIN_WORDS = 6;
+const MORPH_WORDS = 9;
+class DeformStore {
+  records = new Uint32Array(DEFORM_WORDS * 256);
+  recordF32 = new Float32Array(this.records.buffer);
+  /** vec4s: joint matrix rows and morph (index, weight) pairs, written every frame. */
+  poses = new Float32Array(4 * 1024);
+  poseCount = 0;
+  vertexData = new Uint32Array(1024);
+  vertexF32 = new Float32Array(this.vertexData.buffer);
+  vertexWords = 0;
+  wasted = 0;
+  meshes = /* @__PURE__ */ new Map();
+  recordBuffer;
+  poseBuffer;
+  vertexBuffer;
+  recordLo = Number.POSITIVE_INFINITY;
+  recordHi = -1;
+  vertexDirty = true;
+  generation;
+  frame = 0;
+  gpu;
+  constructor(gpu) {
+    this.gpu = gpu;
+    this.generation = gpu.generation;
+    const usage = GPUBufferUsage.STORAGE;
+    this.recordBuffer = new GpuBuffer(gpu, {
+      label: "deform/records",
+      usage,
+      size: DEFORM_BYTES * 256
+    });
+    this.poseBuffer = new GpuBuffer(gpu, { label: "deform/poses", usage, size: 16 * 1024 });
+    this.vertexBuffer = new GpuBuffer(gpu, { label: "deform/vertices", usage, size: 4096 });
+  }
+  /** Slots the record array holds. */
+  get capacity() {
+    return this.records.length / DEFORM_WORDS;
+  }
+  ensureSlots(slots) {
+    if (slots <= this.capacity) return;
+    let n = this.capacity;
+    while (n < slots) n *= 2;
+    const grown = new Uint32Array(n * DEFORM_WORDS);
+    grown.set(this.records);
+    this.records = grown;
+    this.recordF32 = new Float32Array(grown.buffer);
+    this.recordLo = 0;
+    this.recordHi = this.capacity - 1;
+  }
+  beginFrame() {
+    this.poseCount = 0;
+    this.frame++;
+  }
+  /** Reserves `n` vec4s of this frame's poses; returns the first index. */
+  allocPoses(n) {
+    const base = this.poseCount;
+    if ((base + n) * 4 > this.poses.length) {
+      let size = this.poses.length * 2;
+      while (size < (base + n) * 4) size *= 2;
+      const grown = new Float32Array(size);
+      grown.set(this.poses.subarray(0, base * 4));
+      this.poses = grown;
+    }
+    this.poseCount = base + n;
+    return base;
+  }
+  /** Marks a slot's record for upload (after writing `records` at slot * DEFORM_WORDS). */
+  touch(slot) {
+    if (slot < this.recordLo) this.recordLo = slot;
+    if (slot > this.recordHi) this.recordHi = slot;
+  }
+  /** Clears a slot's record (no joints, no targets, no sphere). */
+  clear(slot) {
+    if (slot >= this.capacity) return;
+    this.records.fill(0, slot * DEFORM_WORDS, (slot + 1) * DEFORM_WORDS);
+    this.touch(slot);
+  }
+  /** Packs a mesh's joints, weights, and morph deltas (once per mesh version). */
+  meshData(mesh) {
+    let entry = this.meshes.get(mesh);
+    if (entry && entry.version === mesh.version) {
+      entry.used = this.frame;
+      return entry;
+    }
+    if (entry) this.wasted += this.wordsOf(entry);
+    const n = mesh.vertexCount;
+    entry = {
+      version: mesh.version,
+      skinBase: -1,
+      morphBase: -1,
+      vertexCount: n,
+      targetCount: mesh.targets?.length ?? 0,
+      radii: void 0,
+      radiiFor: void 0,
+      used: this.frame
+    };
+    this.meshes.set(mesh, entry);
+    if (this.wasted > 1 << 16 && this.wasted > this.vertexWords / 2) this.repack();
+    else this.pack(mesh, entry);
+    return entry;
+  }
+  wordsOf(entry) {
+    return (entry.skinBase >= 0 ? entry.vertexCount * SKIN_WORDS : 0) + entry.targetCount * entry.vertexCount * MORPH_WORDS;
+  }
+  reserve(words) {
+    const base = this.vertexWords;
+    if (base + words > this.vertexData.length) {
+      let size = this.vertexData.length * 2;
+      while (size < base + words) size *= 2;
+      const grown = new Uint32Array(size);
+      grown.set(this.vertexData.subarray(0, base));
+      this.vertexData = grown;
+      this.vertexF32 = new Float32Array(grown.buffer);
+    }
+    this.vertexWords = base + words;
+    this.vertexDirty = true;
+    return base;
+  }
+  pack(mesh, entry) {
+    const n = mesh.vertexCount;
+    if (mesh.joints && mesh.weights) {
+      const base = this.reserve(n * SKIN_WORDS);
+      entry.skinBase = base;
+      const j = mesh.joints;
+      const w = mesh.weights;
+      const u = this.vertexData;
+      const f = this.vertexF32;
+      for (let v = 0; v < n; v++) {
+        const o = base + v * SKIN_WORDS;
+        u[o] = (j[v * 4] | j[v * 4 + 1] << 16) >>> 0;
+        u[o + 1] = (j[v * 4 + 2] | j[v * 4 + 3] << 16) >>> 0;
+        const sum = w[v * 4] + w[v * 4 + 1] + w[v * 4 + 2] + w[v * 4 + 3];
+        const k = sum > 1e-6 ? 1 / sum : 0;
+        for (let c = 0; c < 4; c++) f[o + 2 + c] = w[v * 4 + c] * k;
+        if (sum <= 1e-6) f[o + 2] = 1;
+      }
+    }
+    const targets = mesh.targets;
+    if (targets?.length) {
+      const base = this.reserve(targets.length * n * MORPH_WORDS);
+      entry.morphBase = base;
+      const f = this.vertexF32;
+      for (let t = 0; t < targets.length; t++) {
+        const target = targets[t];
+        for (let v = 0; v < n; v++) {
+          const o = base + (t * n + v) * MORPH_WORDS;
+          for (let c = 0; c < 3; c++) {
+            f[o + c] = target.positions[v * 3 + c];
+            f[o + 3 + c] = target.normals ? target.normals[v * 3 + c] : 0;
+            f[o + 6 + c] = target.tangents ? target.tangents[v * 3 + c] : 0;
+          }
+        }
+      }
+    }
+  }
+  repack() {
+    this.vertexWords = 0;
+    this.wasted = 0;
+    for (const [mesh, entry] of this.meshes) {
+      if (entry.used < this.frame - 600 && mesh.version === entry.version) {
+        this.meshes.delete(mesh);
+        continue;
+      }
+      entry.version = mesh.version;
+      entry.vertexCount = mesh.vertexCount;
+      entry.targetCount = mesh.targets?.length ?? 0;
+      entry.skinBase = -1;
+      entry.morphBase = -1;
+      entry.radii = void 0;
+      entry.radiiFor = void 0;
+      this.pack(mesh, entry);
+    }
+    this.vertexDirty = true;
+  }
+  /** Uploads changed records, this frame's poses, and (when it changed) the vertex data. */
+  upload() {
+    if (this.generation !== this.gpu.generation) {
+      this.generation = this.gpu.generation;
+      this.vertexDirty = true;
+      this.recordLo = 0;
+      this.recordHi = this.capacity - 1;
+    }
+    if (this.recordBuffer.ensureCapacity(this.records.byteLength)) {
+      this.recordLo = 0;
+      this.recordHi = this.capacity - 1;
+    }
+    if (this.recordHi >= this.recordLo) {
+      const lo = this.recordLo * DEFORM_WORDS;
+      const n = (this.recordHi - this.recordLo + 1) * DEFORM_WORDS;
+      this.recordBuffer.write(this.records, lo * 4, lo, n);
+    }
+    this.recordLo = Number.POSITIVE_INFINITY;
+    this.recordHi = -1;
+    if (this.poseCount > 0) this.poseBuffer.write(this.poses, 0, 0, this.poseCount * 4);
+    if (this.vertexDirty) {
+      this.vertexDirty = false;
+      if (this.vertexWords > 0) this.vertexBuffer.write(this.vertexData, 0, 0, this.vertexWords);
+    }
+  }
+  /** Bytes of deform data on the GPU (for describe). */
+  get vertexBytes() {
+    return this.vertexWords * 4;
+  }
+}
+export {
+  DEFORM_WORDS,
+  DeformStore,
+  MORPH_WORDS,
+  SKIN_WORDS
+};

package/dist/describe-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The lighting, culling, and renderScale sections of `render.describe`, for agents and the editor.
+ * Only introspection: an app that ships without it renders the same.
+ */
+export declare const renderDescribePlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/describe-plugin.js

@@ -0,0 +1,19 @@
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { describeCulling, describeLighting } from "./debug-views.js";
+import { RenderDescribers } from "./plugin.js";
+import { describeRenderScale } from "./render-scale.js";
+const renderDescribePlugin = definePlugin({
+  name: "render/describe",
+  dependencies: ["render/forward"],
+  build() {
+  },
+  ready(app) {
+    const describers = app.world.initResource(RenderDescribers);
+    describers.set("lighting", (world) => describeLighting(world));
+    describers.set("culling", (world) => describeCulling(world));
+    describers.set("renderScale", (world) => describeRenderScale(world));
+  }
+});
+export {
+  renderDescribePlugin
+};

package/dist/display-nodes.d.ts

@@ -0,0 +1,5 @@
+import type { World } from '@aethervtt/shard-core';
+/** White balance as LMS channel gains (Unity's method, from temperature and tint in −1..1). */
+export declare function whiteBalance(temperature: number, tint: number, out: Float32Array): Float32Array;
+/** Adds the display stage (tonemap, upscale) to the graph. */
+export declare function addDisplayNodes(world: World): void;