@aethervtt/shard-render 0.1.0 → 0.2.1

package/dist/forward.js

@@ -36,6 +36,7 @@ import { DataStore, dataEntry } from "./data-store.js";
 import { addDisplayNodes } from "./display-nodes.js";
 import { Environments, environmentParams } from "./environment-state.js";
 import { addRenderFeatures } from "./features.js";
+import { FoliagePath } from "./foliage-path.js";
 import { GpuAssets, GpuAssetsResource } from "./gpu-assets.js";
 import { RenderPhase } from "./graph.js";
 import { clearHealthIssue, MaterialFallbacks, raiseHealthIssue } from "./health.js";
@@ -127,6 +128,15 @@ import { SkinAssetType, Skins } from "./skin-asset.js";
 import { GpuMemory, RenderCounters, RenderStats } from "./stats.js";
 import { bindingDimension } from "./tier.js";
 import { addShaderVariantSource, materialVariants, ShaderVariantSources } from "./variants.js";
+import {
+  Beam,
+  Decal,
+  DecalReceiver,
+  DecalsPath,
+  observeVfxWithoutPlugin,
+  RibbonsPath,
+  Trail
+} from "./vfx.js";
 import {
   CameraMoved,
   Cameras,
@@ -533,7 +543,7 @@ const PICK_TARGETS = [
   { format: "r32uint" },
   { format: "rgba32float" }
 ];
-const PREPASS_TARGETS = [{ format: "rgba16float" }, { format: "rg16float" }];
+const PREPASS_TARGETS = [{ format: "rg16float" }, { format: "rg16float" }];
 function drawMaterials(ctx, state, pv, cam, draws, pass) {
   const store = ctx.world.resource(Instances);
   const assets = ctx.world.resource(GpuAssetsResource);
@@ -982,8 +992,12 @@ function cascadeNode(state) {
       const shadows = ctx.world.resource(ShadowsResource);
       const size = ctx.world.resource(LightingSettings).cascadeMapSize;
       const texture = pv.cascades.ensureTexture(ctx.gpu, size, ctx.view.name);
+      const foliage = ctx.world.tryResource(FoliagePath);
+      const cam = cameraOf(ctx.view);
+      const animated = foliage?.animatedShadows(cam) ?? false;
       for (let i = 0; i < pv.cascades.count; i++) {
         const view = pv.cascades.views[i];
+        if (animated && i === 0) view.redraw = true;
         if (!beginShadowView(ctx, view)) continue;
         drawShadowCasters(
           ctx,
@@ -993,7 +1007,10 @@ function cascadeNode(state) {
           shadows.uniforms,
           state.pipelines,
           state.layouts.shadowView,
-          `shadows/cascade${i}`
+          `shadows/cascade${i}`,
+          foliage,
+          cam,
+          i
         );
         endShadowView(ctx, view);
       }
@@ -1387,6 +1404,12 @@ function forwardCorePlugin(options = {}) {
       RenderLayers,
       Outline,
       OutlinePath,
+      Trail,
+      Beam,
+      Decal,
+      DecalReceiver,
+      RibbonsPath,
+      DecalsPath,
       CameraMoved,
       // shadows
       ShadowsResource,
@@ -1436,6 +1459,7 @@ function forwardCorePlugin(options = {}) {
       w.initResource(RenderDescribers).set("screenEffects", describeScreenEffects);
       observeInstanceRemovals(w);
       observeOutlinesWithoutPass(w);
+      observeVfxWithoutPlugin(w);
       observeViewVisibilityWithoutPlugin(w);
       observeLightRemovals(w);
       observeOriginShifts(w);

package/dist/graph.d.ts

@@ -67,6 +67,11 @@ export interface NodeContext {
     /** Set for compute nodes. */
     readonly computePass: GPUComputePassEncoder | undefined;
     texture(name: string): GPUTexture;
+    /**
+     * Hands later nodes `texture` as resource `name` for the rest of this view's frame, instead of a
+     * pooled one: a node that keeps its output across frames (TAA's history) writes it once.
+     */
+    provide(name: string, texture: GPUTexture): void;
     /** Timestamp writes for a pass the node begins itself (raw nodes), labeled `name`. */
     timestamps(name: string): GPURenderPassTimestampWrites | undefined;
     /** Runs after the frame's commands are submitted (e.g. to map a readback buffer). */
@@ -85,6 +90,11 @@ export interface NodeDescriptor {
     phase?: number;
     /** Runs even if nothing reads its outputs. */
     sideEffects?: boolean;
+    /**
+     * Render nodes: always a render pass of its own, never shared with the nodes around it (see
+     * `continues`), so its GPU time is its own: what reads it (FoliageBudget's `gpu:foliage/*`) needs it.
+     */
+    ownPass?: boolean;
     /**
      * Whether the node runs for a view (e.g. only when the camera has the effect's component).
      * Disabled nodes are removed before resolving, so what they fed is culled too.
@@ -169,6 +179,13 @@ export declare class RenderGraph {
     /** Views rendered in the last frame, in order. */
     private lastViews;
     private readonly viewData;
+    /** Each node's `render/<node>` span and its CPU time this frame, summed over views (0074). */
+    private readonly nodeSlots;
+    private readonly nodeSpans;
+    private nodeMs;
+    private nodeRan;
+    /** Nodes disabled for measurement (0075): see `ablate`. */
+    private readonly ablatedNodes;
     constructor(gpu: GpuContext);
     /** Rejects pending captures and destroys the timer's query set (the app is being disposed). */
     dispose(): void;
@@ -177,6 +194,17 @@ export declare class RenderGraph {
     hasNode(name: string): boolean;
     /** Every node's name, in the order they were added. */
     nodeNames(): string[];
+    /**
+     * 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: Iterable<string>): void;
+    /** The nodes `ablate` disabled. */
+    ablated(): string[];
     /** The data of a view rendered in the last frame. */
     lastViewData(view: string): Record<string, unknown> | undefined;
     /** Declares a transient texture any node can write, read, or attach by name. */
@@ -185,6 +213,12 @@ export declare class RenderGraph {
     resolve(): ResolvedGraph;
     /** `off`: nodes that don't run on this device (features the baseline tier doesn't support). */
     private resolveFor;
+    /**
+     * 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.
+     */
+    private continues;
     /** Whether a node after `k` loads or reads `resource` (so its contents must be stored). */
     private loadedLater;
     /**

package/dist/graph.js

@@ -1,4 +1,9 @@
-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";
@@ -130,6 +135,13 @@ 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);
@@ -147,6 +159,19 @@ class RenderGraph {
     }
     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);
@@ -159,6 +184,30 @@ class RenderGraph {
   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);
@@ -200,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);
@@ -253,6 +343,7 @@ class RenderGraph {
     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, off);
       const order = resolved.order;
@@ -299,14 +390,28 @@ class RenderGraph {
         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}`,
@@ -326,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;
@@ -380,6 +497,14 @@ 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);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+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';
@@ -10,6 +11,8 @@ export { Cutaway, CutawayPath, type CutawaySupport, CutawayView, MAX_REVEAL_POIN
 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';
@@ -19,6 +22,10 @@ export { dynamicResolutionPlugin, type FrameTimings, RenderScaleController, upda
 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 { 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, labelAtlas, labelWidth } from './gizmo-font.js';
@@ -46,13 +53,15 @@ export { type PickBlocker, type PickDetail, type PickDetailer, type PickDrawer,
 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, RenderOptions, type RenderOptionsValue, type RenderPluginOptions, RenderSet, renderOwner, 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';
@@ -66,6 +75,7 @@ export { OffscreenTarget, type OffscreenTargetOptions, type RenderTarget, } from
 export { bindingDimension, depthReadEntry } from './tier.js';
 export { GpuTimer } from './timer.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';

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  ablatePasses,
+  PassCosts,
+  runAblation
+} from "./ablation.js";
 import {
   AssetStore,
   MaterialAsset,
@@ -94,6 +99,8 @@ import {
   readTextureLayer,
   setDebugView
 } from "./debug-views.js";
+import { Decals, describeDecals, updateDecals } from "./decals.js";
+import { DecalGpu, decalsPlugin } from "./decals-plugin.js";
 import {
   captureGBuffer,
   describeDeferred,
@@ -130,6 +137,20 @@ import {
   reportUnsupported,
   unsupportedNodes
 } from "./features.js";
+import {
+  FoliageLayer,
+  FoliageLayerSet,
+  FoliageLayers,
+  foliagePlugin
+} from "./foliage.js";
+import {
+  CoveredGpuTime,
+  FOLIAGE_SPAN_KEY,
+  FoliageBudget,
+  FoliageController
+} from "./foliage-budget.js";
+import { FoliagePath } from "./foliage-path.js";
+import { FOLIAGE_SHADERS, MAX_FOLIAGE_MESHES } from "./foliage-shaders.js";
 import {
   ForwardStateResource,
   forwardCorePlugin,
@@ -314,6 +335,7 @@ import {
   Gpu,
   GpuDeviceLost,
   Graph,
+  gpuMemory,
   RenderDescribers,
   RenderOptions,
   RenderSet,
@@ -356,6 +378,8 @@ import {
   SCALE_STEP,
   scaledSize
 } from "./render-scale.js";
+import { describeRibbons, Ribbons, shiftRibbons, updateRibbons } from "./ribbons.js";
+import { RibbonGpu, ribbonsPlugin } from "./ribbons-plugin.js";
 import {
   clearScreenEffects,
   describeScreenEffects,
@@ -409,6 +433,7 @@ import {
   showToCamera,
   showVariants
 } from "./variants.js";
+import { Beam, Decal, DecalReceiver, DecalsPath, RibbonsPath, Trail } from "./vfx.js";
 import {
   CameraMoved,
   Cameras,
@@ -450,6 +475,7 @@ export {
   Atmospheres,
   AutoExposure,
   BLEND_MODES,
+  Beam,
   Bloom,
   CLUSTER_COUNT,
   CLUSTER_X,
@@ -467,6 +493,7 @@ export {
   ClusterBuffers,
   ColorGrading,
   ComputedVisibility,
+  CoveredGpuTime,
   Culler,
   Cutaway,
   CutawayCameras,
@@ -478,6 +505,11 @@ export {
   DEFORM_WORDS,
   DataStore,
   DebugOverlays,
+  Decal,
+  DecalGpu,
+  DecalReceiver,
+  Decals,
+  DecalsPath,
   DefaultEnvironment,
   DeformPath,
   DeformStore,
@@ -493,7 +525,15 @@ export {
   ExposureMeters,
   ExposurePresets,
   FALLOFFS,
+  FOLIAGE_SHADERS,
+  FOLIAGE_SPAN_KEY,
   Fog,
+  FoliageBudget,
+  FoliageController,
+  FoliageLayer,
+  FoliageLayerSet,
+  FoliageLayers,
+  FoliagePath,
   ForwardStateResource,
   GBUFFER_CHANNELS,
   GIZMO_LINE_FLOATS,
@@ -547,6 +587,7 @@ export {
   LocalShadows,
   Lod,
   LuminousPowerPresets,
+  MAX_FOLIAGE_MESHES,
   MAX_JOINTS,
   MAX_LENS_FIELDS,
   MAX_LENS_PIXELS,
@@ -583,6 +624,7 @@ export {
   PASS_GROUND,
   PICK_TARGETS,
   POST_NODES,
+  PassCosts,
   PhysicalCamera,
   Picking,
   PixelPerfect,
@@ -612,6 +654,9 @@ export {
   RenderStats,
   RenderStatsMap,
   RenderTargets,
+  RibbonGpu,
+  Ribbons,
+  RibbonsPath,
   SCALE_STEP,
   SCREEN_EFFECTS_DEMAND,
   SHADOW_CATCHER_SHADERS,
@@ -635,6 +680,7 @@ export {
   TONEMAP_CURVES,
   TexturePool,
   Tonemapping,
+  Trail,
   VERTEX_BUFFERS,
   VIEW_SHADOWS,
   VIEW_TARGET,
@@ -648,6 +694,7 @@ export {
   Visibility,
   VisibilityRange,
   Window,
+  ablatePasses,
   addRenderFeatures,
   addShaderVariantSource,
   allMaterialTypes,
@@ -680,6 +727,7 @@ export {
   cullGround,
   cutawayPlugin,
   dataEntry,
+  decalsPlugin,
   deferredPlugin,
   defineMaterial,
   defineOverlay,
@@ -688,6 +736,7 @@ export {
   describeAtmospheres,
   describeCulling,
   describeCutaways,
+  describeDecals,
   describeDeferred,
   describeEnvironment,
   describeFeatures,
@@ -698,6 +747,7 @@ export {
   describePost,
   describeRender,
   describeRenderScale,
+  describeRibbons,
   describeScreenEffects,
   describeViewVisibility,
   dynamicResolutionPlugin,
@@ -717,6 +767,7 @@ export {
   findMaterialType,
   findModelRoot,
   flushDataStores,
+  foliagePlugin,
   forwardCorePlugin,
   forwardLensFields,
   forwardPlugin,
@@ -724,6 +775,7 @@ export {
   forwardScreenEffects,
   fxaaPlugin,
   gizmosPlugin,
+  gpuMemory,
   gridsOverlay,
   groundKey,
   histogramEv,
@@ -779,6 +831,8 @@ export {
   reportUnsupported,
   resolveGraph,
   resolveViewVisibility,
+  ribbonsPlugin,
+  runAblation,
   runScreenEffects,
   sampleAtmosphere,
   scaledSize,
@@ -793,6 +847,7 @@ export {
   shadowCatcherPlugin,
   shiftCameraHistory,
   shiftRenderHistory,
+  shiftRibbons,
   showToCamera,
   showVariants,
   skinArtifact,
@@ -804,7 +859,9 @@ export {
   transmittanceToTop,
   typeOrdinal,
   unsupportedNodes,
+  updateDecals,
   updateRenderScale,
+  updateRibbons,
   validateMaterial,
   viewAliases,
   viewBindGroup,

package/dist/overlay-registry.d.ts

@@ -1,6 +1,8 @@
 import type { Entity, World } from '@aethervtt/shard-core';
 import type { GizmoStore } from './gizmos.js';
-export declare const OVERLAYS: readonly ['bounds', 'lights', 'cameras', 'cascades', 'normals', 'axes', 'labels'];
+export declare const OVERLAYS: readonly ['bounds', 'lights', 'cameras', 'cascades', 'normals', 'axes', 'labels', 
+/** Frame time, the top 8 spans, and the GPU frame (0074). */
+'perf'];
 export type Overlay = (typeof OVERLAYS)[number];
 /** An overlay another package draws (physics colliders, the navmesh, UI rects). */
 export interface OverlayDef {

package/dist/overlay-registry.js

@@ -5,7 +5,9 @@ const OVERLAYS = [
   "cascades",
   "normals",
   "axes",
-  "labels"
+  "labels",
+  /** Frame time, the top 8 spans, and the GPU frame (0074). */
+  "perf"
 ];
 const extraOverlays = /* @__PURE__ */ new Map();
 function defineOverlay(def) {