@aethervtt/shard-render 0.0.1 → 0.1.0

package/dist/target.js

@@ -1,27 +1,3 @@
-class WindowTarget {
-  label = "window";
-  renderScale = true;
-  gpu;
-  constructor(gpu) {
-    this.gpu = gpu;
-  }
-  get format() {
-    return this.gpu.format;
-  }
-  get width() {
-    return this.gpu.canvas?.width ?? 1;
-  }
-  get pixelRatio() {
-    return this.gpu.pixelRatio;
-  }
-  get height() {
-    return this.gpu.canvas?.height ?? 1;
-  }
-  texture() {
-    this.gpu.resize();
-    return this.gpu.context.getCurrentTexture();
-  }
-}
 class OffscreenTarget {
   label;
   format;
@@ -65,6 +41,5 @@ class OffscreenTarget {
   }
 }
 export {
-  OffscreenTarget,
-  WindowTarget
+  OffscreenTarget
 };

package/dist/testing.d.ts

@@ -32,3 +32,13 @@ export declare function compareGolden(dir: string, name: string, image: {
     height: number;
     data: Uint8Array;
 }): GoldenResult;
+/**
+ * Watches a device for what the baseline tier (0064) must never ask for: compute passes, and
+ * storage buffers visible to the vertex or fragment stage. Counts from now on.
+ */
+export declare function watchBaseline(gpu: import('@aethervtt/shard-gpu').GpuContext): {
+    computePasses: number;
+    renderStorage: string[];
+};
+/** Mean absolute difference of two images' bytes. */
+export declare function meanDifference(a: ArrayLike<number>, b: ArrayLike<number>): number;

package/dist/testing.js

@@ -116,11 +116,43 @@ function compareGolden(dir, name, image) {
   }
   return { mean: sum / expected.length, max, written: false };
 }
+function watchBaseline(gpu) {
+  const found = { computePasses: 0, renderStorage: [] };
+  const device = gpu.device;
+  const createEncoder = device.createCommandEncoder.bind(device);
+  device.createCommandEncoder = (descriptor) => {
+    const encoder = createEncoder(descriptor);
+    const begin = encoder.beginComputePass.bind(encoder);
+    encoder.beginComputePass = (d) => {
+      found.computePasses++;
+      return begin(d);
+    };
+    return encoder;
+  };
+  const createLayout = device.createBindGroupLayout.bind(device);
+  device.createBindGroupLayout = (descriptor) => {
+    for (const e of descriptor.entries) {
+      const render = e.visibility & (GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
+      const t = e.buffer?.type;
+      if (render && (t === "storage" || t === "read-only-storage"))
+        found.renderStorage.push(`${descriptor.label ?? "?"}#${e.binding}`);
+    }
+    return createLayout(descriptor);
+  };
+  return found;
+}
+function meanDifference(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) sum += Math.abs(a[i] - b[i]);
+  return sum / a.length;
+}
 export {
   compareGolden,
   comparePng,
+  meanDifference,
   pixel,
   pngBytes,
   renderView,
-  settle
+  settle,
+  watchBaseline
 };

package/dist/tier.d.ts

@@ -0,0 +1,13 @@
+import type { GpuContext } from '@aethervtt/shard-gpu';
+/**
+ * A texture's binding dimension, fixed at creation on baseline (compatibility mode and WebGL2):
+ * spread into the texture descriptor. Nothing on the full tier.
+ */
+export declare function bindingDimension(gpu: GpuContext, dimension: GPUTextureViewDimension): {
+    textureBindingViewDimension?: GPUTextureViewDimension;
+};
+/**
+ * The layout entry for a depth texture read without comparison. On baseline the shader rewrite
+ * reads it as a float texture (naga can't load from depth), so it binds as unfilterable float.
+ */
+export declare function depthReadEntry(gpu: GpuContext, binding: number, visibility: GPUShaderStageFlags, viewDimension?: GPUTextureViewDimension): GPUBindGroupLayoutEntry;

package/dist/tier.js

@@ -0,0 +1,14 @@
+function bindingDimension(gpu, dimension) {
+  return gpu.tier === "baseline" ? { textureBindingViewDimension: dimension } : {};
+}
+function depthReadEntry(gpu, binding, visibility, viewDimension = "2d") {
+  return {
+    binding,
+    visibility,
+    texture: gpu.tier === "baseline" ? { sampleType: "unfilterable-float", viewDimension } : viewDimension === "2d" ? { sampleType: "depth" } : { sampleType: "depth", viewDimension }
+  };
+}
+export {
+  bindingDimension,
+  depthReadEntry
+};

package/dist/timer.d.ts

@@ -18,6 +18,8 @@ export declare class GpuTimer {
     private generation;
     private readonly gpu;
     constructor(gpu: GpuContext);
+    /** Destroys the query set; buffers are released with the rest of the app's (0052). */
+    destroy(): void;
     beginFrame(): void;
     /** Timestamp writes for the next pass, or undefined when timing is off or full. */
     allocate(name: string): GPURenderPassTimestampWrites | undefined;

package/dist/timer.js

@@ -22,6 +22,12 @@ class GpuTimer {
     this.gpu = gpu;
     this.enabled = gpu.features.has("timestamp-query");
   }
+  /** Destroys the query set; buffers are released with the rest of the app's (0052). */
+  destroy() {
+    this.querySet?.destroy();
+    this.querySet = void 0;
+    this.generation = this.gpu.generation;
+  }
   beginFrame() {
     this.names = [];
     if (!this.enabled || this.generation === this.gpu.generation) return;
@@ -117,7 +123,7 @@ class GpuTimer {
           }
           if (b > a) profiler?.record(label, Number(b - a) / 1e6);
         }
-        if (last > first) {
+        if (first !== 0n) {
           this.frameMs = Number(last - first) / 1e6;
           this.frameSamples++;
           profiler?.record("gpu:frame", this.frameMs);

package/dist/variants.d.ts

@@ -0,0 +1,37 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { App } from '@aethervtt/shard-runtime';
+/** A kind of manifest entry, and how to show the variants it names. */
+export interface ShaderVariantSource {
+    /** The entry's key: `{ "dice": … }` is run by the source named `dice`. */
+    readonly name: string;
+    readonly description: string;
+    /**
+     * Shows every variant `entry` names for at least a frame, stepping the app until their pipelines
+     * are made (`app.update`, then `Shaders.whenIdle` and `gpu.pipelines.whenIdle`). Returns how many
+     * variants it showed.
+     */
+    show(app: App, entry: unknown): Promise<number>;
+}
+export declare const ShaderVariantSources: import("@aethervtt/shard-core").ResourceDef<Map<string, ShaderVariantSource>>;
+/** Registers a manifest entry kind. Plugins call it in `build`. */
+export declare function addShaderVariantSource(world: World, source: ShaderVariantSource): void;
+/** The manifest's shape. */
+export interface ShaderVariantManifest {
+    variants: Record<string, unknown>[];
+}
+/** Runs one manifest entry through its source. Throws `render/unknown-variant-source` for a key no plugin registered. */
+export declare function showVariants(app: App, entry: Record<string, unknown>): Promise<number>;
+/** A material asset's path (or guid) and parameter overrides. */
+export interface MaterialVariantEntry {
+    path?: string;
+    guid?: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * Shows what `spawn` makes to a camera of its own (an offscreen target, a shadowed sun), stepping
+ * the app until every pipeline it asked for is made, then takes it all away again. For variant
+ * sources: what's drawn is what a bake records.
+ */
+export declare function showToCamera(app: App, spawn: (at: [number, number, number]) => Entity[]): Promise<void>;
+/** `{ "material": { "path": …, "params": … } }`: a material asset, with its parameters set, on a cube. */
+export declare const materialVariants: ShaderVariantSource;

package/dist/variants.js

@@ -0,0 +1,104 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import {
+  defineResource,
+  ShardError
+} from "@aethervtt/shard-core";
+import { cube } from "@aethervtt/shard-mesh";
+import { lookAt, Transform } from "@aethervtt/shard-transform";
+import { Materials, Meshes, RenderTargets } from "./assets.js";
+import { Camera3d } from "./camera.js";
+import { Mesh3d, MeshMaterial } from "./instances.js";
+import { DirectionalLight } from "./lights.js";
+import { Gpu, Shaders } from "./plugin.js";
+import { OffscreenTarget } from "./target.js";
+const ShaderVariantSources = defineResource(
+  "render/ShaderVariantSources",
+  {
+    description: "Kinds of shaders.variants.json entries (0064) and how to show their variants, for `shard shaders bake`.",
+    init: () => /* @__PURE__ */ new Map()
+  }
+);
+function addShaderVariantSource(world, source) {
+  world.initResource(ShaderVariantSources).set(source.name, source);
+}
+function showVariants(app, entry) {
+  const keys = Object.keys(entry);
+  if (keys.length !== 1) {
+    throw new ShardError(
+      "render/variant-entry",
+      `A shaders.variants.json entry has one key, its source: got ${keys.length ? keys.join(", ") : "none"}`
+    );
+  }
+  const name = keys[0];
+  const source = app.world.tryResource(ShaderVariantSources)?.get(name);
+  if (!source) {
+    const known = [...app.world.tryResource(ShaderVariantSources)?.keys() ?? []];
+    throw new ShardError("render/unknown-variant-source", `No shader variant source "${name}"`, {
+      hint: `Known: ${known.join(", ") || "none"}. Plugins register theirs with addShaderVariantSource.`
+    });
+  }
+  return source.show(app, entry[name]);
+}
+const STAGE = [5e4, 0, 5e4];
+async function showToCamera(app, spawn) {
+  const world = app.world;
+  const gpu = world.resource(Gpu);
+  const target = new OffscreenTarget(gpu, { label: "shader-variants", width: 64, height: 64 });
+  const ref = world.resource(RenderTargets).add(target, `render:variants/${STAGE.join(",")}`);
+  const eye = [STAGE[0], STAGE[1] + 2, STAGE[2] + 4];
+  const made = [
+    world.spawn(
+      [Camera3d, { target: ref, order: 90 }],
+      [Transform, { translation: eye, rotation: lookAt(eye, STAGE) }]
+    ),
+    world.spawn(
+      [DirectionalLight, { shadows: true }],
+      [Transform, { translation: STAGE, rotation: lookAt([0, 0, 0], [-0.4, -1, -0.3]) }]
+    ),
+    ...spawn(STAGE)
+  ];
+  try {
+    for (let i = 0; i < 8; i++) {
+      app.update(1 / 60);
+      await world.resource(Shaders).whenIdle();
+      await gpu.pipelines.whenIdle();
+    }
+  } finally {
+    for (const e of made) if (world.isAlive(e)) world.despawn(e);
+    app.update(1 / 60);
+    target.destroy?.();
+  }
+}
+const materialVariants = {
+  name: "material",
+  description: "A material asset by path or guid, with parameter overrides: { path, params? }.",
+  async show(app, entry) {
+    const list = Array.isArray(entry) ? entry : [entry];
+    const world = app.world;
+    for (const m of list) {
+      const ref = m.guid ? { guid: m.guid } : { path: m.path };
+      await assetServer(world).load(ref);
+      const material = world.resource(Materials).get(ref);
+      if (!material) {
+        throw new ShardError("render/variant-material", `No material ${m.guid ?? m.path}`);
+      }
+      if (m.params) material.set(m.params);
+      const mesh = world.resource(Meshes).add(cube({ size: 1 }));
+      await showToCamera(app, (at) => [
+        world.spawn(
+          [Mesh3d, { mesh }],
+          [MeshMaterial, { material: ref }],
+          [Transform, { translation: at }]
+        )
+      ]);
+    }
+    return list.length;
+  }
+};
+export {
+  ShaderVariantSources,
+  addShaderVariantSource,
+  materialVariants,
+  showToCamera,
+  showVariants
+};

package/dist/view-visibility-plugin.d.ts

@@ -0,0 +1,61 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { GpuBuffer } from '@aethervtt/shard-gpu';
+import { type HiddenSet } from './view-visibility.js';
+/**
+ * Every camera's hidden set, one range of words each. The GPU culler reads them from a region of
+ * its LOD state buffer; only words that changed upload there.
+ */
+export declare class HiddenSets {
+    /** Words per set: one bit per instance slot of the store's capacity. */
+    words: number;
+    data: Uint32Array<ArrayBuffer>;
+    readonly sets: Map<number, HiddenSet>;
+    /** Free set indices, reused before growing. */
+    private readonly free;
+    private count;
+    private dirty;
+    private dirtyLo;
+    private dirtyHi;
+    /** Every word uploads next time (a new layout, buffer, region or device). */
+    private all;
+    /** Where the last upload went: a buffer version (it bumps when replaced) and byte offset. */
+    private target;
+    private targetVersion;
+    private targetOffset;
+    /** Bytes uploaded by the last `upload`. */
+    uploadedBytes: number;
+    /** Resolves since start (tests: a still frame resolves nothing). */
+    resolves: number;
+    /** The set of `camera`, made on first use. */
+    setOf(camera: Entity): HiddenSet;
+    /** Frees a set: its words clear (and upload, so a reused index starts empty). */
+    drop(set: HiddenSet): void;
+    /** Makes room for `capacity` slots per set; a new width re-lays every set and uploads all. */
+    ensureSlots(capacity: number): void;
+    private layout;
+    private write;
+    /**
+     * Writes a set's new bits (from `next`, `words` long), marking only words that differ. Returns
+     * whether any did.
+     */
+    assign(set: HiddenSet, next: Uint32Array): boolean;
+    /**
+     * Uploads changed words in runs to `buffer` at `byteOffset`; everything when that's not where
+     * the last upload went, or the buffer was replaced (grown, or a new device).
+     */
+    upload(buffer: GpuBuffer, byteOffset: number): number;
+}
+/**
+ * Resolves each camera's ViewVisibility into its hidden set, after the instance slots are current.
+ * Lists resolve again only when they change, a slot is allocated or freed, or a ChildOf changes.
+ */
+export declare const resolveViewVisibility: import("@aethervtt/shard-core").SystemDef<{
+    q: import("@aethervtt/shard-core").Query;
+    hierarchy: import("@aethervtt/shard-core").Query;
+    epoch: number;
+    frame: number;
+}>;
+/** render.describe's viewVisibility section: per camera, what it hides and the slots it resolves to. */
+export declare function describeViewVisibility(world: World): Record<string, unknown>;
+/** Per-view hiding (0070): cameras' ViewVisibility lists, resolved for their culls. */
+export declare const viewVisibilityPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/view-visibility-plugin.js

@@ -0,0 +1,267 @@
+import {
+  ChildOf,
+  Children,
+  defineSystem,
+  Last
+} from "@aethervtt/shard-core";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { Camera3d } from "./camera.js";
+import { addRenderFeatures } from "./features.js";
+import { InstanceSlot, Instances, prepareInstances } from "./instances.js";
+import { RenderDescribers, RenderSet } from "./plugin.js";
+import { Cameras } from "./view.js";
+import { HiddenSetsResource, ViewVisibility } from "./view-visibility.js";
+class HiddenSets {
+  /** Words per set: one bit per instance slot of the store's capacity. */
+  words = 0;
+  data = new Uint32Array(0);
+  sets = /* @__PURE__ */ new Map();
+  /** Free set indices, reused before growing. */
+  free = [];
+  count = 0;
+  dirty = new Uint8Array(0);
+  dirtyLo = Number.POSITIVE_INFINITY;
+  dirtyHi = -1;
+  /** Every word uploads next time (a new layout, buffer, region or device). */
+  all = true;
+  /** Where the last upload went: a buffer version (it bumps when replaced) and byte offset. */
+  target;
+  targetVersion = -1;
+  targetOffset = -1;
+  /** Bytes uploaded by the last `upload`. */
+  uploadedBytes = 0;
+  /** Resolves since start (tests: a still frame resolves nothing). */
+  resolves = 0;
+  /** The set of `camera`, made on first use. */
+  setOf(camera) {
+    let set = this.sets.get(camera);
+    if (set) return set;
+    const index = this.free.pop() ?? this.count++;
+    if (index * this.words + this.words > this.data.length) this.layout(this.words, index + 1);
+    const base = index * this.words;
+    set = {
+      camera,
+      base,
+      bits: this.data.subarray(base, base + this.words),
+      slots: 0,
+      hide: [],
+      shadows: false,
+      frame: -1
+    };
+    this.sets.set(camera, set);
+    return set;
+  }
+  /** Frees a set: its words clear (and upload, so a reused index starts empty). */
+  drop(set) {
+    for (let w = 0; w < set.bits.length; w++) if (set.bits[w] !== 0) this.write(set.base + w, 0);
+    this.sets.delete(set.camera);
+    this.free.push(set.base / Math.max(1, this.words));
+  }
+  /** Makes room for `capacity` slots per set; a new width re-lays every set and uploads all. */
+  ensureSlots(capacity) {
+    const words = Math.ceil(capacity / 32);
+    if (words > this.words) this.layout(words, this.count);
+  }
+  layout(words, sets) {
+    const data = new Uint32Array(words * Math.max(1, sets * 2));
+    for (const set of this.sets.values()) {
+      const index = set.base / Math.max(1, this.words);
+      data.set(set.bits, index * words);
+      set.base = index * words;
+    }
+    this.data = data;
+    for (const set of this.sets.values()) set.bits = data.subarray(set.base, set.base + words);
+    this.words = words;
+    this.dirty = new Uint8Array(data.length);
+    this.all = true;
+  }
+  write(word, value) {
+    if (this.data[word] === value) return;
+    this.data[word] = value;
+    if (this.dirty[word]) return;
+    this.dirty[word] = 1;
+    if (word < this.dirtyLo) this.dirtyLo = word;
+    if (word > this.dirtyHi) this.dirtyHi = word;
+  }
+  /**
+   * Writes a set's new bits (from `next`, `words` long), marking only words that differ. Returns
+   * whether any did.
+   */
+  assign(set, next2) {
+    let changed = false;
+    for (let w = 0; w < set.bits.length; w++) {
+      const value = next2[w];
+      if (set.bits[w] !== value) {
+        this.write(set.base + w, value);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /**
+   * Uploads changed words in runs to `buffer` at `byteOffset`; everything when that's not where
+   * the last upload went, or the buffer was replaced (grown, or a new device).
+   */
+  upload(buffer, byteOffset) {
+    buffer.ensureCapacity(byteOffset + this.data.byteLength);
+    void buffer.buffer;
+    if (buffer !== this.target || buffer.version !== this.targetVersion || byteOffset !== this.targetOffset) {
+      this.target = buffer;
+      this.targetVersion = buffer.version;
+      this.targetOffset = byteOffset;
+      this.all = true;
+    }
+    let bytes = 0;
+    if (this.all) {
+      this.all = false;
+      this.dirty.fill(0);
+      this.dirtyLo = Number.POSITIVE_INFINITY;
+      this.dirtyHi = -1;
+      if (this.data.length === 0) return 0;
+      buffer.write(this.data, byteOffset);
+      this.uploadedBytes = this.data.byteLength;
+      return this.uploadedBytes;
+    }
+    let start = -1;
+    for (let w = this.dirtyLo; w <= this.dirtyHi + 1; w++) {
+      if (w <= this.dirtyHi && this.dirty[w] === 1) {
+        this.dirty[w] = 0;
+        if (start < 0) start = w;
+      } else if (start >= 0) {
+        buffer.write(this.data, byteOffset + start * 4, start, w - start);
+        bytes += (w - start) * 4;
+        start = -1;
+      }
+    }
+    this.dirtyLo = Number.POSITIVE_INFINITY;
+    this.dirtyHi = -1;
+    this.uploadedBytes = bytes;
+    return bytes;
+  }
+}
+let next = new Uint32Array(0);
+const stack = [];
+function resolve(world, roots, out) {
+  out.fill(0);
+  let slots = 0;
+  stack.length = 0;
+  for (const e of roots) if (e !== null && e !== void 0) stack.push(e);
+  while (stack.length > 0) {
+    const e = stack.pop();
+    if (!world.isAlive(e)) continue;
+    const table = world.entityTable(e);
+    const row = world.entityRow(e);
+    if (table.has(InstanceSlot)) {
+      const slot = table.column(InstanceSlot, "slot")[row] - 1;
+      if (slot >= 0 && (out[slot >>> 5] & 1 << (slot & 31)) === 0) {
+        out[slot >>> 5] = out[slot >>> 5] | 1 << (slot & 31);
+        slots++;
+      }
+    }
+    if (table.has(Children)) {
+      const children = table.column(Children, "entities")[row];
+      if (children) {
+        for (const c of children) if (c !== null) stack.push(c);
+      }
+    }
+  }
+  return slots;
+}
+const resolveViewVisibility = defineSystem({
+  name: "render/resolve-view-visibility",
+  description: "Resolves cameras' ViewVisibility lists to hidden slot bitsets (0070).",
+  setup: (world) => ({
+    q: world.query({ with: [Camera3d, ViewVisibility] }),
+    hierarchy: world.query({ with: [ChildOf] }),
+    epoch: -1,
+    frame: 0
+  }),
+  run: (state, world, ctx) => {
+    const sets = world.tryResource(HiddenSetsResource);
+    if (!sets) return;
+    const cameras = world.resource(Cameras);
+    const store = world.resource(Instances);
+    const frame = ++state.frame;
+    let listed = 0;
+    for (const table of state.q.tables) listed += table.count;
+    if (listed === 0 && sets.sets.size === 0) return;
+    sets.ensureSlots(store.capacity);
+    if (next.length < sets.words) next = new Uint32Array(sets.words);
+    const since = ctx.lastRunTick;
+    let moved = store.slotEpoch !== state.epoch;
+    state.epoch = store.slotEpoch;
+    if (!moved) {
+      for (const table of state.hierarchy.tables) {
+        if (table.lastStructural > since || table.lastChanged(ChildOf) > since) {
+          moved = true;
+          break;
+        }
+      }
+    }
+    for (const table of state.q.tables) {
+      const hide = table.column(ViewVisibility, "hide");
+      const shadows = table.column(ViewVisibility, "shadows");
+      const changed = table.changedTicks(ViewVisibility);
+      for (let i = 0; i < table.count; i++) {
+        const camera = table.entities[i];
+        const fresh = !sets.sets.has(camera);
+        const set = sets.setOf(camera);
+        set.frame = frame;
+        const cam = cameras.get(camera);
+        if (cam) cam.hidden = set;
+        const hideShadows = shadows[i] === 1;
+        if (!fresh && !moved && changed[i] <= since && set.shadows === hideShadows) continue;
+        const list = hide[i] ?? [];
+        const words = next.subarray(0, sets.words);
+        set.slots = resolve(world, list, words);
+        set.hide = list.filter((e) => e !== null);
+        sets.resolves++;
+        if (sets.assign(set, words) && hideShadows || set.shadows !== hideShadows)
+          store.shadowEpoch++;
+        set.shadows = hideShadows;
+      }
+    }
+    if (sets.sets.size > listed) {
+      for (const set of sets.sets.values()) {
+        if (set.frame === frame) continue;
+        const cam = cameras.get(set.camera);
+        if (cam?.hidden === set) cam.hidden = void 0;
+        if (set.shadows) store.shadowEpoch++;
+        sets.drop(set);
+      }
+    }
+  }
+});
+function describeViewVisibility(world) {
+  const out = {};
+  for (const set of world.tryResource(HiddenSetsResource)?.sets.values() ?? [])
+    out[`camera:${set.camera}`] = {
+      hide: [...set.hide],
+      slots: set.slots,
+      shadows: set.shadows ? "hide" : "keep"
+    };
+  return out;
+}
+const viewVisibilityPlugin = definePlugin({
+  name: "render/view-visibility",
+  dependencies: ["render/forward"],
+  build(app) {
+    app.insertResource(HiddenSetsResource, new HiddenSets());
+    app.addSystems(Last, resolveViewVisibility.inSet(RenderSet.Prepare).after(prepareInstances));
+  },
+  ready(app) {
+    app.world.initResource(RenderDescribers).set("viewVisibility", describeViewVisibility);
+    addRenderFeatures(app.world, {
+      name: "render/view-visibility",
+      description: "Cameras' hidden lists (ViewVisibility).",
+      nodes: [],
+      baseline: { strategy: "CPU culls read the same bits" }
+    });
+  }
+});
+export {
+  HiddenSets,
+  describeViewVisibility,
+  resolveViewVisibility,
+  viewVisibilityPlugin
+};

package/dist/view-visibility.d.ts

@@ -0,0 +1,28 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { HiddenSets } from './view-visibility-plugin.js';
+export declare const VIEW_SHADOWS: readonly ['keep', 'hide'];
+export declare const ViewVisibility: import("@aethervtt/shard-core").ComponentDef<{
+    readonly hide: import("@aethervtt/shard-core").FieldType<(number | null)[], "object">;
+    readonly shadows: import("@aethervtt/shard-core").FieldType<"hide" | "keep", "u8">;
+}>;
+/** `hiddenBase` of a view with no hidden set. */
+export declare const NO_HIDDEN = 4294967295;
+/** One camera's hidden set: a bit per instance slot, in its range of `HiddenSets.data`. */
+export interface HiddenSet {
+    camera: Entity;
+    /** Its first word in `HiddenSets.data` (and the GPU buffer). */
+    base: number;
+    /** Its words: bit `s & 31` of word `s >> 5` is slot `s`. */
+    bits: Uint32Array;
+    /** Slots it resolves to. */
+    slots: number;
+    /** The entities listed, as last resolved. */
+    hide: Entity[];
+    /** Its camera's cascades leave the slots out too. */
+    shadows: boolean;
+    /** The frame it was last seen on (sets of cameras that lose the component are freed). */
+    frame: number;
+}
+export declare const HiddenSetsResource: import("@aethervtt/shard-core").ResourceDef<HiddenSets>;
+/** Warns once per world about a ViewVisibility without its plugin (render/feature-missing). */
+export declare function observeViewVisibilityWithoutPlugin(world: World): void;