@aethervtt/shard-render 0.0.1 → 0.1.0

package/dist/interior-plugin.d.ts

@@ -0,0 +1,121 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import { type InteriorSupport } from './interior.js';
+/** Level table entries; entry `INTERIOR_GROUND` is the ground level's (pieces with no Level). */
+export declare const INTERIOR_LEVELS = 8;
+export declare const INTERIOR_GROUND = 8;
+/** A field texel's cover code: 0 uncovered, else 32768 + 64 × (cover top y − the layer's base). */
+export declare const COVER_SCALE = 64;
+export declare const COVER_ZERO = 32768;
+/** Visibility, in a field texel's low 16 bits above the two link bits. */
+export declare const VISIBILITY_MAX = 16383;
+/** A field texel's link bits: flux to the +x and +z neighbours is blocked. */
+export declare const LINK_X = 1;
+export declare const LINK_Z = 2;
+/** A row bin: distance (low 16 bits) and the barrier's top relative to the light (high), in 1/256 m. */
+export declare const ROW_SCALE = 256;
+export declare const ROW_ZERO = 32768;
+/** A bin with no barrier: the low half all ones (256 m, past any range). */
+export declare const ROW_CLEAR = 2147549183;
+export declare const INTERIOR_SHADERS: Record<string, string>;
+/**
+ * Interior lighting's GPU side: what providers write, and what forward binds. One r32uint texture
+ * array holds both parts (a stage has 16 sampled textures, and the baseline tier's standard
+ * material already uses 15): the field's layers, then the rows, `height` to a layer. Providers
+ * (structure) size and fill it, write the table, and switch the parts on; with both off nothing
+ * is bound at all.
+ */
+export declare class InteriorLighting implements InteriorSupport {
+    sky: boolean;
+    blocked: boolean;
+    provided: boolean;
+    version: number;
+    /**
+     * Set when the texture is made again (a size changed, or the device was lost): the provider
+     * writes the field and every row again, then clears it.
+     */
+    stale: boolean;
+    /** The field's size in texels and layers, and the rows' bins and count (0: none). */
+    fieldWidth: number;
+    fieldHeight: number;
+    fieldLayers: number;
+    rowBins: number;
+    rowCount: number;
+    /** The texture's size: rows sit `height` to a layer after the field's layers. */
+    width: number;
+    height: number;
+    layers: number;
+    /** The table as written; `writeTable` uploads it when it changed. */
+    readonly table: Float32Array<ArrayBuffer>;
+    private readonly sent;
+    private tableStale;
+    private texture;
+    private generation;
+    private placeholder;
+    private buffer;
+    private readonly gpu;
+    private bound;
+    constructor(gpu: GpuContext);
+    get mode(): number;
+    /**
+     * Sizes the texture for a field of `fieldLayers` layers (0: none) and `rows` rows of `bins` bins
+     * (0: none). Made again, and `stale`, only when a size changes or the device was lost.
+     */
+    configure(fieldWidth: number, fieldHeight: number, fieldLayers: number, bins: number, rows: number): void;
+    /**
+     * Whether the device was lost since the texture was made: makes it again (`stale`), so the
+     * provider writes everything once more. Providers check it each frame they're on.
+     */
+    lost(): boolean;
+    /**
+     * Writes a rectangle of field layer `layer` from `data`, a whole layer's texels (fieldWidth ×
+     * fieldHeight, row by row): only the rectangle uploads.
+     */
+    writeField(layer: number, x: number, z: number, w: number, h: number, data: Uint32Array): void;
+    /** Writes row `row` from `data` (`rowBins` bins). */
+    writeRow(row: number, data: Uint32Array): void;
+    /**
+     * Sets the table's field and size: origin (x, z), texel (m), field size, bins per row, filter
+     * taps. `writeTable` uploads.
+     */
+    setGrid(originX: number, originZ: number, texel: number, width: number, height: number, bins: number, taps: number): void;
+    /**
+     * Sets level `i`'s entry (`INTERIOR_GROUND` for the ground level): its [floor, top) y, field
+     * layer, the y its cover heights count from, its interior ambient (rgb, cd/m²) and fill share.
+     */
+    setLevel(i: number, floor: number, top: number, layer: number, base: number, ambient: ArrayLike<number>, fill: number): void;
+    /** How many levels (besides the ground's) the table holds. */
+    setLevelCount(count: number): void;
+    /** Uploads the table if it changed since the last upload. */
+    writeTable(): void;
+    /** GPU bytes the texture holds. */
+    get bytes(): number;
+    entries(gpu: GpuContext): readonly GPUBindGroupEntry[];
+    /** Frees the texture (both parts off). */
+    free(): void;
+    /** Frees everything (the plugin's dispose). */
+    destroy(): void;
+}
+export declare const InteriorLightingResource: import("@aethervtt/shard-core").ResourceDef<InteriorLighting>;
+/** render.describe's interior section. */
+export declare function describeInterior(world: World): {
+    sky: boolean;
+    blockedLights: boolean;
+    provided: boolean;
+    field: {
+        width: number;
+        height: number;
+        layers: number;
+    } | null;
+    rows: {
+        bins: number;
+        rows: number;
+    } | null;
+    bytes: number;
+} | undefined;
+/**
+ * Interior lighting (0069): the lighting stage scales sky ambient by a plan's sky visibility and
+ * occludes wall-blocked lights through polar rows, once a provider (structure's
+ * interiorLightingPlugin) turns a part on. Until then nothing links or binds differently.
+ */
+export declare const interiorPlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/interior-plugin.js

@@ -0,0 +1,465 @@
+import { defineResource } from "@aethervtt/shard-core";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { addRenderFeatures } from "./features.js";
+import {
+  INTERIOR_BINDINGS,
+  INTERIOR_BLOCKED,
+  INTERIOR_SKY,
+  InteriorPath
+} from "./interior.js";
+import { Gpu, RenderDescribers, Shaders } from "./plugin.js";
+import { registerShaders } from "./shaders.js";
+import { bindingDimension } from "./tier.js";
+const INTERIOR_LEVELS = 8;
+const INTERIOR_GROUND = INTERIOR_LEVELS;
+const TABLE_FLOATS = 12 + (INTERIOR_LEVELS + 1) * 8;
+const LEVELS_AT = 12;
+const AMBIENT_AT = 12 + (INTERIOR_LEVELS + 1) * 4;
+const COVER_SCALE = 64;
+const COVER_ZERO = 32768;
+const VISIBILITY_MAX = 16383;
+const LINK_X = 1;
+const LINK_Z = 2;
+const ROW_SCALE = 256;
+const ROW_ZERO = 32768;
+const ROW_CLEAR = 2147549183;
+const INTERIOR_SHADERS = {
+  "shard::interior": `
+import shard::pbr::lights::{ Light, LIGHT_SPOT };
+
+struct Interior {
+  /** The field's origin (x, z, m), 1 / texel, and how many levels the table holds. */
+  field: vec4f,
+  /** The field's size (texels x, z), bins per light row, filter taps. */
+  size: vec4f,
+  /** Where rows start: after the field's layers (x), \`y\` rows to a layer. */
+  rows: vec4f,
+  /**
+   * Levels by elevation: floor y, top y, field layer, the y cover heights count from. Entry 8 is
+   * the ground level's, for any y no level holds.
+   */
+  levels: array<vec4f, 9>,
+  /** Per entry: interior ambient (rgb, cd/m\xB2), and the share of the sky's ambient kept indoors. */
+  ambient: array<vec4f, 9>,
+}
+
+/** The field's layers, then the light rows. */
+@group(0) @binding(16) var interior_data: texture_2d_array<u32>;
+@group(0) @binding(17) var<uniform> interior: Interior;
+
+const INTERIOR_GROUND: u32 = 8u;
+/** How far a blocked light's receiver moves off its surface, so each face reads its own side. */
+const INTERIOR_OFFSET: f32 = 0.05;
+
+/** The table entry whose [floor, top) holds y, or the ground level's. */
+fn interior_level(y: f32) -> u32 {
+  let count = u32(interior.field.w);
+  for (var i = 0u; i < count; i++) {
+    let e = interior.levels[i];
+    if (y >= e.x && y < e.y) { return i; }
+  }
+  return INTERIOR_GROUND;
+}
+
+fn interior_visibility(texel: u32) -> f32 {
+  return f32((texel & 0xffffu) >> 2u) / ${VISIBILITY_MAX}.0;
+}
+
+/**
+ * Sky visibility at a point on a surface: 1 outdoors (outside the field, on an uncovered texel, or
+ * above its cover), else the field, filtered between the texel centres the point reaches without
+ * crossing a barrier, so light never bleeds through a wall. The point moves a texel along the
+ * normal first: a wall's inside face reads the room, not the outdoor texel next to it.
+ */
+fn sky_visibility(world: vec3f, n: vec3f, level: u32) -> f32 {
+  let p = world + n / interior.field.z;
+  let entry = interior.levels[level];
+  let size = vec2i(interior.size.xy);
+  let t = (p.xz - interior.field.xy) * interior.field.z - 0.5;
+  let home = vec2i(floor(t + 0.5));
+  if (any(home < vec2i(0)) || any(home >= size)) { return 1.0; }
+  let layer = i32(entry.z);
+  let own = textureLoad(interior_data, home, layer, 0).r;
+  let cover = own >> 16u;
+  if (cover == 0u) { return 1.0; }
+  if (p.y >= entry.w + (f32(cover) - ${COVER_ZERO}.0) / ${COVER_SCALE}.0) { return 1.0; }
+  // One filter tap (quality low): the texel alone.
+  if (interior.size.w < 1.5) { return interior_visibility(own); }
+  let f = t - floor(t);
+  let i0 = clamp(vec2i(floor(t)), vec2i(0), size - 1);
+  let i1 = min(i0 + 1, size - 1);
+  let a = textureLoad(interior_data, i0, layer, 0).r;
+  let b = textureLoad(interior_data, vec2i(i1.x, i0.y), layer, 0).r;
+  let c = textureLoad(interior_data, vec2i(i0.x, i1.y), layer, 0).r;
+  let d = textureLoad(interior_data, i1, layer, 0).r;
+  let hx = f.x >= 0.5;
+  let hz = f.y >= 0.5;
+  // Open links: along x on rows 0 and 1, along z on columns 0 and 1.
+  let ab = (a & ${LINK_X}u) == 0u;
+  let cd = (c & ${LINK_X}u) == 0u;
+  let ac = (a & ${LINK_Z}u) == 0u;
+  let bd = (b & ${LINK_Z}u) == 0u;
+  let x_home = select(ab, cd, hz);
+  let x_other = select(cd, ab, hz);
+  let z_home = select(ac, bd, hx);
+  let z_other = select(bd, ac, hx);
+  let across = select(0.0, 1.0, x_home);
+  let along = select(0.0, 1.0, z_home);
+  let diagonal = select(0.0, 1.0, (x_home && z_other) || (z_home && x_other));
+  // Weights of the home texel, its row neighbour, its column neighbour, and the diagonal one.
+  let wx = select(f.x, 1.0 - f.x, hx);
+  let wz = select(f.y, 1.0 - f.y, hz);
+  let w_home = (1.0 - wx) * (1.0 - wz);
+  let w_row = wx * (1.0 - wz) * across;
+  let w_col = (1.0 - wx) * wz * along;
+  let w_diag = wx * wz * diagonal;
+  let row = select(select(b, a, hx), select(d, c, hx), hz);
+  let col = select(select(c, d, hx), select(a, b, hx), hz);
+  let diag = select(select(d, c, hx), select(b, a, hx), hz);
+  let sum = w_home * interior_visibility(own) + w_row * interior_visibility(row)
+    + w_col * interior_visibility(col) + w_diag * interior_visibility(diag);
+  return sum / (w_home + w_row + w_col + w_diag);
+}
+
+/**
+ * Ambient light under the plan's cover: \`sky\` (the uniform ambient or the environment's light,
+ * already shaded) scaled by sky visibility s, plus the level's interior ambient on \`albedo\`
+ * (diffuse colour times occlusion) where the sky doesn't reach. Indoors the sky keeps the level's
+ * fill share: mix(fill \xD7 sky + interior, sky, s).
+ */
+fn interior_ambient(sky: vec3f, albedo: vec3f, world: vec3f, n: vec3f) -> vec3f {
+  let level = interior_level(world.y + n.y / interior.field.z);
+  let s = sky_visibility(world, n, level);
+  let a = interior.ambient[level];
+  return sky * (s + (1.0 - s) * a.w) + albedo * a.rgb * (1.0 - s);
+}
+
+/**
+ * A direction's place around the circle, 0 to 1 from \u2212x counter-clockwise (+x at \xBD): a pseudo-angle
+ * (one division, not an atan2), monotonic in the angle. Rows bin by it (interior.ts's binOf).
+ */
+fn interior_bin(v: vec2f) -> f32 {
+  let t = v.y / (abs(v.x) + abs(v.y));
+  // 0 to 4 counter-clockwise from +x: t in the first quadrant, 2 \u2212 t left of the z axis, 4 + t
+  // in the fourth quadrant.
+  let p = select(select(4.0 + t, t, t >= 0.0), 2.0 - t, v.x < 0.0);
+  return fract(p * 0.25 + 0.5);
+}
+
+/**
+ * Where wall-blocked lights (0069) test a fragment: moved off its surface along the normal (xyz),
+ * and its level (w). Once per fragment, before the light loop.
+ */
+fn interior_receiver(world: vec3f, n: vec3f) -> vec4f {
+  let p = world + n * INTERIOR_OFFSET;
+  return vec4f(p, f32(interior_level(p.y)));
+}
+
+/**
+ * How much of a wall-blocked light reaches a receiver (\`interior_receiver\`): 0 on another
+ * level, else the share of the bins around its direction whose barrier it isn't behind, or whose
+ * top the light passes over. A light without a row (its row word is 0) is unblocked.
+ */
+fn wall_visibility(light: Light, receiver: vec4f) -> f32 {
+  // Row + 1, in a word this kind never reads (LIGHT_ROW_WORD): a point's spot scale, a spot's bright.
+  let row = u32(select(light.spot_scale, light.bright, light.kind == LIGHT_SPOT));
+  if (row == 0u) { return 1.0; }
+  let p = receiver.xyz;
+  if (u32(receiver.w) != interior_level(light.position.y)) { return 0.0; }
+  let to = p.xz - light.position.xz;
+  let d = length(to);
+  if (d < 1e-4) { return 1.0; }
+  let bins = i32(interior.size.z);
+  let taps = i32(interior.size.w);
+  let at = i32(floor(interior_bin(to) * f32(bins)));
+  let r = i32(row) - 1;
+  let h = i32(interior.rows.y);
+  let first = i32(interior.rows.x);
+  var lit = 0.0;
+  for (var k = -(taps / 2); k <= taps / 2; k++) {
+    let v = textureLoad(interior_data, vec2i((at + k + bins) % bins, r % h), first + r / h, 0).r;
+    let r = f32(v & 0xffffu) / ${ROW_SCALE}.0;
+    let top = light.position.y + (f32(v >> 16u) - ${ROW_ZERO}.0) / ${ROW_SCALE}.0;
+    // Behind the barrier, unless the line from the light clears its top there.
+    let y_at = light.position.y + (p.y - light.position.y) * r / d;
+    lit += select(1.0, 0.0, d > r && y_at <= top);
+  }
+  return lit / f32(taps);
+}`
+};
+class InteriorLighting {
+  sky = false;
+  blocked = false;
+  provided = false;
+  version = 0;
+  /**
+   * Set when the texture is made again (a size changed, or the device was lost): the provider
+   * writes the field and every row again, then clears it.
+   */
+  stale = false;
+  /** The field's size in texels and layers, and the rows' bins and count (0: none). */
+  fieldWidth = 0;
+  fieldHeight = 0;
+  fieldLayers = 0;
+  rowBins = 0;
+  rowCount = 0;
+  /** The texture's size: rows sit `height` to a layer after the field's layers. */
+  width = 0;
+  height = 0;
+  layers = 0;
+  /** The table as written; `writeTable` uploads it when it changed. */
+  table = new Float32Array(TABLE_FLOATS);
+  sent = new Float32Array(TABLE_FLOATS);
+  tableStale = true;
+  texture;
+  generation = -1;
+  placeholder;
+  buffer;
+  gpu;
+  bound;
+  constructor(gpu) {
+    this.gpu = gpu;
+  }
+  get mode() {
+    return (this.sky ? INTERIOR_SKY : 0) | (this.blocked ? INTERIOR_BLOCKED : 0);
+  }
+  /**
+   * Sizes the texture for a field of `fieldLayers` layers (0: none) and `rows` rows of `bins` bins
+   * (0: none). Made again, and `stale`, only when a size changes or the device was lost.
+   */
+  configure(fieldWidth, fieldHeight, fieldLayers, bins, rows) {
+    const lost = this.texture !== void 0 && this.generation !== this.gpu.generation;
+    if (!lost && fieldWidth === this.fieldWidth && fieldHeight === this.fieldHeight && fieldLayers === this.fieldLayers && bins === this.rowBins && rows === this.rowCount)
+      return;
+    this.texture?.destroy();
+    this.texture = void 0;
+    this.fieldWidth = fieldWidth;
+    this.fieldHeight = fieldHeight;
+    this.fieldLayers = fieldLayers;
+    this.rowBins = bins;
+    this.rowCount = rows;
+    const height = fieldLayers > 0 ? Math.max(fieldHeight, Math.ceil(rows / 64)) : Math.min(rows, 2048);
+    this.width = Math.max(1, fieldWidth, bins);
+    this.height = Math.max(1, height);
+    this.layers = fieldLayers + (rows > 0 ? Math.ceil(rows / this.height) : 0);
+    const t = this.table;
+    t[8] = fieldLayers;
+    t[9] = this.height;
+    this.version++;
+    if (this.layers === 0) return;
+    this.texture = this.gpu.device.createTexture({
+      label: "interior/data",
+      size: { width: this.width, height: this.height, depthOrArrayLayers: this.layers },
+      format: "r32uint",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      ...bindingDimension(this.gpu, "2d-array")
+    });
+    this.generation = this.gpu.generation;
+    this.stale = true;
+  }
+  /**
+   * Whether the device was lost since the texture was made: makes it again (`stale`), so the
+   * provider writes everything once more. Providers check it each frame they're on.
+   */
+  lost() {
+    if (this.texture === void 0 || this.generation === this.gpu.generation) return false;
+    const { fieldWidth, fieldHeight, fieldLayers, rowBins, rowCount } = this;
+    this.configure(fieldWidth, fieldHeight, fieldLayers, rowBins, rowCount);
+    this.tableStale = true;
+    return true;
+  }
+  /**
+   * Writes a rectangle of field layer `layer` from `data`, a whole layer's texels (fieldWidth ×
+   * fieldHeight, row by row): only the rectangle uploads.
+   */
+  writeField(layer, x, z, w, h, data) {
+    if (!this.texture || w <= 0 || h <= 0 || layer >= this.fieldLayers) return;
+    this.gpu.device.queue.writeTexture(
+      { texture: this.texture, origin: { x, y: z, z: layer } },
+      data,
+      {
+        // Relative to the view's start, as WebGPU reads a typed array.
+        offset: (z * this.fieldWidth + x) * 4,
+        bytesPerRow: this.fieldWidth * 4,
+        rowsPerImage: h
+      },
+      { width: w, height: h, depthOrArrayLayers: 1 }
+    );
+  }
+  /** Writes row `row` from `data` (`rowBins` bins). */
+  writeRow(row, data) {
+    if (!this.texture || row >= this.rowCount) return;
+    this.gpu.device.queue.writeTexture(
+      {
+        texture: this.texture,
+        origin: { x: 0, y: row % this.height, z: this.fieldLayers + Math.floor(row / this.height) }
+      },
+      data,
+      { offset: 0, bytesPerRow: this.rowBins * 4 },
+      { width: this.rowBins, height: 1 }
+    );
+  }
+  /**
+   * Sets the table's field and size: origin (x, z), texel (m), field size, bins per row, filter
+   * taps. `writeTable` uploads.
+   */
+  setGrid(originX, originZ, texel, width, height, bins, taps) {
+    const t = this.table;
+    t[0] = originX;
+    t[1] = originZ;
+    t[2] = 1 / texel;
+    t[4] = width;
+    t[5] = height;
+    t[6] = bins;
+    t[7] = taps;
+  }
+  /**
+   * Sets level `i`'s entry (`INTERIOR_GROUND` for the ground level): its [floor, top) y, field
+   * layer, the y its cover heights count from, its interior ambient (rgb, cd/m²) and fill share.
+   */
+  setLevel(i, floor, top, layer, base, ambient, fill) {
+    const t = this.table;
+    const l = LEVELS_AT + i * 4;
+    t[l] = floor;
+    t[l + 1] = top;
+    t[l + 2] = layer;
+    t[l + 3] = base;
+    const a = AMBIENT_AT + i * 4;
+    t[a] = ambient[0];
+    t[a + 1] = ambient[1];
+    t[a + 2] = ambient[2];
+    t[a + 3] = fill;
+  }
+  /** How many levels (besides the ground's) the table holds. */
+  setLevelCount(count) {
+    this.table[3] = Math.min(count, INTERIOR_LEVELS);
+  }
+  /** Uploads the table if it changed since the last upload. */
+  writeTable() {
+    const t = this.table;
+    let same = !this.tableStale && this.buffer !== void 0;
+    for (let i = 0; same && i < t.length; i++) if (!Object.is(t[i], this.sent[i])) same = false;
+    if (same) return;
+    if (!this.buffer) {
+      this.buffer = new GpuBuffer(this.gpu, {
+        label: "interior/table",
+        usage: GPUBufferUsage.UNIFORM,
+        size: TABLE_FLOATS * 4
+      });
+      this.version++;
+    }
+    this.buffer.write(t);
+    this.sent.set(t);
+    this.tableStale = false;
+  }
+  /** GPU bytes the texture holds. */
+  get bytes() {
+    return this.texture ? this.width * this.height * this.layers * 4 : 0;
+  }
+  entries(gpu) {
+    if (!this.buffer) this.writeTable();
+    const buffer = this.buffer;
+    const gpuBuffer = buffer.buffer;
+    const version = this.version * 4096 + buffer.version;
+    if (this.bound?.version === version) return this.bound.entries;
+    let texture = this.texture;
+    if (!texture || this.generation !== gpu.generation) {
+      if (!this.placeholder || this.placeholder.generation !== gpu.generation) {
+        this.placeholder = {
+          texture: gpu.device.createTexture({
+            label: "interior/placeholder",
+            size: { width: 1, height: 1, depthOrArrayLayers: 1 },
+            format: "r32uint",
+            usage: GPUTextureUsage.TEXTURE_BINDING,
+            ...bindingDimension(gpu, "2d-array")
+          }),
+          generation: gpu.generation
+        };
+      }
+      texture = this.placeholder.texture;
+    }
+    const entries = [
+      { binding: INTERIOR_BINDINGS.data, resource: texture.createView({ dimension: "2d-array" }) },
+      { binding: INTERIOR_BINDINGS.table, resource: { buffer: gpuBuffer } }
+    ];
+    this.bound = { version, entries };
+    return entries;
+  }
+  /** Frees the texture (both parts off). */
+  free() {
+    if (!this.texture) return;
+    this.texture.destroy();
+    this.texture = void 0;
+    this.fieldWidth = this.fieldHeight = this.fieldLayers = this.rowBins = this.rowCount = 0;
+    this.width = this.height = this.layers = 0;
+    this.version++;
+  }
+  /** Frees everything (the plugin's dispose). */
+  destroy() {
+    this.free();
+    this.placeholder?.texture.destroy();
+    this.buffer?.destroy();
+  }
+}
+const InteriorLightingResource = defineResource(
+  "render/InteriorLighting",
+  {
+    description: "Interior lighting's textures and level table (0069): sky visibility field, wall-blocked lights' rows. Structure's interiorLightingPlugin fills them."
+  }
+);
+function describeInterior(world) {
+  const s = world.tryResource(InteriorLightingResource);
+  if (!s) return void 0;
+  return {
+    sky: s.sky,
+    blockedLights: s.blocked,
+    provided: s.provided,
+    field: s.fieldLayers > 0 ? { width: s.fieldWidth, height: s.fieldHeight, layers: s.fieldLayers } : null,
+    rows: s.rowCount > 0 ? { bins: s.rowBins, rows: s.rowCount } : null,
+    bytes: s.bytes
+  };
+}
+const interiorPlugin = definePlugin({
+  name: "render/interior",
+  dependencies: ["render/forward"],
+  provides: [InteriorLightingResource],
+  build() {
+  },
+  ready(app) {
+    const world = app.world;
+    const state = new InteriorLighting(world.resource(Gpu));
+    app.insertResource(InteriorLightingResource, state);
+    app.insertResource(InteriorPath, state);
+    registerShaders(world.resource(Shaders), INTERIOR_SHADERS);
+    world.initResource(RenderDescribers).set("interior", describeInterior);
+    addRenderFeatures(world, {
+      name: "render/interior",
+      description: "Sky visibility and wall-blocked lights from a structure plan.",
+      nodes: [],
+      baseline: {
+        strategy: "The same integer texture loads (texelFetch); the table a uniform block"
+      }
+    });
+  },
+  dispose(app) {
+    app.world.tryResource(InteriorLightingResource)?.destroy();
+  }
+});
+export {
+  COVER_SCALE,
+  COVER_ZERO,
+  INTERIOR_GROUND,
+  INTERIOR_LEVELS,
+  INTERIOR_SHADERS,
+  InteriorLighting,
+  InteriorLightingResource,
+  LINK_X,
+  LINK_Z,
+  ROW_CLEAR,
+  ROW_SCALE,
+  ROW_ZERO,
+  VISIBILITY_MAX,
+  describeInterior,
+  interiorPlugin
+};

package/dist/interior.d.ts

@@ -0,0 +1,24 @@
+import type { GpuContext } from '@aethervtt/shard-gpu';
+/** `InteriorSupport.mode` bits. */
+export declare const INTERIOR_SKY = 1;
+export declare const INTERIOR_BLOCKED = 2;
+/** The view group's bindings while a mode bit is on: the field and rows (one texture), the table. */
+export declare const INTERIOR_BINDINGS: {
+    readonly data: 16;
+    readonly table: 17;
+};
+/**
+ * Set by `interiorPlugin`: what forward needs to link and bind the interior variants. With mode 0
+ * the view group and every shader are as they are without the plugin.
+ */
+export interface InteriorSupport {
+    /** INTERIOR_SKY | INTERIOR_BLOCKED this frame. */
+    readonly mode: number;
+    /** Whether something fills the field and rows (structure's interiorLightingPlugin). */
+    readonly provided: boolean;
+    /** Bumps when an entry's resource changes (a texture grows): the view bind group is rebuilt. */
+    readonly version: number;
+    /** The view group's extra entries (INTERIOR_BINDINGS): a placeholder until there's data. */
+    entries(gpu: GpuContext): readonly GPUBindGroupEntry[];
+}
+export declare const InteriorPath: import("@aethervtt/shard-core").ResourceDef<InteriorSupport>;

package/dist/interior.js

@@ -0,0 +1,13 @@
+import { defineResource } from "@aethervtt/shard-core";
+const INTERIOR_SKY = 1;
+const INTERIOR_BLOCKED = 2;
+const INTERIOR_BINDINGS = { data: 16, table: 17 };
+const InteriorPath = defineResource("render/InteriorPath", {
+  description: "Present when interior lighting (interiorPlugin) is installed."
+});
+export {
+  INTERIOR_BINDINGS,
+  INTERIOR_BLOCKED,
+  INTERIOR_SKY,
+  InteriorPath
+};

package/dist/layers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Which cameras draw this renderable: it draws in a view when `mask & Camera3d.layers` is
+ * nonzero. Absent means layer 1. Culling tests it first, so a hidden visual costs no draw.
+ */
+export declare const RenderLayers: import("@aethervtt/shard-core").ComponentDef<{
+    readonly mask: import("@aethervtt/shard-core").FieldType<number, "u16">;
+}>;
+/**
+ * The default ground bands, bottom to top. A host may renumber them; only the order matters.
+ * Floors are opaque, write depth, and sit under every band.
+ */
+export declare const GROUND_BANDS: {
+    readonly tiles: 10;
+    readonly grid: 20;
+    readonly drawings: 30;
+    readonly 'tokens-flat': 40;
+    readonly fog: 50;
+    readonly overlay: 60;
+};
+export type GroundBand = keyof typeof GROUND_BANDS;
+/**
+ * Bands from this one up draw after the transparent phase and projected fog (0058), so fog never
+ * covers them: selection rings, pings, measurement templates.
+ */
+export declare const OVERLAY_BAND: 60;
+/**
+ * Coplanar content on a floor, drawn after opaque geometry in `(band, order)` order with the depth
+ * test on and depth writes off: walls and props in front hide it, and bands never fight each other.
+ * Ground renderables cast no shadows.
+ */
+export declare const GroundLayer: import("@aethervtt/shard-core").ComponentDef<{
+    readonly band: import("@aethervtt/shard-core").FieldType<number, "i16">;
+    readonly order: import("@aethervtt/shard-core").FieldType<number, "i32">;
+    readonly level: import("@aethervtt/shard-core").FieldType<number, "i8">;
+}>;