@aethervtt/shard-render 0.0.1 → 0.1.0

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,12 @@
 import { ShardError } from "@aethervtt/shard-core";
 import { GpuBuffer } from "@aethervtt/shard-gpu";
 import { Culler } from "./culling.js";
+import { addRenderFeatures } from "./features.js";
 import {
   drawMaterials,
   ForwardStateResource,
   gbufferEmissiveFormat,
+  INTERIOR_DEFINES,
   PASS_GBUFFER,
   PASS_OPAQUE,
   sceneColor,
@@ -12,6 +14,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;
@@ -80,7 +83,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 +100,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 +278,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 +288,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 {

package/dist/display-nodes.js

@@ -1,3 +1,4 @@
+import { addRenderFeatures } from "./features.js";
 import { Textures } from "@aethervtt/shard-texture";
 import { GpuAssetsResource } from "./gpu-assets.js";
 import { RenderPhase } from "./graph.js";
@@ -53,15 +54,17 @@ function tonemapNode() {
       }
       const format = ctx.texture("ldr").format;
       const srgb = format.endsWith("-srgb");
+      const alpha = cam.alphaOutput;
       const pipeline = cache.render(
         ctx,
-        `tonemap/${format}`,
+        `tonemap/${format}${alpha ? "/alpha" : ""}`,
         "shard::post::tonemap",
         "fs",
         [layout],
         [{ format }],
         {
-          SRGB_TARGET: srgb
+          SRGB_TARGET: srgb,
+          TRANSPARENT: alpha
         }
       );
       if (!pipeline) return;
@@ -144,13 +147,15 @@ function upscaleNode() {
       const input = ctx.texture("display");
       const target = ctx.texture("view-target");
       const format = target.format;
+      const alpha = cameraOf(ctx.view).alphaOutput;
       const pipeline = cache.render(
         ctx,
-        `upscale/${format}`,
+        `upscale/${format}${alpha ? "/alpha" : ""}`,
         "shard::post::upscale",
         "fs",
         [layout],
-        [{ format }]
+        [{ format }],
+        { TRANSPARENT: alpha }
       );
       if (!pipeline) return;
       const settings = ctx.world.tryResource(RenderScale);
@@ -180,6 +185,12 @@ function upscaleNode() {
 function addDisplayNodes(world) {
   const graph = world.resource(Graph);
   graph.declare({ name: "display", format: "view" });
+  addRenderFeatures(world, {
+    name: "render/display",
+    description: "Tonemapping and the upscale to the display.",
+    nodes: ["tonemap", "post/upscale"],
+    baseline: { strategy: "The same fragment passes" }
+  });
   graph.addNode("tonemap", tonemapNode());
   graph.addNode("post/upscale", upscaleNode());
 }

package/dist/dynamic-resolution.d.ts

@@ -27,6 +27,8 @@ export declare class RenderScaleController {
     private probeAge;
     private probeWait;
     private hold;
+    /** Verifying an upward probe: it needs frames to measure, so on-demand apps keep rendering. */
+    get probing(): boolean;
     /**
      * One frame. `skip`: pipelines are compiling, so the frame says nothing about steady cost.
      * `displayMs`: one refresh of the display, the budget when `targetMs` is 0.

package/dist/dynamic-resolution.js

@@ -1,5 +1,5 @@
 import { defineSystem, Last } from "@aethervtt/shard-core";
-import { DisplayRate, definePlugin, Time } from "@aethervtt/shard-runtime";
+import { DisplayRate, definePlugin, FrameDemand, Time } from "@aethervtt/shard-runtime";
 import { Gpu, Graph, RenderSet } from "./plugin.js";
 import {
   HIGHEST,
@@ -30,6 +30,10 @@ class RenderScaleController {
   probeAge = 0;
   probeWait = 3;
   hold = 0;
+  /** Verifying an upward probe: it needs frames to measure, so on-demand apps keep rendering. */
+  get probing() {
+    return this.probeFrom > 0;
+  }
   /**
    * One frame. `skip`: pipelines are compiling, so the frame says nothing about steady cost.
    * `displayMs`: one refresh of the display, the budget when `targetMs` is 0.
@@ -175,6 +179,7 @@ const updateRenderScale = defineSystem({
       gpu.pipelines.pending > 0,
       display
     );
+    world.tryResource(FrameDemand)?.set("render/render-scale", controller.probing);
   }
 });
 const dynamicResolutionPlugin = definePlugin({

package/dist/environment-plugin.js

@@ -4,15 +4,17 @@ import {
   DefaultEnvironment,
   describeEnvironment,
   EnvironmentMap,
+  Environments,
   ProceduralSky,
   prepareEnvironments,
   runEnvironmentWork,
   Skybox
 } from "./environment.js";
 import { ENVIRONMENT_SHADERS } from "./environment-shaders.js";
+import { addRenderFeatures } from "./features.js";
 import { ForwardStateResource, isCamera, skyNode } from "./forward.js";
 import { RenderPhase } from "./graph.js";
-import { Graph, RenderDescribers, RenderSet, Shaders } from "./plugin.js";
+import { Gpu, Graph, RenderDescribers, RenderSet, Shaders } from "./plugin.js";
 import { registerShaders } from "./shaders.js";
 const environmentPlugin = definePlugin({
   name: "render/environment",
@@ -22,11 +24,24 @@ const environmentPlugin = definePlugin({
     app.world.initResource(DefaultEnvironment);
     app.addSystems(Last, prepareEnvironments.inSet(RenderSet.Prepare));
   },
-  ready(app) {
+  async ready(app) {
     const world = app.world;
+    const baseline = world.resource(Gpu).tier === "baseline" ? await import("./baseline/environment.js") : void 0;
     registerShaders(world.resource(Shaders), ENVIRONMENT_SHADERS);
+    if (baseline) {
+      registerShaders(world.resource(Shaders), baseline.BASELINE_ENVIRONMENT_SHADERS);
+      world.resource(Environments).baseline = baseline;
+    }
     world.initResource(RenderDescribers).set("environment", (w) => describeEnvironment(w));
     const graph = world.resource(Graph);
+    addRenderFeatures(world, {
+      name: "render/environment",
+      description: "Image-based lighting: cube conversion, specular prefilter, SH irradiance, BRDF LUT; and the sky.",
+      nodes: ["environment", "sky"],
+      baseline: {
+        strategy: "Prefilter, SH and BRDF LUT as fragment passes into the cube faces and mips"
+      }
+    });
     graph.addNode("environment", {
       kind: "raw",
       phase: RenderPhase.Setup,

package/dist/environment-state.d.ts

@@ -1,6 +1,7 @@
-import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
+import type { GpuContext } from '@aethervtt/shard-gpu';
 import type { Texture } from '@aethervtt/shard-texture';
 import type { CameraAtmosphere } from './atmosphere-state.js';
+import { DataStore } from './data-store.js';
 import type { CameraData } from './view.js';
 /** Frames between rebakes of a moving camera's atmosphere environment. */
 export declare const REBAKE_FRAMES = 8;
@@ -19,7 +20,8 @@ export declare class Environment {
     specular: GPUTexture;
     specularView: GPUTextureView;
     sourceView: GPUTextureView;
-    readonly sh: GpuBuffer;
+    /** SH9 of the diffuse irradiance: `@data(uniform)` in the forward shader. */
+    readonly sh: DataStore;
     /** 'pending' until the GPU has prefiltered the current key. */
     state: 'pending' | 'ready';
     /** How many times it's been (re)baked or prefiltered. */
@@ -59,12 +61,14 @@ export declare class EnvironmentStore {
     lutReady: boolean;
     emptyCube: GPUTexture | undefined;
     emptyView: GPUTextureView | undefined;
-    emptySh: GpuBuffer | undefined;
+    emptySh: DataStore | undefined;
     sampler: GPUSampler | undefined;
     generation: number;
     frame: number;
     /** The frame the prefilter work last ran (it runs once per frame, for all views). */
     ranFrame: number;
+    /** The baseline tier's prefilter (0064): fragment passes, loaded only on a baseline device. */
+    baseline: typeof import('./baseline/environment.js') | undefined;
     ensure(gpu: GpuContext): void;
 }
 export declare const Environments: import("@aethervtt/shard-core").ResourceDef<EnvironmentStore>;

package/dist/environment-state.js

@@ -1,5 +1,6 @@
 import { defineResource } from "@aethervtt/shard-core";
-import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { DataStore } from "./data-store.js";
+import { bindingDimension } from "./tier.js";
 const REBAKE_FRAMES = 8;
 const SOURCE_SIZE = 512;
 const SKY_SIZE = 256;
@@ -15,6 +16,7 @@ class Environment {
   specular;
   specularView;
   sourceView;
+  /** SH9 of the diffuse irradiance: `@data(uniform)` in the forward shader. */
   sh;
   /** 'pending' until the GPU has prefiltered the current key. */
   state = "pending";
@@ -37,20 +39,25 @@ class Environment {
       size: [this.size, this.size, 6],
       format: "rgba16float",
       mipLevelCount: mips,
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC
+      // Written by compute on the full tier; rendered face by face on baseline (0064).
+      usage: GPUTextureUsage.TEXTURE_BINDING | (gpu.tier === "full" ? GPUTextureUsage.STORAGE_BINDING : GPUTextureUsage.RENDER_ATTACHMENT) | GPUTextureUsage.COPY_SRC,
+      ...bindingDimension(gpu, "cube")
     });
     this.specular = gpu.device.createTexture({
       label: `environment/${kind}/specular`,
       size: [SPECULAR_SIZE, SPECULAR_SIZE, 6],
       format: "rgba16float",
       mipLevelCount: SPECULAR_MIPS,
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC
+      // Written by compute on the full tier; rendered face by face on baseline (0064).
+      usage: GPUTextureUsage.TEXTURE_BINDING | (gpu.tier === "full" ? GPUTextureUsage.STORAGE_BINDING : GPUTextureUsage.RENDER_ATTACHMENT) | GPUTextureUsage.COPY_SRC,
+      ...bindingDimension(gpu, "cube")
     });
     this.sourceView = this.source.createView({ dimension: "cube" });
     this.specularView = this.specular.createView({ dimension: "cube" });
-    this.sh = new GpuBuffer(gpu, {
+    this.sh = new DataStore(gpu, {
       label: `environment/${kind}/sh`,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+      kind: "uniform",
+      usage: GPUBufferUsage.COPY_SRC,
       size: 9 * 16
     });
   }
@@ -74,6 +81,8 @@ class EnvironmentStore {
   frame = 0;
   /** The frame the prefilter work last ran (it runs once per frame, for all views). */
   ranFrame = -1;
+  /** The baseline tier's prefilter (0064): fragment passes, loaded only on a baseline device. */
+  baseline;
   ensure(gpu) {
     if (this.generation === gpu.generation && this.lut) return;
     this.generation = gpu.generation;
@@ -84,19 +93,21 @@ class EnvironmentStore {
       label: "environment/brdf-lut",
       size: [LUT_SIZE, LUT_SIZE],
       format: "rgba16float",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
+      // Computed on the full tier; drawn by a fragment pass on baseline (0064).
+      usage: GPUTextureUsage.TEXTURE_BINDING | (gpu.tier === "full" ? GPUTextureUsage.STORAGE_BINDING : GPUTextureUsage.RENDER_ATTACHMENT)
     });
     this.lutReady = false;
     this.emptyCube = gpu.device.createTexture({
       label: "environment/empty",
       size: [1, 1, 6],
       format: "rgba16float",
-      usage: GPUTextureUsage.TEXTURE_BINDING
+      usage: GPUTextureUsage.TEXTURE_BINDING,
+      ...bindingDimension(gpu, "cube")
     });
     this.emptyView = this.emptyCube.createView({ dimension: "cube" });
-    this.emptySh = new GpuBuffer(gpu, {
+    this.emptySh = new DataStore(gpu, {
       label: "environment/empty-sh",
-      usage: GPUBufferUsage.STORAGE,
+      kind: "uniform",
       size: 9 * 16
     });
     this.sampler = gpu.device.createSampler({

package/dist/environment.js

@@ -90,6 +90,7 @@ const ProceduralSky = defineComponent(
 const DefaultEnvironment = defineResource(
   "render/DefaultEnvironment",
   {
+    hostWritable: true,
     description: "The environment (map or procedural sky) for cameras that have none. AmbientLight is the fallback when neither is set.",
     init: () => ({ map: null, sky: null, background: true })
   }
@@ -194,6 +195,7 @@ const prepareEnvironments = defineSystem({
       } else if (map?.texture) useMap(map, skybox);
       else if (defaults.map?.texture)
         useMap(defaults.map, defaults.background ? Math.max(skybox, 1) : skybox);
+      if (cam.alphaOutput) entry.background = -1;
       store.cameras.set(e, entry);
       view.data.environment = entry;
     }
@@ -312,6 +314,10 @@ function runEnvironmentWork(ctx) {
   const gpu = ctx.gpu;
   const store = world.resource(Environments);
   if (store.ranFrame === store.frame) return;
+  if (gpu.tier === "baseline") {
+    store.baseline?.runBaselineEnvironment(ctx, store);
+    return;
+  }
   if (store.pending.length === 0 && store.lutReady) {
     store.ranFrame = store.frame;
     return;
@@ -422,7 +428,7 @@ function runEnvironmentWork(ctx) {
               mipLevelCount: 1
             })
           },
-          { binding: 1, resource: { buffer: env.sh.buffer } }
+          { binding: 1, resource: { buffer: env.sh.gpuBuffer } }
         ]
       })
     );

package/dist/features.d.ts

@@ -0,0 +1,49 @@
+import { type ComponentDef, type World } from '@aethervtt/shard-core';
+/**
+ * Logs `render/feature-missing` once per world and plugin: `what` asked for a feature whose
+ * `plugin` (one forwardPlugin includes) isn't installed, and `outcome` is what happens instead.
+ */
+export declare function warnFeatureMissing(world: World, what: string, plugin: string, outcome: string): void;
+/** How a feature runs on the baseline tier: a short account of its strategy there. */
+export interface BaselineStrategy {
+    strategy: string;
+}
+export interface RenderFeature {
+    /** `package/feature`, e.g. `render/bloom`. */
+    readonly name: string;
+    readonly description: string;
+    /** The graph nodes it adds. */
+    readonly nodes: readonly string[];
+    /** What it does on the baseline tier, or `'unsupported'`. */
+    readonly baseline: BaselineStrategy | 'unsupported';
+    /** Components that mean a scene uses it (for `render/feature-unsupported` on baseline). */
+    readonly components?: readonly ComponentDef[];
+}
+export declare const RenderFeatures: import("@aethervtt/shard-core").ResourceDef<Map<string, RenderFeature>>;
+/** Registers features a plugin installs. Plugins call it where they add their graph nodes. */
+export declare function addRenderFeatures(world: World, ...features: RenderFeature[]): void;
+/** The feature a graph node belongs to, if one registered it. */
+export declare function featureOfNode(world: World, node: string): RenderFeature | undefined;
+/** `render.describe → features`: each installed feature, its nodes, and its baseline strategy. */
+export declare function describeFeatures(world: World): {
+    name: string;
+    nodes: string[];
+    baseline: string;
+}[];
+/**
+ * The graph nodes of features the baseline tier doesn't run (`baseline: 'unsupported'`): the
+ * graph skips them on a baseline device, so they never ask for what it lacks.
+ */
+export declare function unsupportedNodes(world: World): ReadonlySet<string>;
+/**
+ * Raises `render/feature-unsupported` for `feature` (a feature, or a part of one) that a scene uses
+ * on the baseline tier: RenderHealth turns degraded until `clearUnsupported`.
+ */
+export declare function reportUnsupported(world: World, feature: string, message: string): void;
+export declare function clearUnsupported(world: World, feature: string): void;
+/**
+ * On the baseline tier: reports each unsupported feature whose components are in the world, and
+ * clears the report once they're gone. A query per component, made once; issues change only when
+ * a feature's use does.
+ */
+export declare function checkUnsupportedFeatures(world: World): void;