@aethervtt/shard-render 0.0.1

package/dist/large-world.d.ts

@@ -0,0 +1,13 @@
+import type { World } from '@aethervtt/shard-core';
+/**
+ * Moves everything the renderer keeps from earlier frames into the new origin frame (spec 0040):
+ * previous instance transforms, each camera's last view-projection, and retained gizmos. TAA history
+ * textures hold colors, not positions, so they stay valid once reprojection lines up. Shadow
+ * cascades and light records are rebuilt from `GlobalTransform` every frame.
+ */
+export declare function shiftRenderHistory(world: World, x: number, y: number, z: number): void;
+/**
+ * Follows `OriginShift` synchronously: it fires during transform propagation (PostUpdate), after
+ * this frame's gameplay drew in the old frame and before extraction reads the new one.
+ */
+export declare function observeOriginShifts(world: World): () => void;

package/dist/large-world.js

@@ -0,0 +1,20 @@
+import { OriginShift } from "@aethervtt/shard-transform";
+import { Instances } from "./instances.js";
+import { RenderCounters } from "./stats.js";
+import { Cameras, shiftCameraHistory } from "./view.js";
+function shiftRenderHistory(world, x, y, z) {
+  world.initResource(RenderCounters).originShifts++;
+  if (x === 0 && y === 0 && z === 0) return;
+  world.tryResource(Instances)?.shiftOrigin(x, y, z);
+  const cameras = world.tryResource(Cameras);
+  if (cameras) for (const cam of cameras.values()) shiftCameraHistory(cam, x, y, z);
+}
+function observeOriginShifts(world) {
+  return world.observe(OriginShift, ({ world: w, data }) => {
+    shiftRenderHistory(w, data.offset[0], data.offset[1], data.offset[2]);
+  });
+}
+export {
+  observeOriginShifts,
+  shiftRenderHistory
+};

package/dist/lights.d.ts

@@ -0,0 +1,160 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
+/** Luminous power presets in lumens, for point and spot lights. */
+export declare const LuminousPowerPresets: {
+    readonly candle: 12;
+    readonly 'bulb-40w': 450;
+    readonly bulb: 800;
+    readonly floodlight: 20000;
+};
+export type LuminousPowerPreset = keyof typeof LuminousPowerPresets;
+/** Lumens for a preset name or a number. */
+export declare const lumens: (value: LuminousPowerPreset | number) => number;
+export declare const CascadeSettings: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    maxDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    splitLambda: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>, "object">;
+export declare const DirectionalLight: import("@aethervtt/shard-core").ComponentDef<{
+    readonly shadows: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly shadowBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowNormalBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowSoftness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly illuminance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly cascades: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        maxDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        splitLambda: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, "object">;
+    readonly angularDiameter: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const PointLight: import("@aethervtt/shard-core").ComponentDef<{
+    readonly shadows: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly shadowBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowNormalBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowSoftness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly range: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const SpotLight: import("@aethervtt/shard-core").ComponentDef<{
+    readonly shadows: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly shadowBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowNormalBias: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly shadowSoftness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly color: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Color, "f32">;
+    readonly intensity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly range: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly innerAngle: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly outerAngle: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export interface AmbientLightValue {
+    /** Linear color. */
+    color: [number, number, number];
+    /** Sky luminance in cd/m². A useful fill is roughly illuminance / 10 of the main light. */
+    brightness: number;
+}
+export declare const AmbientLight: import("@aethervtt/shard-core").ResourceDef<AmbientLightValue>;
+export interface LightingSettingsValue {
+    /** Point and spot lights the light buffer holds. */
+    maxLights: number;
+    /** Where the last cluster slice ends (m). 0: the camera's far plane, or 1 km. */
+    clusterFar: number;
+    cascadeMapSize: number;
+    /** Spot and point shadow map size (per face). */
+    shadowMapSize: number;
+    maxShadowedPoints: number;
+    maxShadowedSpots: number;
+}
+export declare const LightingSettings: import("@aethervtt/shard-core").ResourceDef<LightingSettingsValue>;
+/** Floats per light record in the light buffer. */
+export declare const LIGHT_FLOATS = 20;
+export declare const LIGHT_KIND: {
+    readonly point: 0;
+    readonly spot: 1;
+};
+export declare const MAX_DIRECTIONAL = 4;
+/** A clustered light (point or spot) as the renderer tracks it. */
+export interface LightRecord {
+    entity: Entity;
+    kind: 0 | 1;
+    /** Slot in the light buffer. */
+    slot: number;
+    /** World position and range; spot axis (unit, direction light travels) and cos(outer). */
+    x: number;
+    y: number;
+    z: number;
+    range: number;
+    dx: number;
+    dy: number;
+    dz: number;
+    cosOuter: number;
+    /** Luminous power (lm), for describe and shadow ranking. */
+    intensity: number;
+    shadows: boolean;
+    /** Shadow map index this frame (spot layer, or point cube index), or -1. */
+    shadowIndex: number;
+    outerAngle: number;
+    radius: number;
+    alive: boolean;
+}
+/**
+ * Point and spot lights in a storage buffer (`array<Light>`). Each light owns a slot; only lights
+ * whose data changed this frame are uploaded (coalesced runs), and the counters say how many.
+ */
+export declare class LightStore {
+    readonly records: LightRecord[];
+    readonly byEntity: Map<number, LightRecord>;
+    data: Float32Array;
+    u32: Uint32Array;
+    private dirty;
+    private readonly free;
+    high: number;
+    /** Lights uploaded in the last frame, and bytes. */
+    uploadedLights: number;
+    uploadedBytes: number;
+    readonly buffer: GpuBuffer;
+    /** Directional lights: count + up to 4 × (direction, shadow cascade flag, color × lux, disk radius). */
+    readonly directional: GpuBuffer;
+    readonly directionalData: Float32Array<ArrayBuffer>;
+    readonly directionalU32: Uint32Array<ArrayBuffer>;
+    /** The first directional light with shadows: entity, and its settings. */
+    shadowSun: {
+        entity: Entity;
+        direction: Float32Array;
+        count: number;
+        maxDistance: number;
+        splitLambda: number;
+        bias: number;
+        normalBias: number;
+        softness: number;
+    } | null;
+    directionalCount: number;
+    private generation;
+    private readonly gpu;
+    constructor(gpu: GpuContext, capacity: number);
+    get capacity(): number;
+    /** The live records (dense list; order follows slots). */
+    live(): LightRecord[];
+    record(entity: Entity, kind: 0 | 1): LightRecord | undefined;
+    remove(entity: Entity): void;
+    /** Writes a float into a light's record, marking it dirty only when the value changes. */
+    set(slot: number, index: number, value: number): void;
+    setU32(slot: number, index: number, value: number): void;
+    upload(): void;
+}
+export declare const Lights: import("@aethervtt/shard-core").ResourceDef<LightStore>;
+/** Reads lights into the light store. Only lights whose values changed are re-uploaded later. */
+export declare const extractLights: import("@aethervtt/shard-core").SystemDef<{
+    directional: import("@aethervtt/shard-core").Query;
+    points: import("@aethervtt/shard-core").Query;
+    spots: import("@aethervtt/shard-core").Query;
+    seen: Set<number>;
+}>;
+/** Frees a light's slot when its component goes away (including despawn). */
+export declare function observeLightRemovals(world: World): void;
+/** Sets a light's shadow index (marks it dirty if it changed). */
+export declare function setShadowIndex(store: LightStore, r: LightRecord, index: number): void;

package/dist/lights.js

@@ -0,0 +1,468 @@
+import {
+  defineComponent,
+  defineResource,
+  defineSystem,
+  onRemove,
+  t
+} from "@aethervtt/shard-core";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { GlobalTransform, Transform } from "@aethervtt/shard-transform";
+import { LightPresets } from "./camera.js";
+const LuminousPowerPresets = {
+  candle: 12,
+  "bulb-40w": 450,
+  bulb: 800,
+  floodlight: 2e4
+};
+const lumens = (value) => typeof value === "number" ? value : LuminousPowerPresets[value];
+const shadowFields = (defaults) => ({
+  shadows: t.bool({ description: "Casts shadows (within the shadow budget)." }),
+  shadowBias: t.f32({
+    default: defaults.bias,
+    min: 0,
+    unit: "m",
+    description: "Moves receivers toward the light before the depth test. Fixes acne."
+  }),
+  shadowNormalBias: t.f32({
+    default: defaults.normalBias,
+    min: 0,
+    description: "Moves receivers along their normal, in shadow-map texels. Fixes acne at grazing angles."
+  }),
+  shadowSoftness: t.f32({
+    min: 0,
+    description: "PCF filter radius in texels beyond the base 3x3 (0 = 3x3). Softer edges."
+  })
+});
+const CascadeSettings = t.struct(
+  {
+    count: t.u8({ default: 4, min: 1, max: 4, description: "Number of cascades." }),
+    maxDistance: t.f32({
+      default: 150,
+      min: 0.01,
+      unit: "m",
+      description: "Shadows end this far from the camera."
+    }),
+    splitLambda: t.f32({
+      default: 0.8,
+      min: 0,
+      max: 1,
+      description: "Blend of logarithmic (1) and uniform (0) cascade splits."
+    })
+  },
+  { description: "How cascaded shadow maps divide the view." }
+);
+const DirectionalLight = defineComponent(
+  "render/DirectionalLight",
+  {
+    color: t.color({ default: [1, 1, 1, 1], description: "Light color (linear)." }),
+    illuminance: t.f32({
+      default: LightPresets.daylight,
+      min: 0,
+      unit: "lux",
+      presets: LightPresets,
+      description: "Presets: direct-sun 100000, daylight 10000, overcast 1000, indoor 400, twilight 10, moonlight 0.3."
+    }),
+    ...shadowFields({ bias: 0.02, normalBias: 1.5 }),
+    cascades: CascadeSettings,
+    angularDiameter: t.f32({
+      default: 0.53,
+      min: 0,
+      max: 30,
+      unit: "deg",
+      description: "The sun disk's size in an atmosphere's sky (the Sun 0.53\xB0). 0: no disk. Illuminance is at the top of the atmosphere."
+    })
+  },
+  {
+    description: "Sun-like light shining along its -Z axis. Up to 4 are lit; the first with shadows gets cascaded shadow maps. Inside an Atmosphere its light is dimmed and reddened by the air toward it, and the brightest two draw sun disks.",
+    requires: [Transform]
+  }
+);
+const pointFields = {
+  color: t.color({ default: [1, 1, 1, 1], description: "Light color (linear)." }),
+  intensity: t.f32({
+    default: LuminousPowerPresets.bulb,
+    min: 0,
+    unit: "lm",
+    presets: LuminousPowerPresets,
+    description: "Luminous power. Presets: candle 12, bulb-40w 450, bulb 800, floodlight 20000."
+  }),
+  range: t.f32({
+    default: 20,
+    min: 0.01,
+    unit: "m",
+    description: "Where the light's contribution is windowed to zero (and where culling stops)."
+  }),
+  radius: t.f32({
+    min: 0,
+    unit: "m",
+    description: "Emitter size: softens specular highlights."
+  })
+};
+const PointLight = defineComponent(
+  "render/PointLight",
+  { ...pointFields, ...shadowFields({ bias: 0.02, normalBias: 1 }) },
+  {
+    description: "Light emitted equally in all directions, in lumens (intensity lm / 4\u03C0 candela), with physical inverse-square falloff windowed to zero at range.",
+    requires: [Transform]
+  }
+);
+const SpotLight = defineComponent(
+  "render/SpotLight",
+  {
+    ...pointFields,
+    ...shadowFields({ bias: 0.02, normalBias: 1 }),
+    innerAngle: t.f32({
+      default: 30,
+      min: 0,
+      max: 89,
+      unit: "deg",
+      description: "Full brightness inside this angle from the axis."
+    }),
+    outerAngle: t.f32({
+      default: 45,
+      min: 0.1,
+      max: 89.9,
+      unit: "deg",
+      description: "No light outside this angle from the axis."
+    })
+  },
+  {
+    description: "A cone of light along -Z. Brightness is lm / 4\u03C0 candela regardless of the cone's width.",
+    requires: [Transform]
+  }
+);
+const AmbientLight = defineResource("render/AmbientLight", {
+  description: "Uniform fill light, in cd/m\xB2. Used when no environment map lights the view.",
+  init: () => ({ color: [1, 1, 1], brightness: 0 })
+});
+const LightingSettings = defineResource("render/LightingSettings", {
+  description: "Light and shadow budgets: light buffer size, cluster range, shadow map sizes.",
+  init: () => ({
+    maxLights: 1024,
+    clusterFar: 0,
+    cascadeMapSize: 2048,
+    shadowMapSize: 1024,
+    maxShadowedPoints: 4,
+    maxShadowedSpots: 8
+  })
+});
+const LIGHT_FLOATS = 20;
+const LIGHT_KIND = { point: 0, spot: 1 };
+const MAX_DIRECTIONAL = 4;
+class LightStore {
+  records = [];
+  byEntity = /* @__PURE__ */ new Map();
+  data;
+  u32;
+  dirty;
+  free = [];
+  high = 0;
+  /** Lights uploaded in the last frame, and bytes. */
+  uploadedLights = 0;
+  uploadedBytes = 0;
+  buffer;
+  /** Directional lights: count + up to 4 × (direction, shadow cascade flag, color × lux, disk radius). */
+  directional;
+  directionalData = new Float32Array(4 + MAX_DIRECTIONAL * 8);
+  directionalU32 = new Uint32Array(this.directionalData.buffer);
+  /** The first directional light with shadows: entity, and its settings. */
+  shadowSun = null;
+  directionalCount = 0;
+  generation;
+  gpu;
+  constructor(gpu, capacity) {
+    this.gpu = gpu;
+    this.generation = gpu.generation;
+    this.data = new Float32Array(capacity * LIGHT_FLOATS);
+    this.u32 = new Uint32Array(this.data.buffer);
+    this.dirty = new Uint8Array(capacity);
+    this.buffer = new GpuBuffer(gpu, {
+      label: "lights",
+      usage: GPUBufferUsage.STORAGE,
+      size: capacity * LIGHT_FLOATS * 4
+    });
+    this.directional = new GpuBuffer(gpu, {
+      label: "lights/directional",
+      usage: GPUBufferUsage.STORAGE,
+      size: this.directionalData.byteLength
+    });
+  }
+  get capacity() {
+    return this.dirty.length;
+  }
+  /** The live records (dense list; order follows slots). */
+  live() {
+    return this.records.filter((r) => r.alive);
+  }
+  record(entity, kind) {
+    let r = this.byEntity.get(entity);
+    if (r && r.kind === kind) return r;
+    if (r) this.remove(entity);
+    const slot = this.free.pop() ?? (this.high < this.capacity ? this.high++ : -1);
+    if (slot < 0) return void 0;
+    r = {
+      entity,
+      kind,
+      slot,
+      x: 0,
+      y: 0,
+      z: 0,
+      range: 0,
+      dx: 0,
+      dy: 0,
+      dz: -1,
+      cosOuter: -2,
+      intensity: 0,
+      shadows: false,
+      shadowIndex: -1,
+      outerAngle: 0,
+      radius: 0,
+      alive: true
+    };
+    this.records[slot] = r;
+    this.byEntity.set(entity, r);
+    return r;
+  }
+  remove(entity) {
+    const r = this.byEntity.get(entity);
+    if (!r) return;
+    this.byEntity.delete(entity);
+    r.alive = false;
+    this.data.fill(0, r.slot * LIGHT_FLOATS, (r.slot + 1) * LIGHT_FLOATS);
+    this.dirty[r.slot] = 1;
+    this.free.push(r.slot);
+  }
+  /** Writes a float into a light's record, marking it dirty only when the value changes. */
+  set(slot, index, value) {
+    const o = slot * LIGHT_FLOATS + index;
+    const d = this.data;
+    const before = d[o];
+    d[o] = value;
+    if (d[o] !== before && !(Number.isNaN(before) && Number.isNaN(d[o]))) this.dirty[slot] = 1;
+  }
+  setU32(slot, index, value) {
+    const o = slot * LIGHT_FLOATS + index;
+    if (this.u32[o] !== value >>> 0) {
+      this.u32[o] = value >>> 0;
+      this.dirty[slot] = 1;
+    }
+  }
+  upload() {
+    if (this.generation !== this.gpu.generation) {
+      this.generation = this.gpu.generation;
+      this.dirty.fill(1, 0, this.high);
+    }
+    let lights = 0;
+    let runStart = -1;
+    for (let s = 0; s <= this.high; s++) {
+      const d = s < this.high && this.dirty[s] === 1;
+      if (d) {
+        this.dirty[s] = 0;
+        lights++;
+        if (runStart < 0) runStart = s;
+      } else if (runStart >= 0) {
+        this.buffer.write(
+          this.data,
+          runStart * LIGHT_FLOATS * 4,
+          runStart * LIGHT_FLOATS,
+          (s - runStart) * LIGHT_FLOATS
+        );
+        runStart = -1;
+      }
+    }
+    this.uploadedLights = lights;
+    this.uploadedBytes = lights * LIGHT_FLOATS * 4;
+    this.directional.write(this.directionalData);
+  }
+}
+const Lights = defineResource("render/Lights", {
+  description: "Point and spot lights on the GPU, plus the directional lights."
+});
+const POINT_KIND = LIGHT_KIND.point;
+const SPOT_KIND = LIGHT_KIND.spot;
+const INV_4PI = 1 / (4 * Math.PI);
+function writeLight(store, r, g, o, color, c, intensity, range, radius, bias, normalBias, softness, inner, outer) {
+  const s = r.slot;
+  r.x = g[o + 3];
+  r.y = g[o + 7];
+  r.z = g[o + 11];
+  r.range = range;
+  r.intensity = intensity;
+  r.radius = radius;
+  const dx = -g[o + 2];
+  const dy = -g[o + 6];
+  const dz = -g[o + 10];
+  const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+  r.dx = dx / len;
+  r.dy = dy / len;
+  r.dz = dz / len;
+  const candela = intensity * INV_4PI;
+  store.set(s, 0, r.x);
+  store.set(s, 1, r.y);
+  store.set(s, 2, r.z);
+  store.set(s, 3, range);
+  store.set(s, 4, color[c] * candela);
+  store.set(s, 5, color[c + 1] * candela);
+  store.set(s, 6, color[c + 2] * candela);
+  store.set(s, 7, radius);
+  store.set(s, 8, r.dx);
+  store.set(s, 9, r.dy);
+  store.set(s, 10, r.dz);
+  store.setU32(s, 11, r.kind);
+  if (r.kind === SPOT_KIND) {
+    const cosOuter = Math.cos(outer * Math.PI / 180);
+    const cosInner = Math.cos(Math.min(inner, outer - 0.01) * Math.PI / 180);
+    const scale = 1 / Math.max(cosInner - cosOuter, 1e-4);
+    store.set(s, 12, scale);
+    store.set(s, 13, -cosOuter * scale);
+    r.cosOuter = cosOuter;
+    r.outerAngle = outer;
+  } else {
+    store.set(s, 12, 0);
+    store.set(s, 13, 1);
+    r.cosOuter = -2;
+  }
+  store.setU32(s, 14, r.shadowIndex < 0 ? 4294967295 : r.shadowIndex);
+  store.set(s, 15, bias);
+  store.set(s, 16, normalBias);
+  store.set(s, 17, softness);
+}
+const extractLights = defineSystem({
+  name: "render/extract-lights",
+  description: "Reads directional, point, and spot lights into GPU light buffers.",
+  setup: (world) => ({
+    directional: world.query({ with: [DirectionalLight, GlobalTransform] }),
+    points: world.query({ with: [PointLight, GlobalTransform] }),
+    spots: world.query({ with: [SpotLight, GlobalTransform] }),
+    seen: /* @__PURE__ */ new Set()
+  }),
+  run: ({ directional, points, spots, seen }, world, ctx) => {
+    const store = world.resource(Lights);
+    const since = ctx.lastRunTick;
+    seen.clear();
+    for (const [def, kind, q] of [
+      [PointLight, POINT_KIND, points],
+      [SpotLight, SPOT_KIND, spots]
+    ]) {
+      for (const table of q.tables) {
+        const n = table.count;
+        if (n === 0) continue;
+        const g = table.column(GlobalTransform, "matrix");
+        const gChanged = table.changedTicks(GlobalTransform);
+        const changed = table.changedTicks(def);
+        const color = table.column(def, "color");
+        const intensity = table.column(def, "intensity");
+        const range = table.column(def, "range");
+        const radius = table.column(def, "radius");
+        const shadows = table.column(def, "shadows");
+        const bias = table.column(def, "shadowBias");
+        const normalBias = table.column(def, "shadowNormalBias");
+        const softness = table.column(def, "shadowSoftness");
+        const inner = kind === SPOT_KIND ? table.column(SpotLight, "innerAngle") : void 0;
+        const outer = kind === SPOT_KIND ? table.column(SpotLight, "outerAngle") : void 0;
+        for (let i = 0; i < n; i++) {
+          const entity = table.entities[i];
+          seen.add(entity);
+          const existing = store.byEntity.get(entity);
+          const r = store.record(entity, kind);
+          if (!r) continue;
+          r.shadows = shadows[i] !== 0;
+          if (existing === r && gChanged[i] <= since && changed[i] <= since) continue;
+          writeLight(
+            store,
+            r,
+            g,
+            i * 12,
+            color,
+            i * 4,
+            intensity[i],
+            range[i],
+            radius[i],
+            bias[i],
+            normalBias[i],
+            softness[i],
+            inner ? inner[i] : 0,
+            outer ? outer[i] : 90
+          );
+        }
+      }
+    }
+    if (seen.size !== store.byEntity.size) {
+      for (const entity of [...store.byEntity.keys()]) if (!seen.has(entity)) store.remove(entity);
+    }
+    const d = store.directionalData;
+    const du = store.directionalU32;
+    let count = 0;
+    store.shadowSun = null;
+    for (const table of directional.tables) {
+      const g = table.column(GlobalTransform, "matrix");
+      const color = table.column(DirectionalLight, "color");
+      const lux = table.column(DirectionalLight, "illuminance");
+      const shadows = table.column(DirectionalLight, "shadows");
+      const cascades = table.column(DirectionalLight, "cascades");
+      const angular = table.column(DirectionalLight, "angularDiameter");
+      for (let i = 0; i < table.count && count < MAX_DIRECTIONAL; i++) {
+        const o = 4 + count * 8;
+        const x = g[i * 12 + 2];
+        const y = g[i * 12 + 6];
+        const z = g[i * 12 + 10];
+        const len = Math.sqrt(x * x + y * y + z * z) || 1;
+        d[o] = x / len;
+        d[o + 1] = y / len;
+        d[o + 2] = z / len;
+        const shadowed = shadows[i] !== 0 && store.shadowSun === null;
+        du[o + 3] = shadowed ? 1 : 0;
+        d[o + 4] = color[i * 4] * lux[i];
+        d[o + 5] = color[i * 4 + 1] * lux[i];
+        d[o + 6] = color[i * 4 + 2] * lux[i];
+        d[o + 7] = angular[i] * Math.PI / 360;
+        if (shadowed) {
+          const c = cascades[i];
+          store.shadowSun = {
+            entity: table.entities[i],
+            direction: new Float32Array([x / len, y / len, z / len]),
+            count: c.count,
+            maxDistance: c.maxDistance,
+            splitLambda: c.splitLambda,
+            bias: table.column(DirectionalLight, "shadowBias")[i],
+            normalBias: table.column(DirectionalLight, "shadowNormalBias")[i],
+            softness: table.column(DirectionalLight, "shadowSoftness")[i]
+          };
+        }
+        count++;
+      }
+    }
+    du[0] = count;
+    store.directionalCount = count;
+  }
+});
+function observeLightRemovals(world) {
+  for (const def of [PointLight, SpotLight]) {
+    world.observe(onRemove(def), ({ entity, world: world2 }) => {
+      world2.tryResource(Lights)?.remove(entity);
+    });
+  }
+}
+function setShadowIndex(store, r, index) {
+  if (r.shadowIndex === index) return;
+  r.shadowIndex = index;
+  store.setU32(r.slot, 14, index < 0 ? 4294967295 : index);
+}
+export {
+  AmbientLight,
+  CascadeSettings,
+  DirectionalLight,
+  LIGHT_FLOATS,
+  LIGHT_KIND,
+  LightStore,
+  LightingSettings,
+  Lights,
+  LuminousPowerPresets,
+  MAX_DIRECTIONAL,
+  PointLight,
+  SpotLight,
+  extractLights,
+  lumens,
+  observeLightRemovals,
+  setShadowIndex
+};

package/dist/material-noise.d.ts

@@ -0,0 +1,19 @@
+import { type World } from '@aethervtt/shard-core';
+import type { ShaderLibrary } from '@aethervtt/shard-shader';
+import type { MaterialType } from './materials.js';
+/**
+ * Noise slots in materials (`noise: { detail: 'rock.noise.json' }`), supplied by
+ * `materialNoisePlugin` from `@aethervtt/shard-render/noise`. Core render only asks for it when a
+ * material type has noise slots, so apps without such materials carry no noise code.
+ */
+export interface MaterialNoiseSupport {
+    /**
+     * The WGSL a type's noise slots add to its module, and a key that changes with its graphs.
+     * Undefined while a graph is still loading (this starts the load).
+     */
+    wrappers(world: World, library: ShaderLibrary, type: MaterialType): {
+        source: string;
+        key: string;
+    } | undefined;
+}
+export declare const MaterialNoise: import("@aethervtt/shard-core").ResourceDef<MaterialNoiseSupport>;

package/dist/material-noise.js

@@ -0,0 +1,7 @@
+import { defineResource } from "@aethervtt/shard-core";
+const MaterialNoise = defineResource("render/MaterialNoise", {
+  description: "Noise slots in materials, when materialNoisePlugin is installed."
+});
+export {
+  MaterialNoise
+};