@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/graph.js

@@ -1,4 +1,11 @@
-import { ShardError } from "@aethervtt/shard-core";
+import {
+  defineSpan,
+  ProfilerResource,
+  ShardError,
+  TRACK
+} from "@aethervtt/shard-core";
+import { flushDataStores } from "./data-store.js";
+import { unsupportedNodes } from "./features.js";
 import { TexturePool } from "./pool.js";
 import { BYTES_PER_TEXEL, toFloats } from "./readback.js";
 import { GpuTimer } from "./timer.js";
@@ -10,8 +17,14 @@ const RenderPhase = {
   Opaque: 300,
   Lighting: 350,
   Sky: 400,
+  /** Coplanar ground bands (0057): after the sky, which draws where no depth was written. */
+  Ground: 420,
   Sprites: 450,
   Transparent: 500,
+  /** Projected fog's composite (0058): after transparent objects, before the overlay band. */
+  Fog: 520,
+  /** Ground bands from the overlay band up, over fog (0058). */
+  Overlay3d: 530,
   Effects3d: 550,
   Resolve: 600,
   Post: 700,
@@ -122,17 +135,43 @@ class RenderGraph {
   /** Views rendered in the last frame, in order. */
   lastViews = [];
   viewData = /* @__PURE__ */ new Map();
+  /** Each node's `render/<node>` span and its CPU time this frame, summed over views (0074). */
+  nodeSlots = /* @__PURE__ */ new Map();
+  nodeSpans = [];
+  nodeMs = new Float64Array(16);
+  nodeRan = new Uint8Array(16);
+  /** Nodes disabled for measurement (0075): see `ablate`. */
+  ablatedNodes = /* @__PURE__ */ new Set();
   constructor(gpu) {
     this.gpu = gpu;
     this.pool = new TexturePool(gpu);
     this.timer = new GpuTimer(gpu);
   }
+  /** Rejects pending captures and destroys the timer's query set (the app is being disposed). */
+  dispose() {
+    const error = new ShardError("render/disposed", "The app was disposed before the capture ran");
+    for (const capture of this.captures.splice(0)) capture.reject(error);
+    this.timer.destroy();
+  }
   addNode(name, node) {
     if (this.nodes.has(name)) {
       throw new ShardError("render/duplicate-node", `Render graph node "${name}" already exists`);
     }
     this.nodes.set(name, node);
     this.resolutions.clear();
+    if (!this.nodeSlots.has(name)) {
+      const slot = this.nodeSpans.length;
+      this.nodeSlots.set(name, slot);
+      this.nodeSpans.push(defineSpan(`render/${name}`));
+      if (slot >= this.nodeMs.length) {
+        const ms = new Float64Array(this.nodeMs.length * 2);
+        ms.set(this.nodeMs);
+        this.nodeMs = ms;
+        const ran = new Uint8Array(this.nodeRan.length * 2);
+        ran.set(this.nodeRan);
+        this.nodeRan = ran;
+      }
+    }
   }
   removeNode(name) {
     this.nodes.delete(name);
@@ -141,6 +180,34 @@ class RenderGraph {
   hasNode(name) {
     return this.nodes.has(name);
   }
+  /** Every node's name, in the order they were added. */
+  nodeNames() {
+    return [...this.nodes.keys()];
+  }
+  /**
+   * Disables nodes for measurement (0075's ablation), replacing the previous set; `[]` restores
+   * them. A disabled render or compute node still begins and ends its pass, with its attachments'
+   * clears, so the textures it writes stay valid for what reads them; only its `run` (its draws and
+   * dispatches) is skipped. A raw node, which begins its own passes, is skipped whole. The graph
+   * resolves as before: what the node fed still runs, on whatever its textures hold. The image is
+   * wrong while nodes are disabled. Throws `render/unknown-node` for a name the graph lacks.
+   */
+  ablate(names) {
+    const next = [...names];
+    for (const name of next) {
+      if (!this.nodes.has(name)) {
+        throw new ShardError("render/unknown-node", `No render graph node "${name}"`, {
+          hint: `Nodes: ${this.nodeNames().join(", ")}.`
+        });
+      }
+    }
+    this.ablatedNodes.clear();
+    for (const name of next) this.ablatedNodes.add(name);
+  }
+  /** The nodes `ablate` disabled. */
+  ablated() {
+    return [...this.ablatedNodes];
+  }
   /** The data of a view rendered in the last frame. */
   lastViewData(view) {
     return this.viewData.get(view);
@@ -153,11 +220,12 @@ class RenderGraph {
   resolve() {
     return this.resolveFor(void 0);
   }
-  resolveFor(view) {
+  /** `off`: nodes that don't run on this device (features the baseline tier doesn't support). */
+  resolveFor(view, off) {
     let key = "";
     const enabled = /* @__PURE__ */ new Map();
     for (const [name, node] of this.nodes) {
-      const on = !view || !node.enabled || node.enabled(view);
+      const on = (!view || !node.enabled || node.enabled(view)) && !off?.has(name);
       key += on ? "1" : "0";
       if (on) enabled.set(name, node);
     }
@@ -181,6 +249,47 @@ class RenderGraph {
     }
     return resolved;
   }
+  /**
+   * Whether render node `order[k]` can draw in the pass `order[from]` began: the same color
+   * attachments, loaded rather than cleared, the same depth (written only if the pass writes it),
+   * and nothing it samples bound as an attachment.
+   */
+  continues(order, from, k, view) {
+    const a = this.nodes.get(order[from]);
+    const b = this.nodes.get(order[k]);
+    if (a.ownPass || b.ownPass) return false;
+    const aliases = view.aliases;
+    const ca = colorOf(a, view);
+    const cb = colorOf(b, view);
+    if (ca.length !== cb.length) return false;
+    for (let i = 0; i < ca.length; i++) {
+      const x = ca[i];
+      const y = cb[i];
+      if (y.clear !== void 0 || (x.mip ?? 0) !== (y.mip ?? 0)) return false;
+      if (canonicalOf(aliases, x.resource) !== canonicalOf(aliases, y.resource)) return false;
+      if (x.resolve === void 0 !== (y.resolve === void 0)) return false;
+      if (x.resolve && canonicalOf(aliases, x.resolve) !== canonicalOf(aliases, y.resolve))
+        return false;
+    }
+    const da = a.depth;
+    const db = b.depth;
+    if (!da !== !db) return false;
+    if (da && db) {
+      if (canonicalOf(aliases, da.resource) !== canonicalOf(aliases, db.resource)) return false;
+      if (db.clear !== void 0 || da.readOnly && !db.readOnly) return false;
+    }
+    const reads = b.reads ?? [];
+    for (let r = 0; r < reads.length; r++) {
+      const c = canonicalOf(aliases, reads[r]);
+      if (da && c === canonicalOf(aliases, da.resource)) return false;
+      for (let i = 0; i < ca.length; i++) {
+        const x = ca[i];
+        if (c === canonicalOf(aliases, x.resource)) return false;
+        if (x.resolve && c === canonicalOf(aliases, x.resolve)) return false;
+      }
+    }
+    return true;
+  }
   /** Whether a node after `k` loads or reads `resource` (so its contents must be stored). */
   loadedLater(order, k, resource, view) {
     const canonical = canonicalOf(view.aliases, resource);
@@ -233,8 +342,10 @@ class RenderGraph {
     this.lastViews = sorted.map((v) => v.name);
     this.viewData.clear();
     for (const v of sorted) this.viewData.set(v.name, v.data);
+    const off = this.gpu.tier === "baseline" ? unsupportedNodes(world) : void 0;
+    const profiler = world.tryResource(ProfilerResource);
     for (const view of sorted) {
-      const resolved = this.resolveFor(view);
+      const resolved = this.resolveFor(view, off);
       const order = resolved.order;
       this.lastByView.set(view.name, resolved);
       const textures = /* @__PURE__ */ new Map();
@@ -264,25 +375,43 @@ class RenderGraph {
         const vh = view.height ?? view.target.height;
         const px = size === "view" ? [vw, vh] : Array.isArray(size) ? size : [Math.max(1, Math.ceil(vw / size.divide)), Math.max(1, Math.ceil(vh / size.divide))];
         const format = perView(desc.format, view);
+        const sampleCount = perView(desc.sampleCount ?? 1, view);
+        let usage = (desc.usage ?? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING) | GPUTextureUsage.COPY_SRC;
+        if (sampleCount > 1 && this.gpu.tier === "baseline")
+          usage &= ~GPUTextureUsage.TEXTURE_BINDING;
         t = this.pool.acquire({
           label: `${view.name}/${canonical}`,
           format: format === "view" ? view.target.format : format,
           size: px,
-          sampleCount: perView(desc.sampleCount ?? 1, view),
+          sampleCount,
           mipLevelCount: perView(desc.mipLevelCount ?? 1, view),
-          usage: (desc.usage ?? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING) | GPUTextureUsage.COPY_SRC
+          usage
         });
         textures.set(canonical, t);
         return t;
       };
+      const provide = (name, t) => {
+        textures.set(canonicalOf(view.aliases, name), t);
+      };
       const timestamps = (name) => this.timer.allocate(name);
       const afterSubmit = (fn) => void submitted.push(fn);
+      let open;
+      let openFrom = -1;
       for (let k = 0; k < order.length; k++) {
         const name = order[k];
         const node = this.nodes.get(name);
+        const ablated = this.ablatedNodes.size > 0 && this.ablatedNodes.has(name);
+        if (ablated && node.kind === "raw") continue;
+        const t0 = profiler !== void 0 ? profiler.now() : 0;
         let renderPass;
         let computePass;
-        if (node.kind === "render") {
+        if (node.kind === "render" && open && this.continues(order, openFrom, k, view)) {
+          renderPass = open;
+        } else {
+          open?.end();
+          open = void 0;
+        }
+        if (node.kind === "render" && !renderPass) {
           const colors = colorOf(node, view);
           renderPass = encoder.beginRenderPass({
             label: `${view.name}/${name}`,
@@ -302,26 +431,38 @@ class RenderGraph {
             } : void 0,
             timestampWrites: this.timer.allocate(name)
           });
+          open = renderPass;
+          openFrom = k;
         } else if (node.kind === "compute") {
           computePass = encoder.beginComputePass({
             label: `${view.name}/${name}`,
             timestampWrites: this.timer.allocate(name)
           });
         }
-        node.run({
-          gpu: this.gpu,
-          world,
-          view,
-          encoder,
-          renderPass,
-          computePass,
-          texture,
-          timestamps,
-          afterSubmit
-        });
-        renderPass?.end();
+        if (!ablated) {
+          node.run({
+            gpu: this.gpu,
+            world,
+            view,
+            encoder,
+            renderPass,
+            computePass,
+            texture,
+            provide,
+            timestamps,
+            afterSubmit
+          });
+        }
         computePass?.end();
+        if (profiler !== void 0) {
+          const ms = profiler.now() - t0;
+          const slot = this.nodeSlots.get(name);
+          this.nodeMs[slot] = this.nodeMs[slot] + ms;
+          this.nodeRan[slot] = 1;
+          profiler.event(this.nodeSpans[slot], TRACK.main, t0, ms);
+        }
       }
+      open?.end();
       for (const capture of this.captures) {
         if (capture.view !== view.name) continue;
         let source;
@@ -356,8 +497,17 @@ class RenderGraph {
         readbacks.push({ capture, buffer, width, height, format, bytesPerRow });
       }
     }
+    if (profiler !== void 0) {
+      for (let slot = 0; slot < this.nodeSpans.length; slot++) {
+        if (!this.nodeRan[slot]) continue;
+        profiler.sample(this.nodeSpans[slot], this.nodeMs[slot]);
+        this.nodeMs[slot] = 0;
+        this.nodeRan[slot] = 0;
+      }
+    }
     this.captures = this.captures.filter((c) => !readbacks.some((r) => r.capture === c));
     this.timer.resolve(encoder);
+    flushDataStores(this.gpu);
     device.queue.submit([encoder.finish()]);
     this.timer.readback(world);
     for (const fn of submitted) fn();

package/dist/health.d.ts

@@ -0,0 +1,58 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuStatus } from '@aethervtt/shard-gpu';
+export type RenderHealthState = 'ok' | 'degraded' | 'lost' | 'failed';
+export interface RenderHealthIssue {
+    /** `package/what-happened`, e.g. `assets/load-failed`, `render/material-fallback`. */
+    code: string;
+    message: string;
+    /** What it's about: an asset path, a material type, a feature. */
+    ref?: string;
+    /** When it was first seen, in ms since the epoch. */
+    since: number;
+    /**
+     * `degraded` issues make the state `degraded` (something draws a fallback or not at all); `info`
+     * ones are reported without changing it (a shader cache miss in a dev build).
+     */
+    severity: 'degraded' | 'info';
+}
+export interface RenderHealthValue {
+    /**
+     * `ok`; `degraded` while any fallback, failed pipeline or unsupported feature is in use; `lost`
+     * between a device loss and its recovery; `failed` when recovery gave up.
+     */
+    state: RenderHealthState;
+    issues: RenderHealthIssue[];
+}
+export declare const RenderHealth: import("@aethervtt/shard-core").ResourceDef<RenderHealthValue>;
+export declare const RenderHealthChanged: import("@aethervtt/shard-core").EventDef<{
+    from: RenderHealthState;
+    to: RenderHealthState;
+    issues: RenderHealthIssue[];
+}>;
+type Raised = Omit<RenderHealthIssue, 'since'>;
+/** Issues raised by code other than the renderer's own checks (unsupported features, 0064). */
+export declare const RenderHealthReports: import("@aethervtt/shard-core").ResourceDef<{
+    issues: Map<string, Raised>;
+    version: number;
+}>;
+/** Raises an issue until `clearHealthIssue` (same code and ref). Raising it again does nothing. */
+export declare function raiseHealthIssue(world: World, issue: Raised): void;
+export declare function clearHealthIssue(world: World, code: string, ref?: string): void;
+/** Material types drawing through the standard fallback (filled by the forward plugin). */
+export declare const MaterialFallbacks: import("@aethervtt/shard-core").ResourceDef<{
+    count(): number;
+    list(): readonly {
+        type: string;
+        error: {
+            code: string;
+            message: string;
+        };
+    }[];
+}>;
+/** Where the device status comes from (the render plugin's GPU context). */
+export interface HealthSources {
+    status(): GpuStatus;
+}
+/** Rebuilds RenderHealth when its inputs change, and sends RenderHealthChanged on transitions. */
+export declare function healthSystem(sources: HealthSources): import("@aethervtt/shard-core").SystemDef<undefined>;
+export {};

package/dist/health.js

@@ -0,0 +1,112 @@
+import { AssetServerResource } from "@aethervtt/shard-assets";
+import { defineEvent, defineResource, defineSystem } from "@aethervtt/shard-core";
+const RenderHealth = defineResource("render/Health", {
+  description: "The renderer's health: ok, degraded (fallbacks in use), lost (device reset in progress) or failed, with the issues behind it.",
+  init: () => ({ state: "ok", issues: [] })
+});
+const RenderHealthChanged = defineEvent("render/HealthChanged", {
+  description: "RenderHealth moved to another state (ok, degraded, lost, failed)."
+});
+const RenderHealthReports = defineResource(
+  "render/HealthReports",
+  {
+    description: "Health issues raised by features and backends, by code and ref.",
+    init: () => ({ issues: /* @__PURE__ */ new Map(), version: 0 })
+  }
+);
+function raiseHealthIssue(world, issue) {
+  const reports = world.initResource(RenderHealthReports);
+  const key = `${issue.code}|${issue.ref ?? ""}`;
+  const had = reports.issues.get(key);
+  if (had && had.message === issue.message && had.severity === issue.severity) return;
+  reports.issues.set(key, issue);
+  reports.version++;
+}
+function clearHealthIssue(world, code, ref) {
+  const reports = world.tryResource(RenderHealthReports);
+  if (reports?.issues.delete(`${code}|${ref ?? ""}`)) reports.version++;
+}
+const MaterialFallbacks = defineResource("render/MaterialFallbacks", {
+  description: "Material types whose shader or pipeline failed, drawn with the standard one."
+});
+function healthSystem(sources) {
+  const seen = { status: "", fallbacks: -1, materials: -1, reports: -1 };
+  const since = /* @__PURE__ */ new Map();
+  return defineSystem({
+    name: "render/health",
+    description: "Keeps RenderHealth current: device status, fallbacks in use, raised issues.",
+    run: (_, world) => {
+      const status = sources.status();
+      const server = world.tryResource(AssetServerResource);
+      const fallbacks = server?.fallbackCount ?? 0;
+      const fallbackMaterials = world.tryResource(MaterialFallbacks);
+      const materials = fallbackMaterials?.count() ?? 0;
+      const reports = world.tryResource(RenderHealthReports)?.version ?? 0;
+      if (status === seen.status && fallbacks === seen.fallbacks && materials === seen.materials && reports === seen.reports)
+        return;
+      seen.status = status;
+      seen.fallbacks = fallbacks;
+      seen.materials = materials;
+      seen.reports = reports;
+      const now = Date.now();
+      const issues = [];
+      const add = (issue) => {
+        const key = `${issue.code}|${issue.ref ?? ""}`;
+        let at = since.get(key);
+        if (at === void 0) {
+          at = now;
+          since.set(key, at);
+        }
+        issues.push({ ...issue, since: at });
+      };
+      if (status === "lost") {
+        add({
+          code: "gpu/device-lost",
+          message: "The GPU device was lost; recovering",
+          severity: "degraded"
+        });
+      } else if (status === "failed") {
+        add({
+          code: "gpu/recovery-failed",
+          message: "The GPU device couldn't be replaced",
+          severity: "degraded"
+        });
+      }
+      for (const f of server?.failed() ?? []) {
+        add({ code: f.code, message: f.message, ref: f.path, severity: "degraded" });
+      }
+      for (const f of fallbackMaterials?.list() ?? []) {
+        add({
+          code: "render/material-fallback",
+          message: `Drawn with the standard material: ${f.error.message}`,
+          ref: f.type,
+          severity: "degraded"
+        });
+      }
+      for (const issue of world.tryResource(RenderHealthReports)?.issues.values() ?? []) add(issue);
+      for (const key of since.keys()) {
+        if (!issues.some((i) => `${i.code}|${i.ref ?? ""}` === key)) since.delete(key);
+      }
+      const state = status === "failed" ? "failed" : status === "lost" ? "lost" : issues.some((i) => i.severity === "degraded") ? "degraded" : "ok";
+      const health = world.initResource(RenderHealth);
+      const from = health.state;
+      health.state = state;
+      health.issues = issues;
+      world.touchResource(RenderHealth);
+      if (from !== state) {
+        const change = { from, to: state, issues };
+        world.send(RenderHealthChanged, change);
+        world.trigger(RenderHealthChanged, change);
+      }
+    }
+  });
+}
+export {
+  MaterialFallbacks,
+  RenderHealth,
+  RenderHealthChanged,
+  RenderHealthReports,
+  clearHealthIssue,
+  healthSystem,
+  raiseHealthIssue
+};

package/dist/index.d.ts

@@ -1,12 +1,18 @@
-export { AssetStore, MaterialAsset, MaterialAssetType, MaterialImporter, Materials, type MaterialValue, MeshAsset, Meshes, materialFields, materialFromJson, materialTypeOf, RenderTargets, STANDARD_TYPE, StandardMaterial, type StandardMaterialValue, validateMaterial, } from './assets.js';
+export { type AblationDriver, type AblationOptions, type AblationResult, ablatePasses, type PassCost, PassCosts, type PassCostsData, runAblation, } from './ablation.js';
+export { AssetStore, MaterialAsset, MaterialAssetType, MaterialImporter, Materials, type MaterialValue, MeshAsset, Meshes, materialFields, materialFromJson, materialTypeOf, missingMesh, RenderTargets, STANDARD_TYPE, StandardMaterial, type StandardMaterialValue, validateMaterial, } from './assets.js';
 export { Atmosphere, type AtmospherePreset, AtmospherePresets, type AtmosphereRecord, type AtmosphereSampleResult, AtmosphereSettings, AtmosphereStore, Atmospheres, type AtmosphereValue, atmosphereMethods, atmosphereModel, type CameraAtmosphere, describeAtmospheres, sampleAtmosphere, selectAtmospheres, sunTransmittanceAt, } from './atmosphere.js';
 export { type AtmosphereModel, createSkySample, integrateSky, multiscatterLut, transmittanceLut, transmittanceToTop, } from './atmosphere-model.js';
 export { AtmosphereGpu, AtmosphereGpuResource, LUT_LAYERS } from './atmosphere-nodes.js';
 export { atmospherePlugin } from './atmosphere-plugin.js';
 export { applyPhysicalCameras, Camera3d, type Camera3dValue, camera2d, Exposure, type ExposurePreset, ExposurePresets, ev100, ev100FromCamera, ev100FromIlluminance, exposureScale, type LightPreset, LightPresets, lux, PhysicalCamera, } from './camera.js';
 export { CLUSTER_COUNT, CLUSTER_X, CLUSTER_Y, CLUSTER_Z, ClusterBuffers, type ClusterStats, clusterAabb, clusterAabbs, clusterLightsCpu, clusterRange, MAX_LIGHTS_PER_CLUSTER, ViewLightList, } from './clusters.js';
-export { Culler, GpuCuller, readVisibleSlots, visibleSlots } from './culling.js';
+export { Culler, cullGround, GpuCuller, readVisibleSlots, visibleSlots } from './culling.js';
+export { Cutaway, CutawayPath, type CutawaySupport, CutawayView, MAX_REVEAL_POINTS, } from './cutaway.js';
+export { CUTAWAY_SHADERS, CutawayCameras, type CutawayState, cutawayPlugin, describeCutaways, extractCutaways, } from './cutaway-plugin.js';
+export { DATA_WIDTH, DataStore, type DataStoreOptions, dataEntry, flushDataStores, loadDataTextures, } from './data-store.js';
 export { captureShadowMap, DEBUG_VIEWS, type DebugView, describeCulling, describeLighting, readBuffer, readTextureLayer, setDebugView, } from './debug-views.js';
+export { Decals, describeDecals, updateDecals } from './decals.js';
+export { DecalGpu, decalsPlugin } from './decals-plugin.js';
 export { captureGBuffer, describeDeferred, GBUFFER_CHANNELS, type GBufferChannel, } from './deferred.js';
 export { deferredPlugin } from './deferred-plugin.js';
 export { DEFORM_WORDS, DeformStore, type MeshDeform } from './deform.js';
@@ -15,39 +21,62 @@ export { whiteBalance } from './display-nodes.js';
 export { dynamicResolutionPlugin, type FrameTimings, RenderScaleController, updateRenderScale, } from './dynamic-resolution.js';
 export { type CameraEnvironment, DefaultEnvironment, type DefaultEnvironmentValue, describeEnvironment, Environment, type EnvironmentBaker, EnvironmentMap, type EnvironmentMapValue, EnvironmentPresets, EnvironmentStore, Environments, environmentBakers, ProceduralSky, type ProceduralSkyValue, Skybox, } from './environment.js';
 export { environmentPlugin } from './environment-plugin.js';
-export { type ForwardPluginOptions, type ForwardState, ForwardStateResource, forwardCorePlugin, PICK_TARGETS, sceneColor, type ViewGpu, viewBindGroup, } from './forward.js';
+export { addRenderFeatures, type BaselineStrategy, clearUnsupported, describeFeatures, featureOfNode, type RenderFeature, RenderFeatures, reportUnsupported, unsupportedNodes, } from './features.js';
+export { type FoliageChunk, FoliageLayer, type FoliageLayerOptions, FoliageLayerSet, FoliageLayers, foliagePlugin, } from './foliage.js';
+export { CoveredGpuTime, FOLIAGE_SPAN_KEY, FoliageBudget, type FoliageBudgetValue, FoliageController, } from './foliage-budget.js';
+export { FoliagePath, type FoliageSupport } from './foliage-path.js';
+export { FOLIAGE_SHADERS, MAX_FOLIAGE_MESHES } from './foliage-shaders.js';
+export { type ForwardPluginOptions, type ForwardState, ForwardStateResource, forwardCorePlugin, forwardQueue, PASS_GROUND, PICK_TARGETS, sceneColor, VERTEX_BUFFERS, type ViewGpu, viewBindGroup, viewPixelScale, } from './forward.js';
 export { fxaaPlugin } from './fxaa.js';
-export { LABEL_FONT, labelWidth } from './gizmo-font.js';
+export { LABEL_FONT, labelAtlas, labelWidth } from './gizmo-font.js';
 export { GIZMO_LINE_FLOATS, type GizmoOptions, GizmoStore, Gizmos, packGizmoColor, } from './gizmos.js';
 export { gizmosPlugin } from './gizmos-plugin.js';
 export { GpuAssets, GpuAssetsResource, type GpuMaterial, type GpuMesh, type GpuTexture, } from './gpu-assets.js';
 export { type CapturedBuffer, type CapturedImage, type ColorAttachment, type DepthAttachment, type NodeContext, type NodeDescriptor, RenderGraph, RenderPhase, type RenderView, type ResolvedGraph, type ResourceRef, resolveGraph, type TransientTexture, VIEW_TARGET, } from './graph.js';
-export { type Batch, createDrawList, DeformPath, type DrawItem, type DrawList, INSTANCE_BYTES, INSTANCE_FLOATS, InstanceData, InstanceFlags, InstanceSlot, InstanceStore, Instances, LOD_BIT, Lod, lodSize, Mesh3d, MeshMaterial, MorphWeights, NotShadowCaster, NotShadowReceiver, SkinnedMesh, selectLod, VisibilityRange, } from './instances.js';
+export { clearHealthIssue, MaterialFallbacks, RenderHealth, RenderHealthChanged, type RenderHealthIssue, RenderHealthReports, type RenderHealthState, type RenderHealthValue, raiseHealthIssue, } from './health.js';
+export { type Batch, CUTAWAY_BIT, createDrawList, DeformPath, type DrawItem, type DrawList, groundKey, INSTANCE_BYTES, INSTANCE_FLOATS, InstanceData, InstanceFlags, InstanceSlot, InstanceStore, Instances, LOD_BIT, Lod, lodSize, Mesh3d, MeshMaterial, MorphWeights, NotShadowCaster, NotShadowReceiver, recordFlags, ShadowWhenHidden, SkinnedMesh, selectLod, VisibilityRange, } from './instances.js';
+export { INTERIOR_BINDINGS, INTERIOR_BLOCKED, INTERIOR_SKY, InteriorPath, type InteriorSupport, } from './interior.js';
+export { COVER_SCALE, COVER_ZERO, describeInterior, INTERIOR_GROUND, INTERIOR_LEVELS, INTERIOR_SHADERS, InteriorLighting, InteriorLightingResource, interiorPlugin, LINK_X, LINK_Z, ROW_CLEAR, ROW_SCALE, ROW_ZERO, VISIBILITY_MAX, } from './interior-plugin.js';
 export { observeOriginShifts, shiftRenderHistory } from './large-world.js';
-export { AmbientLight, type AmbientLightValue, CascadeSettings, DirectionalLight, LIGHT_FLOATS, LightingSettings, type LightingSettingsValue, type LightRecord, LightStore, Lights, type LuminousPowerPreset, LuminousPowerPresets, lumens, PointLight, SpotLight, } from './lights.js';
+export { GROUND_BANDS, type GroundBand, GroundLayer, RenderLayers } from './layers.js';
+export { clearLensFields, expireLensFields, forwardLensFields, LENS_DEMAND, Lens, type LensField, LensFields, LensPath, MAX_LENS_FIELDS, publishLensField, } from './lens.js';
+export { describeLens, extractLens, LENS_SHADERS, type LensView, LensViews, lensPlugin, MAX_LENS_PIXELS, } from './lens-plugin.js';
+export { AmbientLight, type AmbientLightValue, CascadeSettings, DirectionalLight, extractLights, FALLOFFS, LIGHT_FLOATS, LIGHT_ROW_WORD, LightingSettings, type LightingSettingsValue, type LightRecord, LightStore, Lights, type LuminousPowerPreset, LuminousPowerPresets, lumens, PointLight, SHADOW_UPDATES, SpotLight, setLightRow, tabletopFalloff, } from './lights.js';
 export { MaterialNoise, type MaterialNoiseSupport } from './material-noise.js';
 export { registerMaterialModule, typeOrdinal } from './material-pipelines.js';
 export { allMaterialTypes, BLEND_MODES, type BlendMode, defineMaterial, findMaterialType, isTransparent, type MaterialNoiseSlot, MaterialType, type MaterialTypeOptions, materialModulePath, onMaterialTypeChange, } from './materials.js';
+export { MAX_OUTLINE_STYLES, OUTLINE_OCCLUSION, Outline, OutlinePath, } from './outline.js';
+export { describeOutlines, OUTLINE_SHADERS, type OutlineView, OutlineViews, outlinePlugin, queueOutlines, } from './outline-plugin.js';
 export { allOverlays, DebugOverlays, type DebugOverlaysValue, defineOverlay, gridsOverlay, isOverlayOn, OVERLAYS, type Overlay, type OverlayDef, type OverlayFilter, overlayNames, setOverlays, } from './overlays.js';
 export { descendantPaths, entityName, findModelRoot } from './paths.js';
-export { type PickBlocker, type PickDrawer, type PickHit, Picking, pick, primaryView, type RaycastOptions, raycast, } from './picking.js';
+export { type PickBlocker, type PickDetail, type PickDetailer, type PickDrawer, type PickHit, Picking, pick, primaryView, type RaycastOptions, raycast, } from './picking.js';
 export { pickingPlugin } from './picking-plugin.js';
 export { PixelPerfect, type PixelPerfectLayout, PixelPerfectPath, PixelTargets, pixelPerfectLayout, } from './pixel-perfect.js';
 export { pixelPerfectPlugin } from './pixel-perfect-plugin.js';
-export { captureBuffer, captureView, describeRender, Gpu, GpuDeviceLost, Graph, RenderDescribers, type RenderPluginOptions, RenderSet, renderPlugin, Shaders, Views, Window, } from './plugin.js';
+export { captureBuffer, captureView, describeRender, Gpu, GpuDeviceLost, Graph, gpuMemory, RenderDescribers, RenderOptions, type RenderOptionsValue, type RenderPluginOptions, RenderSet, renderOwner, renderPlugin, Shaders, Views, Window, } from './plugin.js';
 export { TexturePool } from './pool.js';
 export { ANTIALIASING_MODES, Antialiasing, AutoExposure, Bloom, ColorGrading, cocRadiusPixels, DepthOfField, Fog, METERING_MODES, MotionBlur, PostEffect, type PostSettings, SSAO_QUALITIES, Ssao, Vignette, } from './post.js';
 export { bloomLevels, describePost, ExposureMeters, type ExposureState, histogramEv, METER_READBACKS, POST_NODES, } from './post-nodes.js';
 export { postPlugin } from './post-plugin.js';
+export { screenToPlane, screenToRay, worldToScreen } from './projection.js';
 export { describeRenderScale, RenderScale, type RenderScaleValue, SCALE_STEP, scaledSize, } from './render-scale.js';
+export { describeRibbons, Ribbons, shiftRibbons, updateRibbons } from './ribbons.js';
+export { RibbonGpu, ribbonsPlugin } from './ribbons-plugin.js';
+export { clearScreenEffects, describeScreenEffects, expireScreenEffects, forwardScreenEffects, MAX_SCREEN_EFFECT_PARAMS, MAX_SCREEN_EFFECTS, onScreenEffect, publishScreenEffect, runScreenEffects, SCREEN_EFFECTS_DEMAND, type ScreenEffect, type ScreenEffectHandler, ScreenEffectHandlers, type ScreenEffectParams, ScreenEffects, } from './screen-effects.js';
 export { ENGINE_SHADERS, materialLayout, registerEngineShaders, registerShaders, ViewUniform, viewLayout, } from './shaders.js';
+export { SHADOW_CATCHER_SHADERS, ShadowCatcher, shadowCatcherPlugin } from './shadow-catcher.js';
 export { Cascades, cascadeSplits, LocalShadows, ShadowsResource, sliceSphere, } from './shadows.js';
 export { MAX_JOINTS, type SkinAsset, SkinAssetType, Skins, skinArtifact } from './skin-asset.js';
 export { prepareDeforms } from './skinning.js';
 export { skinningPlugin } from './skinning-plugin.js';
 export { forwardPlugin } from './standard.js';
-export { GpuMemory, type GpuMemoryData, RenderCounters, type RenderCountersData, RenderStats, type ViewStats, } from './stats.js';
-export { OffscreenTarget, type OffscreenTargetOptions, type RenderTarget, WindowTarget, } from './target.js';
+export { type FrameCounts, type FrameRecord, GpuMemory, type GpuMemoryData, RECENT_FRAMES, RenderCounters, type RenderCountersData, RenderStats, RenderStatsMap, type ViewStats, } from './stats.js';
+export { OffscreenTarget, type OffscreenTargetOptions, type RenderTarget, } from './target.js';
+export { bindingDimension, depthReadEntry } from './tier.js';
 export { GpuTimer } from './timer.js';
-export { type CameraData, Cameras, cameraOf, DEFAULT_CURVE, isScaled, RenderPath, shiftCameraHistory, TONEMAP_CURVES, type TonemapCurve, Tonemapping, ViewSettings, type ViewSettingsValue, viewAliases, } from './view.js';
+export { addShaderVariantSource, type MaterialVariantEntry, materialVariants, type ShaderVariantManifest, type ShaderVariantSource, ShaderVariantSources, showToCamera, showVariants, } from './variants.js';
+export { Beam, Decal, DecalReceiver, DecalsPath, RibbonsPath, Trail } from './vfx.js';
+export { type CameraData, CameraMoved, Cameras, cameraOf, DEFAULT_CURVE, isScaled, RenderPath, shiftCameraHistory, TONEMAP_CURVES, type TonemapCurve, Tonemapping, ViewSettings, type ViewSettingsValue, viewAliases, } from './view.js';
+export { type HiddenSet, HiddenSetsResource, NO_HIDDEN, observeViewVisibilityWithoutPlugin, VIEW_SHADOWS, ViewVisibility, } from './view-visibility.js';
+export { describeViewVisibility, HiddenSets, resolveViewVisibility, viewVisibilityPlugin, } from './view-visibility-plugin.js';
 export { ComputedVisibility, computeVisibility, Visibility } from './visibility.js';