@aethervtt/shard-render 0.0.1 → 0.2.0

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";
@@ -32,7 +33,8 @@ function tonemapNode() {
     kind: "render",
     phase: RenderPhase.Tonemap,
     enabled: (view) => cameraOf(view) !== void 0,
-    reads: ["post-hdr"],
+    // Bloom's chain, when the view blooms: the glow is composited here (see the 'bloom' node).
+    reads: ["post-hdr", "bloom"],
     writes: ["ldr"],
     color: [{ resource: "ldr", clear: { r: 0, g: 0, b: 0, a: 1 } }],
     run: (ctx) => {
@@ -42,7 +44,7 @@ function tonemapNode() {
         layoutGen = gpu.generation;
         layout = gpu.layouts.bindGroupLayout({
           label: "tonemap",
-          entries: [tex(0, "unfilterable-float"), uniform(1), tex(2), sampler(3)]
+          entries: [tex(0, "unfilterable-float"), uniform(1), tex(2), sampler(3), tex(4)]
         });
         white = gpu.device.createTexture({
           label: "tonemap/no-lut",
@@ -53,15 +55,19 @@ function tonemapNode() {
       }
       const format = ctx.texture("ldr").format;
       const srgb = format.endsWith("-srgb");
+      const alpha = cam.alphaOutput;
+      const bloom = (cam.post.effects & PostEffect.Bloom) !== 0;
       const pipeline = cache.render(
         ctx,
-        `tonemap/${format}`,
+        `tonemap/${format}${alpha ? "/alpha" : ""}${bloom ? "/bloom" : ""}`,
         "shard::post::tonemap",
         "fs",
         [layout],
         [{ format }],
         {
-          SRGB_TARGET: srgb
+          SRGB_TARGET: srgb,
+          TRANSPARENT: alpha,
+          BLOOM: bloom
         }
       );
       if (!pipeline) return;
@@ -79,7 +85,7 @@ function tonemapNode() {
           flags |= 4;
         }
       }
-      scratch.fill(0, 0, 32);
+      scratch.fill(0, 0, 36);
       u[0] = cam.curve;
       u[1] = cam.dither ? 1 : 0;
       u[2] = flags;
@@ -97,20 +103,30 @@ function tonemapNode() {
       scratch[26] = cam.width / Math.max(1, cam.height);
       scratch[28] = 1 / cam.width;
       scratch[29] = 1 / cam.height;
-      const params = cache.buffer(gpu, `${ctx.view.name}/tonemap`, 128);
-      params.write(scratch, 0, 0, 32);
+      const chain = bloom ? ctx.texture("bloom") : void 0;
+      if (chain) {
+        const b = post.bloom;
+        scratch[32] = b.intensity;
+        scratch[33] = chain.mipLevelCount;
+        scratch[34] = b.threshold > 0 ? 0 : 1;
+      }
+      const params = cache.buffer(gpu, `${ctx.view.name}/tonemap`, 144);
+      params.write(scratch, 0, 0, 36);
       const hdr = ctx.texture("post-hdr");
-      const lutView = lut ?? white.createView();
       const group = cache.group(
         gpu,
         `${ctx.view.name}/tonemap`,
-        `${idOf(hdr)}/${params.version}/${lut ? idOf(lut) : 0}`,
+        `${idOf(hdr)}/${params.version}/${lut ? idOf(lut) : 0}/${chain ? idOf(chain) : 0}`,
         layout,
         () => [
           { binding: 0, resource: hdr.createView() },
           { binding: 1, resource: { buffer: params.buffer } },
-          { binding: 2, resource: lutView },
-          { binding: 3, resource: cache.sampler(gpu) }
+          { binding: 2, resource: lut ?? white.createView() },
+          { binding: 3, resource: cache.sampler(gpu) },
+          {
+            binding: 4,
+            resource: chain ? chain.createView({ mipLevelCount: 1 }) : white.createView()
+          }
         ]
       );
       const pass = ctx.renderPass;
@@ -144,13 +160,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 +198,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;

package/dist/features.js

@@ -0,0 +1,106 @@
+import { defineResource } from "@aethervtt/shard-core";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { clearHealthIssue, raiseHealthIssue } from "./health.js";
+const missingPlugins = /* @__PURE__ */ new WeakMap();
+function warnFeatureMissing(world, what, plugin, outcome) {
+  let seen = missingPlugins.get(world);
+  if (!seen) {
+    seen = /* @__PURE__ */ new Set();
+    missingPlugins.set(world, seen);
+  }
+  if (seen.has(plugin)) return;
+  seen.add(plugin);
+  world.tryResource(LogResource)?.log("warn", `${what}, but ${plugin} isn't installed; ${outcome}`, {
+    code: "render/feature-missing",
+    hint: `Add ${plugin} from '@aethervtt/shard-render' (forwardPlugin includes it).`
+  });
+}
+const RenderFeatures = defineResource("render/Features", {
+  description: "Render features installed, the graph nodes each adds, and its baseline strategy.",
+  init: () => /* @__PURE__ */ new Map()
+});
+function addRenderFeatures(world, ...features) {
+  const registry = world.initResource(RenderFeatures);
+  for (const feature of features) registry.set(feature.name, feature);
+}
+function featureOfNode(world, node) {
+  for (const feature of world.tryResource(RenderFeatures)?.values() ?? []) {
+    if (feature.nodes.includes(node)) return feature;
+  }
+  return void 0;
+}
+function describeFeatures(world) {
+  return [...world.tryResource(RenderFeatures)?.values() ?? []].map((f) => ({
+    name: f.name,
+    nodes: [...f.nodes],
+    baseline: f.baseline === "unsupported" ? "unsupported" : f.baseline.strategy
+  }));
+}
+const unsupported = /* @__PURE__ */ new WeakMap();
+function unsupportedNodes(world) {
+  const registry = world.initResource(RenderFeatures);
+  let cached = unsupported.get(registry);
+  if (!cached || cached.size !== registry.size) {
+    const nodes = /* @__PURE__ */ new Set();
+    for (const f of registry.values())
+      if (f.baseline === "unsupported") for (const n of f.nodes) nodes.add(n);
+    cached = { size: registry.size, nodes };
+    unsupported.set(registry, cached);
+  }
+  return cached.nodes;
+}
+function reportUnsupported(world, feature, message) {
+  raiseHealthIssue(world, {
+    code: "render/feature-unsupported",
+    severity: "degraded",
+    ref: feature,
+    message
+  });
+}
+function clearUnsupported(world, feature) {
+  clearHealthIssue(world, "render/feature-unsupported", feature);
+}
+const usage = /* @__PURE__ */ new WeakMap();
+function checkUnsupportedFeatures(world) {
+  let state = usage.get(world);
+  if (!state) {
+    state = { queries: /* @__PURE__ */ new Map(), reported: /* @__PURE__ */ new Set() };
+    usage.set(world, state);
+  }
+  const queries = state.queries;
+  for (const f of world.initResource(RenderFeatures).values()) {
+    if (f.baseline !== "unsupported" || !f.components) continue;
+    let used = false;
+    for (const c of f.components) {
+      let q = queries.get(c);
+      if (!q) {
+        q = world.query({ with: [c] });
+        queries.set(c, q);
+      }
+      for (const table of q.tables) if (table.count > 0) used = true;
+    }
+    if (used === state.reported.has(f.name)) continue;
+    if (used) {
+      state.reported.add(f.name);
+      reportUnsupported(
+        world,
+        f.name,
+        `${f.name} (${f.description}) runs on the full tier only (WebGPU with compute and storage in shaders): it draws nothing here`
+      );
+    } else {
+      state.reported.delete(f.name);
+      clearUnsupported(world, f.name);
+    }
+  }
+}
+export {
+  RenderFeatures,
+  addRenderFeatures,
+  checkUnsupportedFeatures,
+  clearUnsupported,
+  describeFeatures,
+  featureOfNode,
+  reportUnsupported,
+  unsupportedNodes,
+  warnFeatureMissing
+};

package/dist/foliage-budget.d.ts

@@ -0,0 +1,64 @@
+import { type Profiler } from '@aethervtt/shard-core';
+/** The budget key foliage's GPU time is measured by: it covers `gpu:foliage/place`, `/cull`, `/draw`. */
+export declare const FOLIAGE_SPAN_KEY = "gpu:foliage";
+export interface FoliageBudgetValue {
+    /**
+     * GPU milliseconds foliage may take a frame. 0 (the default): its `gpu:foliage` slice of the
+     * app's scenario (`App.perfScenario`) on the detected machine, and with no scenario (or an
+     * unknown machine) no target: foliage draws at full detail.
+     */
+    ms: number;
+    /** The least detail it thins to, as a share of the instances drawn at full detail. Default 0.1. */
+    minDetail: number;
+    /** Read only: the target in force (ms), 0 when none. */
+    target: number;
+    /** Read only: foliage's GPU time a frame, smoothed (ms). */
+    measuredMs: number;
+    /**
+     * Read only: the share of full detail drawn (minDetail to 1). Density is its square root and range
+     * its fourth root, so instances drawn scale with it.
+     */
+    detail: number;
+}
+export declare const FoliageBudget: import("@aethervtt/shard-core").ResourceDef<FoliageBudgetValue>;
+/**
+ * The controller: one GPU time a frame in, detail out. Smoothed (an exponential average), with
+ * hysteresis (it moves only above the target, or under 85% of it) and asymmetric steps (down 1% a
+ * sample, up 0.5%), so the lag of GPU timings (frames late) doesn't make it oscillate. Like
+ * `TerrainBudget.triangles`' LOD bias (0043), slow on purpose: density and range change gradually.
+ */
+export declare class FoliageController {
+    detail: number;
+    /** Smoothed GPU time (ms); 0 before the first sample. */
+    smoothed: number;
+    private primed;
+    /** One frame's foliage GPU time against `target` (0: none, back to full detail at once). */
+    sample(ms: number, target: number, minDetail: number): void;
+    /** No target: full detail, and the smoothing starts over. */
+    reset(): void;
+    /** The share of instances kept by thinning (the cull's density factor). */
+    get density(): number;
+    /** The share of each layer's range drawn. */
+    get rangeScale(): number;
+}
+/**
+ * Reads the GPU time a budget key covers, one GPU frame at a time, without allocating: when
+ * `gpu:frame` has a new sample, the covered spans that got one with it are summed. Span names are
+ * matched by `spanCovers` as they're interned.
+ */
+export declare class CoveredGpuTime {
+    readonly key: string;
+    /** The latest frame's covered time (ms), after `read` returned true. */
+    ms: number;
+    private ids;
+    private seen;
+    private count;
+    private scanned;
+    private frameId;
+    private frameRuns;
+    constructor(key: string);
+    /** True when a new GPU frame's timings landed since the last call; `ms` is then its covered time. */
+    read(profiler: Profiler): boolean;
+    /** New span names since the last scan: the ones the key covers join the list. */
+    private scan;
+}