@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/decals.js

@@ -0,0 +1,326 @@
+import {
+  affine,
+  defineResource,
+  defineSystem
+} from "@aethervtt/shard-core";
+import { FrameDemand, Time } from "@aethervtt/shard-runtime";
+import { GlobalTransform } from "@aethervtt/shard-transform";
+import { Materials, Meshes } from "./assets.js";
+import { Mesh3d, MeshMaterial, MorphWeights, SkinnedMesh } from "./instances.js";
+import { RenderLayers } from "./layers.js";
+import { isTransparent } from "./materials.js";
+import { Decal, DecalReceiver } from "./vfx.js";
+import {
+  createRecord,
+  matrixChanged,
+  number,
+  point,
+  recordDescription,
+  refreshRecord,
+  VFX_STRIDE
+} from "./vfx-state.js";
+import { ComputedVisibility } from "./visibility.js";
+const DECAL_TRIANGLE_BUDGET = 32768;
+const Decals = defineResource("render/Decals", {
+  init: () => ({
+    records: [],
+    receivers: [],
+    receiverByEntity: /* @__PURE__ */ new Map(),
+    frame: 0,
+    revision: 0,
+    rejected: 0
+  })
+});
+function create(world, entity) {
+  const max = world.get(entity, Decal).maxVertices;
+  return {
+    ...createRecord(world, entity, Decal, "decal", max),
+    inverse: new Float64Array(12),
+    settings: new Float64Array(8).fill(NaN),
+    geometryCount: 0,
+    receiverRevision: -1,
+    rebuilds: 0,
+    ranges: [],
+    clipA: new Float64Array(48),
+    clipB: new Float64Array(48),
+    worldTriangle: new Float64Array(9)
+  };
+}
+function clipPlane(input, count, output, axis, sign, half) {
+  let n = 0;
+  for (let i = 0; i < count; i++) {
+    const a = (i + count - 1) % count * 3, b = i * 3;
+    const da = half - sign * input[a + axis], db = half - sign * input[b + axis];
+    if (da >= 0 !== db >= 0) {
+      const f = da / (da - db);
+      for (let k = 0; k < 3; k++)
+        output[n * 3 + k] = input[a + k] + (input[b + k] - input[a + k]) * f;
+      n++;
+    }
+    if (db >= 0) {
+      for (let k = 0; k < 3; k++) output[n * 3 + k] = input[b + k];
+      n++;
+    }
+  }
+  return n;
+}
+function intersects(r, receiver, sx, sy, sz) {
+  const bounds = receiver.mesh.bounds, scratch = r.worldTriangle;
+  let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (let i = 0; i < 8; i++) {
+    point(
+      scratch,
+      0,
+      receiver.matrix,
+      bounds[i & 1 ? 3 : 0],
+      bounds[i & 2 ? 4 : 1],
+      bounds[i & 4 ? 5 : 2]
+    );
+    point(scratch, 3, r.inverse, scratch[0], scratch[1], scratch[2]);
+    minX = Math.min(minX, scratch[3]);
+    minY = Math.min(minY, scratch[4]);
+    minZ = Math.min(minZ, scratch[5]);
+    maxX = Math.max(maxX, scratch[3]);
+    maxY = Math.max(maxY, scratch[4]);
+    maxZ = Math.max(maxZ, scratch[5]);
+  }
+  return minX <= sx / 2 && maxX >= -sx / 2 && minY <= sy / 2 && maxY >= -sy / 2 && minZ <= sz / 2 && maxZ >= -sz / 2;
+}
+function projectDecal(r, receivers) {
+  r.count = 0;
+  r.geometryCount = 0;
+  r.ranges.length = 0;
+  r.error = null;
+  r.rebuilds++;
+  if (!affine.invert(r.inverse, r.matrix)) {
+    r.error = "render/decal-singular";
+    return;
+  }
+  const size = r.columns.size, so = r.row * 3;
+  const sx = size[so], sy = size[so + 1], sz = size[so + 2];
+  if (!(sx > 0 && sy > 0 && sz > 0)) {
+    r.error = "render/decal-size";
+    return;
+  }
+  const mask = number(r, "receiverMask"), offset = number(r, "offset"), cos = Math.cos(number(r, "maxAngle") * Math.PI / 180);
+  const zx = r.matrix[2], zy = r.matrix[6], zz = r.matrix[10], zl = Math.sqrt(zx * zx + zy * zy + zz * zz);
+  let tested = 0;
+  for (let ri = 0; ri < receivers.length; ri++) {
+    const receiver = receivers[ri], mesh = receiver.mesh;
+    if (!receiver.visible || !(receiver.mask & mask) || !mesh || !intersects(r, receiver, sx, sy, sz))
+      continue;
+    if (receiver.unsupported) {
+      r.error = "render/decal-unsupported-receiver";
+      break;
+    }
+    const start = r.count, positions = mesh.positions, indices = mesh.indices;
+    const triangles = Math.floor((indices ? indices.length : positions.length / 3) / 3);
+    if (tested + triangles > DECAL_TRIANGLE_BUDGET) {
+      r.error = "render/decal-input-budget";
+      break;
+    }
+    tested += triangles;
+    for (let t = 0; t < triangles; t++) {
+      for (let v = 0; v < 3; v++) {
+        const vi = (indices ? indices[t * 3 + v] : t * 3 + v) * 3;
+        point(
+          r.worldTriangle,
+          v * 3,
+          receiver.matrix,
+          positions[vi],
+          positions[vi + 1],
+          positions[vi + 2]
+        );
+      }
+      const w = r.worldTriangle;
+      const ax = w[3] - w[0], ay = w[4] - w[1], az = w[5] - w[2], bx = w[6] - w[0], by = w[7] - w[1], bz = w[8] - w[2];
+      let nx = ay * bz - az * by, ny = az * bx - ax * bz, nz = ax * by - ay * bx;
+      const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+      if (length < 1e-12) continue;
+      nx /= length;
+      ny /= length;
+      nz /= length;
+      if ((nx * zx + ny * zy + nz * zz) / zl < cos) continue;
+      for (let v = 0; v < 3; v++)
+        point(r.clipA, v * 3, r.inverse, w[v * 3], w[v * 3 + 1], w[v * 3 + 2]);
+      let a = r.clipA, b = r.clipB, count = 3;
+      for (let plane = 0; plane < 6 && count; plane++) {
+        const axis = plane >> 1, half = (axis === 0 ? sx : axis === 1 ? sy : sz) * 0.5;
+        count = clipPlane(a, count, b, axis, plane % 2 ? -1 : 1, half);
+        const swap = a;
+        a = b;
+        b = swap;
+      }
+      if (count < 3) continue;
+      if (r.count + (count - 2) * 3 > r.vertices.length / VFX_STRIDE) {
+        r.error = "render/decal-output-budget";
+        break;
+      }
+      for (let fan = 1; fan < count - 1; fan++)
+        for (let v = 0; v < 3; v++) {
+          const at = (v === 0 ? 0 : v === 1 ? fan : fan + 1) * 3, o = r.count++ * VFX_STRIDE;
+          point(w, 0, r.matrix, a[at], a[at + 1], a[at + 2]);
+          r.vertices[o] = w[0] + nx * offset;
+          r.vertices[o + 1] = w[1] + ny * offset;
+          r.vertices[o + 2] = w[2] + nz * offset;
+          r.vertices[o + 3] = 0;
+          r.vertices[o + 4] = 0;
+          r.vertices[o + 5] = 0;
+          r.vertices[o + 6] = a[at] / sx + 0.5;
+          r.vertices[o + 7] = 0.5 - a[at + 1] / sy;
+          for (let k = 8; k < 12; k++) r.vertices[o + k] = 1;
+          r.vertices[o + 12] = 0;
+          r.vertices[o + 13] = 0;
+        }
+    }
+    if (r.error) break;
+    if (r.count > start)
+      r.ranges.push({
+        start,
+        count: r.count - start,
+        entity: receiver.entity,
+        layers: receiver.layers
+      });
+  }
+  if (r.error) {
+    r.count = 0;
+    r.ranges.length = 0;
+  }
+  r.geometryCount = r.count;
+  r.version++;
+}
+const updateDecals = defineSystem({
+  name: "render/decals-update",
+  setup: (world) => ({
+    q: world.query({ with: [Decal, GlobalTransform] }),
+    receivers: world.query({ with: [DecalReceiver, Mesh3d, GlobalTransform] })
+  }),
+  run({ q, receivers }, world) {
+    const state = world.resource(Decals), meshes = world.resource(Meshes), delta = world.resource(Time).delta;
+    state.frame++;
+    state.rejected = 0;
+    for (let ti = 0; ti < receivers.tables.length; ti++) {
+      const table = receivers.tables[ti], mask = table.column(DecalReceiver, "mask"), refs = table.column(Mesh3d, "mesh");
+      for (let row = 0; row < table.count; row++) {
+        const entity = table.entities[row];
+        let receiver = state.receiverByEntity.get(entity);
+        if (!receiver) {
+          receiver = {
+            entity,
+            matrix: new Float64Array(12),
+            mesh: void 0,
+            version: -1,
+            mask: -1,
+            visible: false,
+            unsupported: false,
+            layers: 1,
+            seen: 0
+          };
+          state.receivers.push(receiver);
+          state.receiverByEntity.set(entity, receiver);
+          state.revision++;
+        }
+        const mesh = meshes.get(refs[row]), version = mesh?.version ?? -1;
+        const visible = !table.has(ComputedVisibility) || table.column(ComputedVisibility, "visible")[row] !== 0;
+        const layers = table.has(RenderLayers) ? table.column(RenderLayers, "mask")[row] : 1;
+        let unsupported = !!mesh && (!mesh.positions || !!mesh.joints || !!mesh.targets?.length || table.has(SkinnedMesh) || table.has(MorphWeights));
+        if (table.has(MeshMaterial)) {
+          const material = world.tryResource(Materials)?.get(table.column(MeshMaterial, "material")[row]);
+          if (material && isTransparent(material.type.blendOf(material.value))) unsupported = true;
+        }
+        if (matrixChanged(world, entity, receiver.matrix) || receiver.mesh !== mesh || receiver.version !== version || receiver.mask !== mask[row] || receiver.visible !== visible || receiver.layers !== layers || receiver.unsupported !== unsupported)
+          state.revision++;
+        receiver.mesh = mesh;
+        receiver.version = version;
+        receiver.mask = mask[row];
+        receiver.visible = visible;
+        receiver.layers = layers;
+        receiver.unsupported = unsupported;
+        receiver.seen = state.frame;
+      }
+    }
+    for (let i = state.receivers.length - 1; i >= 0; i--)
+      if (state.receivers[i].seen !== state.frame) {
+        state.receiverByEntity.delete(state.receivers[i].entity);
+        state.receivers.splice(i, 1);
+        state.revision++;
+      }
+    let demand = false;
+    for (let ti = 0; ti < q.tables.length; ti++) {
+      const table = q.tables[ti];
+      for (let row = 0; row < table.count; row++) {
+        const entity = table.entities[row];
+        const maxVertices = table.column(Decal, "maxVertices")[row];
+        if (maxVertices < 3 || maxVertices > 65535) {
+          state.rejected++;
+          continue;
+        }
+        let r;
+        for (let i = 0; i < state.records.length; i++)
+          if (state.records[i].entity === entity) {
+            r = state.records[i];
+            break;
+          }
+        if (!r) {
+          if (state.records.length >= 64) {
+            state.rejected++;
+            continue;
+          }
+          r = create(world, entity);
+          state.records.push(r);
+        }
+        refreshRecord(world, r);
+        r.seen = state.frame;
+        let changed = matrixChanged(world, entity, r.matrix);
+        const size = r.columns.size;
+        for (let i = 0; i < 8; i++) {
+          const value = i < 3 ? size[row * 3 + i] : i === 3 ? number(r, "receiverMask") : i === 4 ? number(r, "maxAngle") : i === 5 ? number(r, "offset") : i === 6 ? number(r, "maxVertices") : 0;
+          if (r.settings[i] !== value) changed = true;
+          r.settings[i] = value;
+        }
+        const capacity = number(r, "maxVertices") * VFX_STRIDE;
+        if (r.vertices.length !== capacity) {
+          r.vertices = new Float32Array(capacity);
+          changed = true;
+        }
+        const playing = !!number(r, "playing"), paused = !!number(r, "paused"), lifetime = number(r, "lifetime");
+        if (playing && !r.wasPlaying) r.age = 0;
+        r.wasPlaying = playing;
+        if (playing && !paused) r.age += delta;
+        if (changed || r.receiverRevision !== state.revision) {
+          projectDecal(r, state.receivers);
+          r.receiverRevision = state.revision;
+        }
+        r.count = playing && (!lifetime || r.age < lifetime) ? r.geometryCount : 0;
+        if (lifetime && number(r, "fadeOut") > 0)
+          r.opacity *= Math.min(1, Math.max(0, (lifetime - r.age) / number(r, "fadeOut")));
+        if (playing && !paused && lifetime > 0 && r.age < lifetime) demand = true;
+      }
+    }
+    for (let i = state.records.length - 1; i >= 0; i--)
+      if (state.records[i].seen !== state.frame) state.records.splice(i, 1);
+    world.tryResource(FrameDemand)?.set("render/decals", demand);
+  }
+});
+function describeDecals(world) {
+  const s = world.resource(Decals);
+  return {
+    rejected: s.rejected,
+    error: s.rejected ? "render/decal-limit" : null,
+    receivers: s.receivers.length,
+    records: s.records.map((r) => ({
+      ...recordDescription(r),
+      cpuBytes: r.vertices.byteLength + r.matrix.byteLength + r.inverse.byteLength + r.settings.byteLength + r.clipA.byteLength + r.clipB.byteLength + r.worldTriangle.byteLength,
+      rebuilds: r.rebuilds,
+      triangles: r.geometryCount / 3
+    }))
+  };
+}
+export {
+  DECAL_TRIANGLE_BUDGET,
+  Decals,
+  clipPlane,
+  describeDecals,
+  projectDecal,
+  updateDecals
+};

package/dist/deferred-shaders.js

@@ -66,6 +66,7 @@ import shard::mesh::mesh_vertex_at;
 import shard::pbr::material::pbr_input;
 import shard::pbr::standard::material;
 import shard::pbr::gbuffer::{ GBufferOutput, pack_gbuffer };
+@if(CUTAWAY) import shard::cutaway::cutaway_clip;
 
 const FLAG_RECEIVER: u32 = 4u;
 
@@ -85,6 +86,7 @@ const FLAG_RECEIVER: u32 = 4u;
 
 /** The surface stage only: what the material makes of the surface, packed for lighting. */
 @fragment fn fs(in: VertexOutput) -> GBufferOutput {
+  @if(CUTAWAY) cutaway_clip(in.world_position, in.clip.xy, in.flags);
   let p = pbr_input(in);
   @if(MASK) if (p.alpha < material.alphaCutoff) { discard; }
   return pack_gbuffer(p, (in.flags & FLAG_RECEIVER) != 0u, view.exposure);

package/dist/deferred.js

@@ -1,10 +1,13 @@
 import { ShardError } from "@aethervtt/shard-core";
 import { GpuBuffer } from "@aethervtt/shard-gpu";
 import { Culler } from "./culling.js";
+import { addRenderFeatures } from "./features.js";
+import { FoliagePath } from "./foliage-path.js";
 import {
   drawMaterials,
   ForwardStateResource,
   gbufferEmissiveFormat,
+  INTERIOR_DEFINES,
   PASS_GBUFFER,
   PASS_OPAQUE,
   sceneColor,
@@ -12,6 +15,7 @@ import {
 } from "./forward.js";
 import { RenderPhase } from "./graph.js";
 import { Gpu, Graph, RenderDescribers, Shaders, Views } from "./plugin.js";
+import { depthReadEntry } from "./tier.js";
 import { Cameras, cameraOf } from "./view.js";
 const GBUFFER_CHANNELS = ["albedo", "normal", "roughness", "metallic", "emissive"];
 const deferredView = (view) => cameraOf(view)?.deferred === true;
@@ -28,7 +32,9 @@ 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);
+  if (!pv) return;
+  drawMaterials(ctx, state, pv, cam, cam.draws, PASS_GBUFFER);
+  ctx.world.tryResource(FoliagePath)?.draw(ctx, cam, PASS_GBUFFER, ctx.renderPass);
 }
 const gbufferNode = {
   kind: "render",
@@ -80,7 +86,11 @@ function lightingNode() {
       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" });
+      const mode = state.interiorMode;
+      const module = ctx.world.resource(Shaders).module(
+        gpu,
+        mode !== 0 ? { root: "shard::pbr::deferred_lighting", defines: INTERIOR_DEFINES[mode] } : { root: "shard::pbr::deferred_lighting" }
+      );
       if (!module) {
         gpu.pipelines.skipped++;
         return;
@@ -93,7 +103,7 @@ function lightingNode() {
             { 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" } }
+            depthReadEntry(gpu, 3, F)
           ]
         });
         layoutGeneration = gpu.generation;
@@ -271,7 +281,7 @@ function describeDeferred(world) {
       deferredMeshes: cam.draws.visible,
       forwardMeshes: cam.forwardOnly.visible + cam.transparent.visible,
       forwardReasons: forwardReason(cam, world)
-    } : { path: "forward", msaa: cam.msaa };
+    } : cam.msaaCapped ? { path: "forward", msaa: cam.msaa, msaaLimit: "the device can't multisample rgba16float" } : { path: "forward", msaa: cam.msaa };
   }
   return { views };
 }
@@ -281,6 +291,20 @@ function addDeferredNodes(app) {
   graph.declare({ name: "gbuffer0", format: "rgba8unorm-srgb" });
   graph.declare({ name: "gbuffer1", format: "rgba16float" });
   graph.declare({ name: "gbuffer2", format: gbufferEmissiveFormat(gpu) });
+  addRenderFeatures(app.world, {
+    name: "render/deferred",
+    description: "The deferred path: G-buffer, lighting, and forward-only materials.",
+    nodes: [
+      "deferred-gbuffer",
+      "gbuffer-fill",
+      "deferred-lighting",
+      "deferred-forward",
+      "gbuffer-debug"
+    ],
+    baseline: {
+      strategy: "The same passes, reading lights and clusters through the baseline accessors"
+    }
+  });
   graph.addNode("deferred-gbuffer", gbufferNode);
   graph.addNode("gbuffer-fill", gbufferFillNode);
   graph.addNode("deferred-lighting", lightingNode());

package/dist/deform.d.ts

@@ -1,5 +1,6 @@
-import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
+import type { GpuContext } from '@aethervtt/shard-gpu';
 import type { Mesh } from '@aethervtt/shard-mesh';
+import { DataStore } from './data-store.js';
 /**
  * Per-slot deform record, 12 words (mirrors `Deform` in `shard::mesh` and `shard::cull`):
  *
@@ -47,9 +48,9 @@ export declare class DeformStore {
     private vertexWords;
     private wasted;
     readonly meshes: Map<Mesh, MeshDeform>;
-    readonly recordBuffer: GpuBuffer;
-    readonly poseBuffer: GpuBuffer;
-    readonly vertexBuffer: GpuBuffer;
+    readonly recordBuffer: DataStore;
+    readonly poseBuffer: DataStore;
+    readonly vertexBuffer: DataStore;
     private recordLo;
     private recordHi;
     private vertexDirty;

package/dist/deform.js

@@ -1,4 +1,4 @@
-import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { DataStore } from "./data-store.js";
 const DEFORM_WORDS = 12;
 const DEFORM_BYTES = DEFORM_WORDS * 4;
 const SKIN_WORDS = 6;
@@ -26,14 +26,9 @@ class DeformStore {
   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 });
+    this.recordBuffer = new DataStore(gpu, { label: "deform/records", size: DEFORM_BYTES * 256 });
+    this.poseBuffer = new DataStore(gpu, { label: "deform/poses", size: 16 * 1024 });
+    this.vertexBuffer = new DataStore(gpu, { label: "deform/vertices", size: 4096 });
   }
   /** Slots the record array holds. */
   get capacity() {

package/dist/describe-plugin.d.ts

@@ -1,5 +1,7 @@
 /**
- * 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.
+ * The lighting, culling, renderScale, surfaces, uploads, and frames sections of `render.describe`,
+ * and the
+ * `gpu.stats` method, 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

@@ -1,17 +1,89 @@
-import { definePlugin } from "@aethervtt/shard-runtime";
+import { defineSchema, t } from "@aethervtt/shard-core";
+import { definePlugin, FrameDemand } from "@aethervtt/shard-runtime";
 import { describeCulling, describeLighting } from "./debug-views.js";
-import { RenderDescribers } from "./plugin.js";
+import { GroundLayer } from "./layers.js";
+import { Gpu, RenderDescribers, RenderOptions, Window } from "./plugin.js";
 import { describeRenderScale } from "./render-scale.js";
+import { RenderStats } from "./stats.js";
+import { Cameras } from "./view.js";
+function describeSurfaces(world) {
+  const window = world.tryResource(Window);
+  return world.resource(Gpu).surfaces.map((s) => ({
+    label: s.label,
+    size: [s.width, s.height],
+    alpha: s.alpha,
+    pixelRatio: s.pixelRatio,
+    thisApp: s === window
+  }));
+}
+function describeUploads(world) {
+  const stats = world.resource(RenderStats);
+  const bytes = (r) => ({
+    bytes: { ...r.bytes },
+    sceneBytes: r.sceneBytes,
+    created: r.created
+  });
+  const rebuilds = (r) => ({
+    chunksRebuilt: r.chunksRebuilt,
+    meshesRebuilt: r.meshesRebuilt,
+    shadowMapsRendered: r.shadowMapsRendered
+  });
+  return {
+    frames: stats.frames,
+    lastFrame: bytes(stats.lastFrame),
+    recent: bytes(stats.recent),
+    rebuilds: { lastFrame: rebuilds(stats.lastFrame), recent: rebuilds(stats.recent) }
+  };
+}
+function describeGround(world) {
+  const bands = {};
+  world.query({ with: [GroundLayer] }).each((_e, row, table) => {
+    const band = String(table.column(GroundLayer, "band")[row]);
+    bands[band] = (bands[band] ?? 0) + 1;
+  });
+  const views = {};
+  for (const cam of world.resource(Cameras).values())
+    views[`camera:${cam.entity}`] = {
+      instances: cam.ground.visible + cam.overlay.visible,
+      draws: cam.ground.length + cam.overlay.length
+    };
+  return { bands, views };
+}
+const gpuStats = {
+  name: "gpu.stats",
+  description: "Live GPU buffers and textures, by owner: each app's render plugin is one, and 'gpu' holds what apps on the device share.",
+  params: defineSchema("render/GpuStatsParams", {
+    owner: t.string({ description: "One owner. Empty: this app, every owner, and the total." })
+  }),
+  handler: ({ world }, p) => {
+    const gpu = world.resource(Gpu);
+    if (p.owner) return { owner: p.owner, ...gpu.stats(p.owner) };
+    return {
+      owner: world.resource(RenderOptions).owner,
+      total: gpu.stats(),
+      owners: Object.fromEntries(gpu.owners().map((o) => [o, gpu.stats(o)]))
+    };
+  }
+};
 const renderDescribePlugin = definePlugin({
   name: "render/describe",
   dependencies: ["render/forward"],
-  build() {
+  build(app) {
+    app.addMethod(gpuStats);
   },
   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));
+    describers.set("surfaces", describeSurfaces);
+    describers.set("uploads", describeUploads);
+    describers.set("ground", describeGround);
+    describers.set("frames", (world) => world.resource(FrameDemand).describe());
+    describers.set(
+      "gpuObjects",
+      (world) => world.resource(Gpu).stats(world.resource(RenderOptions).owner)
+    );
   }
 });
 export {