@aethervtt/shard-render 0.0.1

package/dist/graph.d.ts

@@ -0,0 +1,204 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import { TexturePool } from './pool.js';
+import type { RenderTarget } from './target.js';
+import { GpuTimer } from './timer.js';
+/** Each view's final output. Nodes that write it are what the graph exists to run. */
+export declare const VIEW_TARGET = "view-target";
+type PerView<T> = T | ((view: RenderView) => T);
+/** A per-frame texture the graph allocates from its pool. */
+export interface TransientTexture {
+    name: string;
+    /** A format, or 'view' for the view target's format (e.g. an MSAA color buffer). */
+    format: PerView<GPUTextureFormat | 'view'>;
+    /** Pixel size, 'view' to match the view's target (the default), or a divisor of it. */
+    size?: PerView<'view' | [number, number] | {
+        divide: number;
+    }>;
+    sampleCount?: PerView<number>;
+    /** Default: RENDER_ATTACHMENT | TEXTURE_BINDING. */
+    usage?: GPUTextureUsageFlags;
+    mipLevelCount?: PerView<number>;
+}
+export type ResourceRef = string | TransientTexture;
+export interface ColorAttachment {
+    resource: string;
+    /** Clears to this color (or a per-view color); omit to load existing contents. */
+    clear?: GPUColor | ((view: RenderView) => GPUColor);
+    /** Resolve target for MSAA. */
+    resolve?: string;
+    /** Mip level of the attachment (default 0). */
+    mip?: number;
+}
+export interface DepthAttachment {
+    resource: string;
+    /** Clears to this depth; omit to load. Reversed-Z renderers clear to 0. */
+    clear?: number;
+    /** Depth is only tested, not written: the attachment is bound read-only. */
+    readOnly?: boolean;
+}
+export interface RenderView {
+    /** Unique per frame, e.g. the camera entity or 'window'. */
+    name: string;
+    target: RenderTarget;
+    /**
+     * Render resolution (0051): the size of 'view'-sized textures when it differs from the target's.
+     * `view-target` is always the target itself.
+     */
+    width?: number;
+    height?: number;
+    /** Lower renders first. */
+    order: number;
+    /** Per-view data for nodes (camera matrices, etc.). */
+    data: Record<string, unknown>;
+    /**
+     * Resource names that are another resource in this view, e.g. `scene-color → hdr` when there's
+     * no MSAA. Writing an alias writes its target.
+     */
+    aliases?: Readonly<Record<string, string>>;
+}
+export interface NodeContext {
+    readonly gpu: GpuContext;
+    readonly world: World;
+    readonly view: RenderView;
+    readonly encoder: GPUCommandEncoder;
+    /** Set for render nodes. */
+    readonly renderPass: GPURenderPassEncoder | undefined;
+    /** Set for compute nodes. */
+    readonly computePass: GPUComputePassEncoder | undefined;
+    texture(name: string): GPUTexture;
+    /** 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). */
+    afterSubmit(fn: () => void): void;
+}
+export interface NodeDescriptor {
+    kind: 'render' | 'compute' | 'raw';
+    reads?: readonly string[];
+    writes?: readonly ResourceRef[];
+    /** Explicit ordering for side effects the resource lists don't capture. */
+    after?: readonly string[];
+    /**
+     * Ordering among writers of the same resource, and among independent nodes: lower runs first.
+     * Nodes in the same phase keep registration order. See `RenderPhase`.
+     */
+    phase?: number;
+    /** Runs even if nothing reads its outputs. */
+    sideEffects?: 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.
+     */
+    enabled?: (view: RenderView) => boolean;
+    /** Render nodes: attachments, set up from resources. */
+    color?: readonly ColorAttachment[] | ((view: RenderView) => readonly ColorAttachment[]);
+    depth?: DepthAttachment;
+    run(ctx: NodeContext): void;
+}
+/** Standard phases, spaced so plugins can slot nodes in between. */
+export declare const RenderPhase: {
+    readonly Setup: 0;
+    readonly Shadows: 100;
+    readonly Prepass: 200;
+    readonly Opaque: 300;
+    readonly Lighting: 350;
+    readonly Sky: 400;
+    readonly Sprites: 450;
+    readonly Transparent: 500;
+    readonly Effects3d: 550;
+    readonly Resolve: 600;
+    readonly Post: 700;
+    readonly Tonemap: 900;
+    readonly Display: 950;
+    readonly Overlay: 1000;
+    readonly Debug: 1100;
+};
+export interface ResolvedGraph {
+    order: string[];
+    culled: string[];
+}
+export interface CapturedImage {
+    width: number;
+    height: number;
+    /** RGBA8, row by row, no padding. */
+    data: Uint8Array;
+}
+/** A captured buffer of any format: floats, 4 channels per pixel (depth in R), row by row. */
+export interface CapturedBuffer {
+    width: number;
+    height: number;
+    format: GPUTextureFormat;
+    data: Float32Array;
+}
+/**
+ * Orders nodes from their resource dependencies and drops nodes whose outputs nothing needs.
+ * Pure: no GPU involved, so it's testable on its own.
+ *
+ * Rules: writers of a resource run in phase order, then registration order; a reader runs after
+ * the writers of what it reads in its own and earlier phases, and before writers in later phases;
+ * `after` adds explicit edges. A node is needed if it writes an
+ * output (the view target), has `sideEffects`, or writes something a needed node reads. `aliases`
+ * maps resource names to the resource they really are for this view.
+ */
+export declare function resolveGraph(nodes: ReadonlyMap<string, NodeDescriptor>, outputs?: ReadonlySet<string>, options?: {
+    aliases?: Readonly<Record<string, string>>;
+    view?: RenderView;
+}): ResolvedGraph;
+/**
+ * Named passes that declare what they read and write. The graph resolves an order per view
+ * configuration (enabled nodes, aliases), then runs it for every view each frame, allocating
+ * transient textures from a pool.
+ */
+export declare class RenderGraph {
+    readonly pool: TexturePool;
+    readonly timer: GpuTimer;
+    private readonly nodes;
+    /** Transient textures any node can use by name. */
+    private readonly declared;
+    private readonly gpu;
+    private readonly resolutions;
+    /** The last resolution per view name, for describe(). */
+    private readonly lastByView;
+    private captures;
+    /** Views rendered in the last frame, in order. */
+    private lastViews;
+    private readonly viewData;
+    constructor(gpu: GpuContext);
+    addNode(name: string, node: NodeDescriptor): void;
+    removeNode(name: string): void;
+    hasNode(name: string): boolean;
+    /** 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. */
+    declare(texture: TransientTexture): void;
+    /** The resolution with every node enabled and no aliases. */
+    resolve(): ResolvedGraph;
+    private resolveFor;
+    /** Whether a node after `k` loads or reads `resource` (so its contents must be stored). */
+    private loadedLater;
+    /**
+     * Copies a view's image after the next frame renders it. `buffer` names any texture resource
+     * (default: the view target): 8-bit color formats resolve as `CapturedImage`, others as floats.
+     */
+    capture(view: string): Promise<CapturedImage>;
+    capture(view: string, buffer: string): Promise<CapturedImage | CapturedBuffer>;
+    describe(): {
+        order: {
+            name: string;
+            kind: "compute" | "raw" | "render";
+            reads: string[];
+            writes: string[];
+        }[];
+        culled: string[];
+        perView: {
+            [k: string]: {
+                order: string[];
+                culled: string[];
+            };
+        };
+        pooledTextures: number;
+    };
+    /** Runs the graph for every view and submits once. */
+    execute(world: World, views: readonly RenderView[]): void;
+}
+export {};

package/dist/graph.js

@@ -0,0 +1,417 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { TexturePool } from "./pool.js";
+import { BYTES_PER_TEXEL, toFloats } from "./readback.js";
+import { GpuTimer } from "./timer.js";
+const VIEW_TARGET = "view-target";
+const RenderPhase = {
+  Setup: 0,
+  Shadows: 100,
+  Prepass: 200,
+  Opaque: 300,
+  Lighting: 350,
+  Sky: 400,
+  Sprites: 450,
+  Transparent: 500,
+  Effects3d: 550,
+  Resolve: 600,
+  Post: 700,
+  Tonemap: 900,
+  Display: 950,
+  Overlay: 1e3,
+  Debug: 1100
+};
+const resourceName = (ref) => typeof ref === "string" ? ref : ref.name;
+function canonicalOf(aliases, name) {
+  if (!aliases) return name;
+  let n = name;
+  for (let i = 0; i < 8 && aliases[n] !== void 0; i++) n = aliases[n];
+  return n;
+}
+function colorOf(node, view) {
+  const c = node.color;
+  if (typeof c === "function") return view ? c(view) : [];
+  return c ?? [];
+}
+function resolveGraph(nodes, outputs = /* @__PURE__ */ new Set([VIEW_TARGET]), options = {}) {
+  const canon = (name) => canonicalOf(options.aliases, name);
+  const registration = [...nodes.keys()];
+  const rank = new Map(registration.map((n, i) => [n, i]));
+  const names = [...registration].sort(
+    (a, b) => (nodes.get(a).phase ?? 0) - (nodes.get(b).phase ?? 0) || rank.get(a) - rank.get(b)
+  );
+  const writesOf = (node) => (node.writes ?? []).map((r) => canon(resourceName(r)));
+  const readsOf = (node) => (node.reads ?? []).map(canon);
+  const writers = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    for (const r of writesOf(nodes.get(name))) writers.set(r, [...writers.get(r) ?? [], name]);
+  }
+  const needed = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const name of names) {
+    const node = nodes.get(name);
+    if (node.sideEffects || writesOf(node).some((r) => outputs.has(r))) stack.push(name);
+  }
+  while (stack.length > 0) {
+    const name = stack.pop();
+    if (needed.has(name)) continue;
+    needed.add(name);
+    const node = nodes.get(name);
+    for (const r of readsOf(node)) for (const w of writers.get(r) ?? []) stack.push(w);
+    for (const a of colorOf(node, options.view)) {
+      if (a.clear === void 0) for (const w of writers.get(canon(a.resource)) ?? []) stack.push(w);
+    }
+    if (node.depth && node.depth.clear === void 0) {
+      for (const w of writers.get(canon(node.depth.resource)) ?? []) stack.push(w);
+    }
+  }
+  const live = names.filter((n) => needed.has(n));
+  const index = new Map(live.map((n, i) => [n, i]));
+  const edges = live.map(() => /* @__PURE__ */ new Set());
+  const link = (from, to) => {
+    const a = index.get(from);
+    const b = index.get(to);
+    if (a !== void 0 && b !== void 0 && a !== b) edges[a].add(b);
+  };
+  const phaseOf = (name) => nodes.get(name).phase ?? 0;
+  for (const [resource, ws] of writers) {
+    const liveWriters = ws.filter((w) => needed.has(w));
+    for (let i = 1; i < liveWriters.length; i++) link(liveWriters[i - 1], liveWriters[i]);
+    for (const name of live) {
+      const node = nodes.get(name);
+      if (!writesOf(node).includes(resource) && readsOf(node).includes(resource)) {
+        for (const w of liveWriters) {
+          if (phaseOf(w) > phaseOf(name)) link(name, w);
+          else link(w, name);
+        }
+      }
+    }
+  }
+  for (const name of live) for (const dep of nodes.get(name).after ?? []) link(dep, name);
+  const indegree = live.map(() => 0);
+  for (const set of edges) for (const to of set) indegree[to]++;
+  const order = [];
+  const done = live.map(() => false);
+  for (let step = 0; step < live.length; step++) {
+    const next = indegree.findIndex((d, i) => d === 0 && !done[i]);
+    if (next === -1) {
+      const stuck = live.filter((_, i) => !done[i]);
+      throw new ShardError(
+        "render/graph-cycle",
+        `Render graph nodes form a cycle: ${stuck.join(", ")}`,
+        { hint: "Check reads/writes and `after` on these nodes." }
+      );
+    }
+    done[next] = true;
+    order.push(live[next]);
+    for (const to of edges[next]) indegree[to]--;
+  }
+  return { order, culled: registration.filter((n) => !needed.has(n)) };
+}
+const perView = (value, view) => typeof value === "function" ? value(view) : value;
+class RenderGraph {
+  pool;
+  timer;
+  nodes = /* @__PURE__ */ new Map();
+  /** Transient textures any node can use by name. */
+  declared = /* @__PURE__ */ new Map();
+  gpu;
+  resolutions = /* @__PURE__ */ new Map();
+  /** The last resolution per view name, for describe(). */
+  lastByView = /* @__PURE__ */ new Map();
+  captures = [];
+  /** Views rendered in the last frame, in order. */
+  lastViews = [];
+  viewData = /* @__PURE__ */ new Map();
+  constructor(gpu) {
+    this.gpu = gpu;
+    this.pool = new TexturePool(gpu);
+    this.timer = new GpuTimer(gpu);
+  }
+  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();
+  }
+  removeNode(name) {
+    this.nodes.delete(name);
+    this.resolutions.clear();
+  }
+  hasNode(name) {
+    return this.nodes.has(name);
+  }
+  /** The data of a view rendered in the last frame. */
+  lastViewData(view) {
+    return this.viewData.get(view);
+  }
+  /** Declares a transient texture any node can write, read, or attach by name. */
+  declare(texture) {
+    this.declared.set(texture.name, texture);
+  }
+  /** The resolution with every node enabled and no aliases. */
+  resolve() {
+    return this.resolveFor(void 0);
+  }
+  resolveFor(view) {
+    let key = "";
+    const enabled = /* @__PURE__ */ new Map();
+    for (const [name, node] of this.nodes) {
+      const on = !view || !node.enabled || node.enabled(view);
+      key += on ? "1" : "0";
+      if (on) enabled.set(name, node);
+    }
+    const aliases = view?.aliases;
+    if (aliases) for (const k in aliases) key += `|${k}>${aliases[k]}`;
+    if (view) {
+      for (const node of enabled.values()) {
+        if (typeof node.color === "function") {
+          for (const a of node.color(view)) key += a.clear === void 0 ? "L" : "C";
+        }
+      }
+    }
+    let resolved = this.resolutions.get(key);
+    if (!resolved) {
+      resolved = resolveGraph(enabled, /* @__PURE__ */ new Set([VIEW_TARGET]), { aliases, view });
+      resolved = {
+        order: resolved.order,
+        culled: [...this.nodes.keys()].filter((n) => !resolved.order.includes(n))
+      };
+      this.resolutions.set(key, resolved);
+    }
+    return resolved;
+  }
+  /** 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);
+    for (let j = k + 1; j < order.length; j++) {
+      const node = this.nodes.get(order[j]);
+      for (const r of node.reads ?? []) if (canonicalOf(view.aliases, r) === canonical) return true;
+      for (const a of colorOf(node, view)) {
+        if (canonicalOf(view.aliases, a.resource) === canonical) return a.clear === void 0;
+      }
+    }
+    return this.captures.some((c) => c.view === view.name && c.buffer === resource);
+  }
+  capture(view, buffer = VIEW_TARGET) {
+    return new Promise(
+      (resolve, reject) => this.captures.push({ view, buffer, resolve, reject })
+    );
+  }
+  describe() {
+    const { order, culled } = this.resolve();
+    const describeOrder = (names) => names.map((name) => {
+      const node = this.nodes.get(name);
+      return {
+        name,
+        kind: node.kind,
+        reads: [...node.reads ?? []],
+        writes: (node.writes ?? []).map(resourceName)
+      };
+    });
+    return {
+      order: describeOrder(order),
+      culled,
+      perView: Object.fromEntries(
+        this.lastViews.filter((v) => this.lastByView.has(v)).map((v) => [
+          v,
+          { order: this.lastByView.get(v).order, culled: this.lastByView.get(v).culled }
+        ])
+      ),
+      pooledTextures: this.pool.size
+    };
+  }
+  /** Runs the graph for every view and submits once. */
+  execute(world, views) {
+    const device = this.gpu.device;
+    const encoder = device.createCommandEncoder({ label: "frame" });
+    this.pool.beginFrame();
+    this.timer.beginFrame();
+    const readbacks = [];
+    const submitted = [];
+    const sorted = [...views].sort((a, b) => a.order - b.order);
+    this.lastViews = sorted.map((v) => v.name);
+    this.viewData.clear();
+    for (const v of sorted) this.viewData.set(v.name, v.data);
+    for (const view of sorted) {
+      const resolved = this.resolveFor(view);
+      const order = resolved.order;
+      this.lastByView.set(view.name, resolved);
+      const textures = /* @__PURE__ */ new Map();
+      textures.set(VIEW_TARGET, view.target.texture());
+      const inline = /* @__PURE__ */ new Map();
+      for (const name of order) {
+        for (const ref of this.nodes.get(name).writes ?? []) {
+          if (typeof ref !== "string") inline.set(ref.name, ref);
+        }
+      }
+      const texture = (name) => {
+        const canonical = canonicalOf(view.aliases, name);
+        let t = textures.get(canonical);
+        if (t) return t;
+        const desc = inline.get(canonical) ?? this.declared.get(canonical);
+        if (!desc) {
+          throw new ShardError(
+            "render/missing-resource",
+            `Render graph resource "${name}" is not available`,
+            {
+              hint: "Declare it in a node's `writes` (as a transient texture) or with graph.declare."
+            }
+          );
+        }
+        const size = perView(desc.size ?? "view", view);
+        const vw = view.width ?? view.target.width;
+        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);
+        t = this.pool.acquire({
+          label: `${view.name}/${canonical}`,
+          format: format === "view" ? view.target.format : format,
+          size: px,
+          sampleCount: perView(desc.sampleCount ?? 1, view),
+          mipLevelCount: perView(desc.mipLevelCount ?? 1, view),
+          usage: (desc.usage ?? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING) | GPUTextureUsage.COPY_SRC
+        });
+        textures.set(canonical, t);
+        return t;
+      };
+      const timestamps = (name) => this.timer.allocate(name);
+      const afterSubmit = (fn) => void submitted.push(fn);
+      for (let k = 0; k < order.length; k++) {
+        const name = order[k];
+        const node = this.nodes.get(name);
+        let renderPass;
+        let computePass;
+        if (node.kind === "render") {
+          const colors = colorOf(node, view);
+          renderPass = encoder.beginRenderPass({
+            label: `${view.name}/${name}`,
+            colorAttachments: colors.map((a) => ({
+              view: texture(a.resource).createView({ baseMipLevel: a.mip ?? 0, mipLevelCount: 1 }),
+              resolveTarget: a.resolve ? texture(a.resolve).createView() : void 0,
+              loadOp: a.clear === void 0 ? "load" : "clear",
+              clearValue: typeof a.clear === "function" ? a.clear(view) : a.clear,
+              // A resolved MSAA buffer that no later pass loads never needs to reach memory.
+              storeOp: a.resolve && !this.loadedLater(order, k, a.resource, view) ? "discard" : "store"
+            })),
+            depthStencilAttachment: node.depth ? node.depth.readOnly ? { view: texture(node.depth.resource).createView(), depthReadOnly: true } : {
+              view: texture(node.depth.resource).createView(),
+              depthLoadOp: node.depth.clear === void 0 ? "load" : "clear",
+              depthClearValue: node.depth.clear ?? 0,
+              depthStoreOp: "store"
+            } : void 0,
+            timestampWrites: this.timer.allocate(name)
+          });
+        } 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();
+        computePass?.end();
+      }
+      for (const capture of this.captures) {
+        if (capture.view !== view.name) continue;
+        let source;
+        try {
+          source = texture(capture.buffer);
+        } catch (err) {
+          capture.reject(err);
+          continue;
+        }
+        const { width, height, format } = source;
+        const bpp = BYTES_PER_TEXEL[format];
+        if (!bpp || source.sampleCount > 1) {
+          capture.reject(
+            new ShardError(
+              "render/capture-format",
+              `Can't capture "${capture.buffer}" (${format})`
+            )
+          );
+          continue;
+        }
+        const bytesPerRow = Math.ceil(width * bpp / 256) * 256;
+        const buffer = device.createBuffer({
+          label: `capture/${view.name}/${capture.buffer}`,
+          size: bytesPerRow * height,
+          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+        });
+        encoder.copyTextureToBuffer(
+          { texture: source, aspect: format.startsWith("depth") ? "depth-only" : "all" },
+          { buffer, bytesPerRow },
+          [width, height]
+        );
+        readbacks.push({ capture, buffer, width, height, format, bytesPerRow });
+      }
+    }
+    this.captures = this.captures.filter((c) => !readbacks.some((r) => r.capture === c));
+    this.timer.resolve(encoder);
+    device.queue.submit([encoder.finish()]);
+    this.timer.readback(world);
+    for (const fn of submitted) fn();
+    for (const r of readbacks) {
+      const { capture, buffer, width, height, format, bytesPerRow } = r;
+      buffer.mapAsync(GPUMapMode.READ).then(
+        () => {
+          const src = buffer.getMappedRange();
+          const eightBit = BYTES_PER_TEXEL[format] === 4 && /^(rgba8|bgra8)/.test(format);
+          if (eightBit) {
+            const bytes = new Uint8Array(src);
+            const data2 = new Uint8Array(width * height * 4);
+            const bgra = format.startsWith("bgra");
+            for (let y = 0; y < height; y++) {
+              const row = bytes.subarray(y * bytesPerRow, y * bytesPerRow + width * 4);
+              if (!bgra) {
+                data2.set(row, y * width * 4);
+                continue;
+              }
+              for (let x = 0; x < width * 4; x += 4) {
+                const o = y * width * 4 + x;
+                data2[o] = row[x + 2];
+                data2[o + 1] = row[x + 1];
+                data2[o + 2] = row[x];
+                data2[o + 3] = row[x + 3];
+              }
+            }
+            buffer.unmap();
+            buffer.destroy();
+            capture.resolve({ width, height, data: data2 });
+            return;
+          }
+          const data = new Float32Array(width * height * 4);
+          for (let y = 0; y < height; y++) {
+            toFloats(
+              src.slice(y * bytesPerRow, (y + 1) * bytesPerRow),
+              format,
+              width,
+              data,
+              y * width * 4
+            );
+          }
+          buffer.unmap();
+          buffer.destroy();
+          capture.resolve({ width, height, format, data });
+        },
+        (err) => capture.reject(err)
+      );
+    }
+  }
+}
+export {
+  RenderGraph,
+  RenderPhase,
+  VIEW_TARGET,
+  resolveGraph
+};

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+export { AssetStore, MaterialAsset, MaterialAssetType, MaterialImporter, Materials, type MaterialValue, MeshAsset, Meshes, materialFields, materialFromJson, materialTypeOf, 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 { captureShadowMap, DEBUG_VIEWS, type DebugView, describeCulling, describeLighting, readBuffer, readTextureLayer, setDebugView, } from './debug-views.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';
+export { renderDescribePlugin } from './describe-plugin.js';
+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 { fxaaPlugin } from './fxaa.js';
+export { LABEL_FONT, 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 { 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 { 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 { 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 { 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 { 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 { describeRenderScale, RenderScale, type RenderScaleValue, SCALE_STEP, scaledSize, } from './render-scale.js';
+export { ENGINE_SHADERS, materialLayout, registerEngineShaders, registerShaders, ViewUniform, viewLayout, } from './shaders.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 { 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 { ComputedVisibility, computeVisibility, Visibility } from './visibility.js';