@aethervtt/shard-render 0.0.1

package/dist/instances.js

@@ -0,0 +1,1335 @@
+import {
+  defineComponent,
+  defineResource,
+  defineSystem,
+  onRemove,
+  t
+} from "@aethervtt/shard-core";
+import { GpuBuffer } from "@aethervtt/shard-gpu";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { toHalf } from "@aethervtt/shard-texture";
+import { GlobalTransform, Transform } from "@aethervtt/shard-transform";
+import { MaterialAsset, Materials, Meshes } from "./assets.js";
+import { DEFORM_WORDS, DeformStore } from "./deform.js";
+import { GpuAssetsResource } from "./gpu-assets.js";
+import { isTransparent } from "./materials.js";
+import { ComputedVisibility, Visibility } from "./visibility.js";
+const InstanceSlot = defineComponent(
+  "render/InstanceSlot",
+  {
+    slot: t.u32({
+      readonly: true,
+      description: "GPU instance slot + 1 (0 = none yet). Managed by the renderer."
+    })
+  },
+  {
+    description: "The entity's slot in the renderer's persistent instance buffer. Do not write.",
+    serialize: false
+  }
+);
+const NotShadowCaster = defineComponent(
+  "render/NotShadowCaster",
+  {},
+  { description: "Tag: this mesh casts no shadows." }
+);
+const NotShadowReceiver = defineComponent(
+  "render/NotShadowReceiver",
+  {},
+  { description: "Tag: shadows are not applied to this mesh." }
+);
+const Mesh3d = defineComponent(
+  "render/Mesh3d",
+  { mesh: t.handle("Mesh", { description: "The mesh to draw." }) },
+  {
+    description: "Draws a mesh at this entity's transform.",
+    requires: [Transform, Visibility, InstanceSlot]
+  }
+);
+const MeshMaterial = defineComponent(
+  "render/MeshMaterial",
+  {
+    material: t.handle("Material", {
+      description: "Standard material; a neutral gray when absent."
+    })
+  },
+  { description: "The material a Mesh3d is drawn with." }
+);
+const MAX_LOD_LEVELS = 8;
+const Lod = defineComponent(
+  "render/Lod",
+  {
+    levels: t.list(
+      t.struct({
+        mesh: t.handle("Mesh", { description: "The mesh for this level." }),
+        screenSize: t.f32({
+          min: 0,
+          description: "Projected bounding-sphere diameter, as a fraction of viewport height, above which this level draws."
+        })
+      }),
+      {
+        description: "From most to least detailed, with decreasing screenSize. Smaller than the last level: not drawn."
+      }
+    ),
+    hysteresis: t.f32({
+      default: 0.1,
+      min: 0,
+      max: 0.9,
+      description: "A level changes only once the size crosses a threshold by this fraction."
+    }),
+    bias: t.f32({
+      description: "Scales every size by 2^bias: positive keeps detail longer, negative drops it sooner."
+    })
+  },
+  {
+    description: "Level of detail: the drawn mesh follows the entity's size on screen, chosen per camera (shadows use the camera's choice). Replaces Mesh3d.mesh.",
+    requires: [Mesh3d]
+  }
+);
+const SkinnedMesh = defineComponent(
+  "render/SkinnedMesh",
+  {
+    skin: t.handle("Skin", {
+      description: "The skin: joint paths and inverse bind matrices (imported from glTF)."
+    }),
+    joints: t.list(t.entity, {
+      description: "The joint entities, in the skin's order. Resolved from the skin's joint paths when empty (the model's instance spawns them); set it to drive a mesh with other entities."
+    })
+  },
+  {
+    description: "Deforms the mesh by its joints' transforms (linear blend skinning, 4 influences), in every pass that draws it. Culling bounds follow the pose.",
+    requires: [Mesh3d]
+  }
+);
+const MorphWeights = defineComponent(
+  "render/MorphWeights",
+  {
+    weights: t.list(t.f32, {
+      description: "One weight per morph target of the mesh (0 = none, 1 = the full target). The 8 heaviest are applied. Animation clips' weights channels write it."
+    })
+  },
+  {
+    description: "Blends the mesh's morph targets (blend shapes) by weight.",
+    requires: [Mesh3d]
+  }
+);
+const VisibilityRange = defineComponent(
+  "render/VisibilityRange",
+  {
+    start: t.f32({ min: 0, unit: "m", description: "Hidden when the camera is closer than this." }),
+    end: t.f32({
+      default: 100,
+      min: 0,
+      unit: "m",
+      description: "Hidden at this distance from the camera and beyond (shadows too)."
+    })
+  },
+  {
+    description: "Distance culling from the camera, for small props. Applies to the camera's shadow views too.",
+    requires: [Mesh3d]
+  }
+);
+const InstanceData = defineComponent(
+  "render/InstanceData",
+  {
+    x: t.f32({ description: "First value (stored as a half float)." }),
+    y: t.f32({
+      description: "Second value (stored as a half float; integers up to 2048 are exact)."
+    })
+  },
+  {
+    description: "Two numbers this instance's material reads in its vertex stage (vertex_instance_data() in shard::mesh), e.g. a fade or per-edge flags. They share the slot word VisibilityRange uses, so an entity has one or the other.",
+    requires: [Mesh3d]
+  }
+);
+const INSTANCE_FLOATS = 16;
+const INSTANCE_BYTES = INSTANCE_FLOATS * 4;
+const PREV_BYTES = 48;
+const InstanceFlags = {
+  Visible: 1,
+  Caster: 2,
+  Receiver: 4,
+  Range: 8,
+  Lod: 16,
+  /** Skinned: the vertex stage reads joint matrices; culling reads the slot's own sphere. */
+  Skinned: 32,
+  /** Morphed: the vertex stage adds morph target deltas. */
+  Morph: 64
+};
+const NO_BATCH = 4294967295;
+const LOD_BIT = 2147483648;
+const SLOT_MASK = 268435455;
+const LOD_UNSET = 255;
+function createDrawList() {
+  return { items: [], length: 0, visible: 0, culled: 0, hidden: 0, pending: 0, cullView: -1 };
+}
+const halfToFloat = (h) => {
+  const s = h & 32768 ? -1 : 1;
+  const e = h >> 10 & 31;
+  const f = h & 1023;
+  if (e === 0) return s * 2 ** -14 * (f / 1024);
+  if (e === 31) return f ? Number.NaN : s * Number.POSITIVE_INFINITY;
+  return s * 2 ** (e - 15) * (1 + f / 1024);
+};
+const f32 = Math.fround;
+const scratchSphere = new Float32Array(4);
+const halfScratch = new Float32Array(2);
+function slotSphere(out, f, o, bounds) {
+  const cx = f32((bounds[0] + bounds[3]) * 0.5);
+  const cy = f32((bounds[1] + bounds[4]) * 0.5);
+  const cz = f32((bounds[2] + bounds[5]) * 0.5);
+  const ex = f32((bounds[3] - bounds[0]) * 0.5);
+  const ey = f32((bounds[4] - bounds[1]) * 0.5);
+  const ez = f32((bounds[5] - bounds[2]) * 0.5);
+  const r = f32(Math.sqrt(ex * ex + ey * ey + ez * ez));
+  out[0] = f32(f[o] * cx + f[o + 1] * cy + f[o + 2] * cz + f[o + 3]);
+  out[1] = f32(f[o + 4] * cx + f[o + 5] * cy + f[o + 6] * cz + f[o + 7]);
+  out[2] = f32(f[o + 8] * cx + f[o + 9] * cy + f[o + 10] * cz + f[o + 11]);
+  const sx = f[o] * f[o] + f[o + 4] * f[o + 4] + f[o + 8] * f[o + 8];
+  const sy = f[o + 1] * f[o + 1] + f[o + 5] * f[o + 5] + f[o + 9] * f[o + 9];
+  const sz = f[o + 2] * f[o + 2] + f[o + 6] * f[o + 6] + f[o + 10] * f[o + 10];
+  out[3] = f32(r * Math.sqrt(Math.max(sx, sy, sz)));
+  return out;
+}
+function sphereOfSlot(out, store, slot, flags, bounds) {
+  if (flags & InstanceFlags.Skinned) {
+    const r = store.deform.recordF32;
+    const o = slot * DEFORM_WORDS;
+    if (r[o + 3] > 0) {
+      out[0] = r[o];
+      out[1] = r[o + 1];
+      out[2] = r[o + 2];
+      out[3] = r[o + 3];
+      return out;
+    }
+  }
+  return slotSphere(out, store.f32, slot * INSTANCE_FLOATS, bounds);
+}
+function sphereInFrustum(planes, s) {
+  for (let p = 0; p < 24; p += 4) {
+    if (planes[p] * s[0] + planes[p + 1] * s[1] + planes[p + 2] * s[2] + planes[p + 3] < -s[3])
+      return false;
+  }
+  return true;
+}
+function selectLod(size, thresholds, count, hysteresis, previous) {
+  let level = previous;
+  if (previous === LOD_UNSET || previous > count) {
+    level = count;
+    for (let k = 0; k < count; k++) {
+      if (size >= thresholds[k]) {
+        level = k;
+        break;
+      }
+    }
+    return level;
+  }
+  while (level > 0 && size > thresholds[level - 1] * (1 + hysteresis)) level--;
+  while (level < count && size < thresholds[level] * (1 - hysteresis)) level++;
+  return level;
+}
+class InstanceStore {
+  capacity = 0;
+  /** Slots in use or freed; slots >= high were never used. */
+  high = 0;
+  f32 = new Float32Array(0);
+  u32 = new Uint32Array(0);
+  /**
+   * Each slot's InstanceFlags, mirrored from its record: prepare compares against these every
+   * frame, and reading them from the 64-byte records would touch a cache line per instance.
+   */
+  flags = new Uint8Array(0);
+  /** Hidden instances per ECS table id, from the last time prepare visited the table. */
+  tableHidden = [];
+  /** Batch index (>= 0), LOD set (-2 - index), or -1 (none), per slot. */
+  batchOf = new Int32Array(0);
+  /** Index of the slot in its batch's member list, or -1. */
+  memberIndex = new Int32Array(0);
+  /** Visibility range per slot, as the GPU sees it (f16-rounded start, end). */
+  ranges = new Float32Array(0);
+  meshRefs = [];
+  materialRefs = [];
+  /** Lod component value per slot, or null. */
+  lods = [];
+  dirty = new Uint8Array(0);
+  dirtyLo = Number.POSITIVE_INFINITY;
+  dirtyHi = -1;
+  /**
+   * Last frame's transform per slot (12 floats), for motion vectors. A slot that moved last frame
+   * but not this one catches up, so a stopped object has no velocity.
+   */
+  prev = new Float32Array(0);
+  prevDirty = new Uint8Array(0);
+  prevLo = Number.POSITIVE_INFINITY;
+  prevHi = -1;
+  movedFrame = new Uint32Array(0);
+  moved = new Uint32Array(64);
+  movedCount = 0;
+  lastMoved = new Uint32Array(64);
+  lastMovedCount = 0;
+  frame = 1;
+  prevBuffer;
+  free = [];
+  /** Slots waiting for their mesh or material to load. */
+  pending = /* @__PURE__ */ new Set();
+  batches = [];
+  /** Batches in draw order (sorted by pipeline, then material, then mesh). */
+  sorted = [];
+  byMesh = /* @__PURE__ */ new Map();
+  lodSets = [];
+  lodByKey = /* @__PURE__ */ new Map();
+  defaultMaterial = new MaterialAsset();
+  /** Bytes of instance data uploaded this frame. */
+  uploadedBytes = 0;
+  /** Slots with a batch and not hidden, and hidden ones: stats for GPU-culled views. */
+  drawableCount = 0;
+  hiddenCount = 0;
+  /** Bumps when batches or LOD sets change shape (the GPU tables re-upload). */
+  structureVersion = 0;
+  /** Visible slot lists of every CPU-culled view this frame, concatenated. */
+  visible = new Uint32Array(1024);
+  visibleCount = 0;
+  instanceBuffer;
+  visibleBuffer;
+  generation;
+  gpu;
+  bindGroup;
+  bound = "";
+  layout;
+  /** Set by the GPU culler: views it culls read their visible lists from this buffer. */
+  gpuVisible;
+  /** Bind group over `gpuVisible`, for draws of GPU-culled views. */
+  gpuBindGroup;
+  gpuBound = "";
+  /** Joint matrices, morph weights, and deform records of skinned and morphed slots. */
+  deform;
+  constructor(gpu) {
+    this.gpu = gpu;
+    this.generation = gpu.generation;
+    this.instanceBuffer = new GpuBuffer(gpu, {
+      label: "instances",
+      usage: GPUBufferUsage.STORAGE,
+      size: INSTANCE_BYTES * 256
+    });
+    this.prevBuffer = new GpuBuffer(gpu, {
+      label: "instances/previous",
+      usage: GPUBufferUsage.STORAGE,
+      size: PREV_BYTES * 256
+    });
+    this.visibleBuffer = new GpuBuffer(gpu, {
+      label: "instances/visible",
+      usage: GPUBufferUsage.STORAGE,
+      size: 4 * 1024
+    });
+    this.layout = createInstanceLayout(gpu);
+    this.deform = new DeformStore(gpu);
+    this.grow(256);
+  }
+  get live() {
+    return this.high - this.free.length;
+  }
+  grow(capacity) {
+    const f32a = new Float32Array(capacity * INSTANCE_FLOATS);
+    f32a.set(this.f32);
+    this.f32 = f32a;
+    this.u32 = new Uint32Array(f32a.buffer);
+    const batchOf = new Int32Array(capacity).fill(-1);
+    batchOf.set(this.batchOf);
+    this.batchOf = batchOf;
+    const memberIndex = new Int32Array(capacity).fill(-1);
+    memberIndex.set(this.memberIndex);
+    this.memberIndex = memberIndex;
+    const ranges = new Float32Array(capacity * 2);
+    ranges.set(this.ranges);
+    this.ranges = ranges;
+    const dirty = new Uint8Array(capacity);
+    dirty.set(this.dirty);
+    this.dirty = dirty;
+    const flags = new Uint8Array(capacity);
+    flags.set(this.flags);
+    this.flags = flags;
+    const prev = new Float32Array(capacity * 12);
+    prev.set(this.prev);
+    this.prev = prev;
+    const prevDirty = new Uint8Array(capacity);
+    prevDirty.set(this.prevDirty);
+    this.prevDirty = prevDirty;
+    const movedFrame = new Uint32Array(capacity);
+    movedFrame.set(this.movedFrame);
+    this.movedFrame = movedFrame;
+    this.capacity = capacity;
+    this.deform.ensureSlots(capacity);
+  }
+  alloc(entity) {
+    let slot = this.free.pop();
+    if (slot === void 0) {
+      if (this.high >= this.capacity) this.grow(this.capacity * 2);
+      slot = this.high++;
+    }
+    this.u32[slot * INSTANCE_FLOATS + 12] = NO_BATCH;
+    this.u32[slot * INSTANCE_FLOATS + 13] = 0;
+    this.flags[slot] = 0;
+    this.u32[slot * INSTANCE_FLOATS + 14] = 0;
+    this.u32[slot * INSTANCE_FLOATS + 15] = entity % 4294967296;
+    this.batchOf[slot] = -1;
+    this.memberIndex[slot] = -1;
+    this.lods[slot] = null;
+    this.markDirty(slot);
+    return slot;
+  }
+  release(slot) {
+    this.assign(slot, -1);
+    this.u32[slot * INSTANCE_FLOATS + 13] = 0;
+    this.flags[slot] = 0;
+    this.meshRefs[slot] = null;
+    this.materialRefs[slot] = null;
+    this.lods[slot] = null;
+    this.pending.delete(slot);
+    this.deform.clear(slot);
+    this.markDirty(slot);
+    this.free.push(slot);
+  }
+  boundsDirty = true;
+  cachedBounds = new Float32Array(6);
+  /**
+   * The world bounds of every shadow caster (spheres), cached until an instance changes. GPU
+   * culling fits cascade depth ranges to it, having no CPU cull to take a union from.
+   */
+  casterBounds(out) {
+    if (this.boundsDirty) {
+      this.boundsDirty = false;
+      const b = this.cachedBounds;
+      b[0] = b[1] = b[2] = Number.POSITIVE_INFINITY;
+      b[3] = b[4] = b[5] = Number.NEGATIVE_INFINITY;
+      const sphere = scratchSphere;
+      const need = InstanceFlags.Visible | InstanceFlags.Caster;
+      for (let s = 0; s < this.high; s++) {
+        const a = this.batchOf[s];
+        if (a === -1 || (this.u32[s * INSTANCE_FLOATS + 13] & need) !== need) continue;
+        const batch = this.batches[a >= 0 ? a : this.lodSets[-2 - a].batches[0]];
+        if (batch.transparent) continue;
+        sphereOfSlot(sphere, this, s, this.u32[s * INSTANCE_FLOATS + 13], batch.mesh.bounds);
+        for (let k = 0; k < 3; k++) {
+          if (sphere[k] - sphere[3] < b[k]) b[k] = sphere[k] - sphere[3];
+          if (sphere[k] + sphere[3] > b[k + 3]) b[k + 3] = sphere[k] + sphere[3];
+        }
+      }
+    }
+    out.set(this.cachedBounds);
+    return out;
+  }
+  markDirty(slot) {
+    this.boundsDirty = true;
+    if (this.dirty[slot]) return;
+    this.dirty[slot] = 1;
+    if (slot < this.dirtyLo) this.dirtyLo = slot;
+    if (slot > this.dirtyHi) this.dirtyHi = slot;
+  }
+  /**
+   * Records a transform change: `from` is where the slot's record is now (copied to its previous
+   * transform), unless the slot is new, when both get `to`.
+   */
+  moveSlot(slot, g, offset, fresh) {
+    const f = this.f32;
+    const p = this.prev;
+    const o = slot * INSTANCE_FLOATS;
+    const q = slot * 12;
+    for (let k = 0; k < 12; k++) {
+      p[q + k] = fresh ? g[offset + k] : f[o + k];
+      f[o + k] = g[offset + k];
+    }
+    this.markDirty(slot);
+    this.markPrevDirty(slot);
+    if (this.movedFrame[slot] !== this.frame) {
+      this.movedFrame[slot] = this.frame;
+      if (this.movedCount >= this.moved.length) {
+        const grown = new Uint32Array(this.moved.length * 2);
+        grown.set(this.moved);
+        this.moved = grown;
+      }
+      this.moved[this.movedCount++] = slot;
+    }
+  }
+  /**
+   * The floating origin moved (spec 0040): adds `x, y, z` to every slot's current and previous
+   * translation, so this frame's moves compare against last frame's pose in the new frame and
+   * motion vectors stay continuous. Runs once per shift, not per frame.
+   */
+  shiftOrigin(x, y, z) {
+    const f = this.f32;
+    const p = this.prev;
+    for (let s = 0; s < this.high; s++) {
+      const o = s * INSTANCE_FLOATS;
+      const q = s * 12;
+      f[o + 3] = f[o + 3] + x;
+      f[o + 7] = f[o + 7] + y;
+      f[o + 11] = f[o + 11] + z;
+      p[q + 3] = p[q + 3] + x;
+      p[q + 7] = p[q + 7] + y;
+      p[q + 11] = p[q + 11] + z;
+    }
+    if (this.high === 0) return;
+    this.boundsDirty = true;
+    this.dirty.fill(1, 0, this.high);
+    this.prevDirty.fill(1, 0, this.high);
+    this.dirtyLo = Math.min(this.dirtyLo, 0);
+    this.dirtyHi = Math.max(this.dirtyHi, this.high - 1);
+    this.prevLo = 0;
+    this.prevHi = Math.max(this.prevHi, this.high - 1);
+  }
+  markPrevDirty(slot) {
+    if (this.prevDirty[slot]) return;
+    this.prevDirty[slot] = 1;
+    if (slot < this.prevLo) this.prevLo = slot;
+    if (slot > this.prevHi) this.prevHi = slot;
+  }
+  /** Slots that moved last frame but not this one: their previous transform catches up. */
+  settleMoved() {
+    const f = this.f32;
+    const p = this.prev;
+    for (let i = 0; i < this.lastMovedCount; i++) {
+      const slot = this.lastMoved[i];
+      if (this.movedFrame[slot] === this.frame || slot >= this.high) continue;
+      const o = slot * INSTANCE_FLOATS;
+      const q = slot * 12;
+      for (let k = 0; k < 12; k++) p[q + k] = f[o + k];
+      this.markPrevDirty(slot);
+    }
+    const t2 = this.lastMoved;
+    this.lastMoved = this.moved;
+    this.lastMovedCount = this.movedCount;
+    this.moved = t2;
+    this.movedCount = 0;
+    this.frame++;
+  }
+  /** Assigns a slot to a batch (>= 0), a LOD set (-2 - index), or nothing (-1). */
+  assign(slot, assignment) {
+    const old = this.batchOf[slot];
+    if (old === assignment) return;
+    if (old >= 0) {
+      this.batches[old].count--;
+      this.removeMember(slot, this.batches[old]);
+    } else if (old <= -2) {
+      const set = this.lodSets[-2 - old];
+      set.count--;
+      for (const b of set.batches) this.batches[b].count--;
+    }
+    if (assignment >= 0) {
+      this.batches[assignment].count++;
+      this.addMember(slot, this.batches[assignment]);
+    } else if (assignment <= -2) {
+      const set = this.lodSets[-2 - assignment];
+      set.count++;
+      for (const b of set.batches) this.batches[b].count++;
+    }
+    this.batchOf[slot] = assignment;
+    this.u32[slot * INSTANCE_FLOATS + 12] = assignment >= 0 ? assignment : assignment <= -2 ? (LOD_BIT | -2 - assignment) >>> 0 : NO_BATCH;
+    this.markDirty(slot);
+  }
+  /** A plain batch assignment. */
+  setBatch(slot, index) {
+    this.assign(slot, index);
+  }
+  addMember(slot, batch) {
+    if (batch.memberCount >= batch.members.length) {
+      const grown = new Uint32Array(batch.members.length * 2);
+      grown.set(batch.members);
+      batch.members = grown;
+    }
+    this.memberIndex[slot] = batch.memberCount;
+    batch.members[batch.memberCount++] = slot;
+  }
+  removeMember(slot, batch) {
+    const i = this.memberIndex[slot];
+    if (i < 0) return;
+    const last = batch.members[--batch.memberCount];
+    batch.members[i] = last;
+    this.memberIndex[last] = i;
+    this.memberIndex[slot] = -1;
+  }
+  batchFor(mesh, material, meshGuid, materialGuid) {
+    let byMaterial = this.byMesh.get(mesh);
+    if (!byMaterial) {
+      byMaterial = /* @__PURE__ */ new Map();
+      this.byMesh.set(mesh, byMaterial);
+    }
+    let batch = byMaterial.get(material);
+    if (!batch) {
+      batch = {
+        index: this.batches.length,
+        mesh,
+        material,
+        meshGuid,
+        materialGuid,
+        count: 0,
+        ready: false,
+        transparent: false,
+        deferrable: true,
+        members: new Uint32Array(16),
+        memberCount: 0,
+        region: 0,
+        scratch: new Uint32Array(64),
+        scratchCount: 0,
+        forwardScratch: new Uint32Array(16),
+        forwardCount: 0
+      };
+      byMaterial.set(material, batch);
+      this.batches.push(batch);
+      if (!this.materialOrder.has(material))
+        this.materialOrder.set(material, this.materialOrder.size);
+      if (!this.meshOrder.has(mesh)) this.meshOrder.set(mesh, this.meshOrder.size);
+      let lo = 0;
+      let hi = this.sorted.length;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if (this.compareBatches(this.sorted[mid], batch, this.batchKey) <= 0) lo = mid + 1;
+        else hi = mid;
+      }
+      this.sorted.splice(lo, 0, batch);
+      this.structureVersion++;
+    }
+    return batch;
+  }
+  /** The LOD set for a Lod value and material (created on first use). Undefined if a mesh is missing. */
+  lodSetFor(lod, material, materialGuid, meshes) {
+    const levels = lod.levels.slice(0, MAX_LOD_LEVELS);
+    const resolved = [];
+    for (const level of levels) {
+      const mesh = meshes.get(level.mesh);
+      if (!mesh) return void 0;
+      resolved.push(mesh);
+    }
+    const key = `${levels.map((l, i) => `${idOf(resolved[i])}@${l.screenSize}`).join(",")}|${lod.hysteresis}|${lod.bias}|${idOf(material)}`;
+    let set = this.lodByKey.get(key);
+    if (!set) {
+      set = {
+        index: this.lodSets.length,
+        key,
+        batches: resolved.map(
+          (mesh, i) => this.batchFor(mesh, material, levels[i].mesh?.guid, materialGuid).index
+        ),
+        thresholds: Float32Array.from(levels.map((l) => l.screenSize)),
+        hysteresis: lod.hysteresis,
+        bias: lod.bias,
+        count: 0
+      };
+      this.lodSets.push(set);
+      this.lodByKey.set(key, set);
+      this.structureVersion++;
+    }
+    return set;
+  }
+  /** Orders batches by pipeline (set by the renderer: material type and variant). */
+  batchKey = () => 0;
+  /** Draw order: grouped by pipeline, then material, then mesh, so switches stay rare. */
+  sortBatches(key = this.batchKey) {
+    this.sorted.sort((a, b) => this.compareBatches(a, b, key));
+  }
+  /** Materials and meshes in the order their first batch appeared (draw order within a pipeline). */
+  materialOrder = /* @__PURE__ */ new Map();
+  meshOrder = /* @__PURE__ */ new Map();
+  compareBatches(a, b, key) {
+    return key(a) - key(b) || this.materialOrder.get(a.material) - this.materialOrder.get(b.material) || this.meshOrder.get(a.mesh) - this.meshOrder.get(b.mesh);
+  }
+  /** Writes a slot's visibility range (packed as two halves, as the GPU reads it). */
+  setRange(slot, start, end) {
+    halfScratch[0] = start;
+    halfScratch[1] = end;
+    const h = toHalf(halfScratch);
+    const packed = (h[0] | h[1] << 16) >>> 0;
+    const o = slot * INSTANCE_FLOATS + 14;
+    if (this.u32[o] !== packed) {
+      this.u32[o] = packed;
+      this.markDirty(slot);
+    }
+    this.ranges[slot * 2] = halfToFloat(h[0]);
+    this.ranges[slot * 2 + 1] = halfToFloat(h[1]);
+  }
+  /** Uploads dirty slots in coalesced runs. Returns bytes written. */
+  upload() {
+    if (this.generation !== this.gpu.generation) {
+      this.generation = this.gpu.generation;
+      this.layout = createInstanceLayout(this.gpu);
+      this.bindGroup = void 0;
+      this.gpuBindGroup = void 0;
+      this.dirtyLo = 0;
+      this.dirtyHi = this.high - 1;
+      this.dirty.fill(1, 0, this.high);
+      this.prevLo = 0;
+      this.prevHi = this.high - 1;
+      this.prevDirty.fill(1, 0, this.high);
+    }
+    if (this.instanceBuffer.ensureCapacity(this.capacity * INSTANCE_BYTES) && this.high > 0) {
+      this.dirtyLo = 0;
+      this.dirtyHi = this.high - 1;
+      this.dirty.fill(1, 0, this.high);
+    }
+    if (this.prevBuffer.ensureCapacity(this.capacity * PREV_BYTES) && this.high > 0) {
+      this.prevLo = 0;
+      this.prevHi = this.high - 1;
+      this.prevDirty.fill(1, 0, this.high);
+    }
+    let start = -1;
+    for (let s = this.prevLo; s <= this.prevHi + 1; s++) {
+      if (s <= this.prevHi && this.prevDirty[s] === 1) {
+        this.prevDirty[s] = 0;
+        if (start < 0) start = s;
+      } else if (start >= 0) {
+        this.prevBuffer.write(this.prev, start * PREV_BYTES, start * 12, (s - start) * 12);
+        start = -1;
+      }
+    }
+    this.prevLo = Number.POSITIVE_INFINITY;
+    this.prevHi = -1;
+    let bytes = 0;
+    const lo = this.dirtyLo;
+    const hi = this.dirtyHi;
+    let runStart = -1;
+    for (let s = lo; s <= hi + 1; s++) {
+      const d = s <= hi && this.dirty[s] === 1;
+      if (d) {
+        this.dirty[s] = 0;
+        if (runStart < 0) runStart = s;
+      } else if (runStart >= 0) {
+        const n = s - runStart;
+        this.instanceBuffer.write(
+          this.f32,
+          runStart * INSTANCE_BYTES,
+          runStart * INSTANCE_FLOATS,
+          n * INSTANCE_FLOATS
+        );
+        bytes += n * INSTANCE_BYTES;
+        runStart = -1;
+      }
+    }
+    this.dirtyLo = Number.POSITIVE_INFINITY;
+    this.dirtyHi = -1;
+    this.uploadedBytes = bytes;
+    return bytes;
+  }
+  beginFrame() {
+    this.visibleCount = 0;
+  }
+  // Transparent instances this cull: slot, batch, and view depth, sorted back to front.
+  transparentCount = 0;
+  forwardOnlyCount = 0;
+  tSlots = new Uint32Array(64);
+  tBatches = new Int32Array(64);
+  tDepths = new Float32Array(64);
+  tOrder = [];
+  /**
+   * CPU culling of every slot into `list` (and, for camera views, `transparent` back to front and
+   * deferred `forwardOnly`). Same tests as the GPU culler: bounding sphere against the frustum,
+   * visibility range, LOD level. `bounds` gets the union of what passed (cascade fitting). With
+   * `transparentOnly`, only blended batches are culled (the GPU culls the rest).
+   */
+  cullCpu(list, params, bounds, transparent, forward, forwardOnly, transparentOnly = false) {
+    if (bounds) {
+      bounds[0] = bounds[1] = bounds[2] = Number.POSITIVE_INFINITY;
+      bounds[3] = bounds[4] = bounds[5] = Number.NEGATIVE_INFINITY;
+    }
+    list.length = 0;
+    list.visible = 0;
+    list.culled = 0;
+    list.hidden = 0;
+    list.pending = this.pending.size;
+    list.cullView = -1;
+    this.transparentCount = 0;
+    this.forwardOnlyCount = 0;
+    const batches = this.batches;
+    for (let b = 0; b < batches.length; b++) {
+      batches[b].scratchCount = 0;
+      batches[b].forwardCount = 0;
+    }
+    const f = this.f32;
+    const u32 = this.u32;
+    const mask = InstanceFlags.Visible | params.require;
+    const eye = params.eye;
+    const sphere = scratchSphere;
+    for (let s = 0; s < this.high; s++) {
+      const assignment = this.batchOf[s];
+      if (assignment === -1) continue;
+      const flags = u32[s * INSTANCE_FLOATS + 13];
+      if ((flags & mask) !== mask) {
+        if ((flags & InstanceFlags.Visible) === 0) list.hidden++;
+        continue;
+      }
+      let set;
+      let b = assignment;
+      if (assignment <= -2) {
+        set = this.lodSets[-2 - assignment];
+        b = set.batches[0];
+      }
+      let batch = batches[b];
+      if (transparentOnly && !batch.transparent) continue;
+      if (!batch.ready) {
+        list.pending++;
+        continue;
+      }
+      if (batch.transparent && (params.require !== 0 || !transparent)) continue;
+      if (flags & InstanceFlags.Skinned) sphereOfSlot(sphere, this, s, flags, batch.mesh.bounds);
+      else slotSphere(sphere, f, s * INSTANCE_FLOATS, batch.mesh.bounds);
+      if (params.planes && !sphereInFrustum(params.planes, sphere)) {
+        list.culled++;
+        continue;
+      }
+      let distance = 0;
+      if (eye) {
+        const dx = sphere[0] - eye[0];
+        const dy = sphere[1] - eye[1];
+        const dz = sphere[2] - eye[2];
+        distance = f32(Math.sqrt(dx * dx + dy * dy + dz * dz));
+      }
+      if (flags & InstanceFlags.Range && eye) {
+        if (distance < this.ranges[s * 2] || distance >= this.ranges[s * 2 + 1]) {
+          list.culled++;
+          continue;
+        }
+      }
+      let level = 0;
+      if (set) {
+        const state = params.lodState;
+        const previous = state ? state[s] : LOD_UNSET;
+        if (params.updateLod || !state) {
+          const size = lodSize(sphere[3], distance, params) * 2 ** set.bias;
+          level = selectLod(size, set.thresholds, set.batches.length, set.hysteresis, previous);
+          if (state) state[s] = level;
+        } else {
+          level = previous;
+        }
+        if (level >= set.batches.length) {
+          list.culled++;
+          continue;
+        }
+        b = set.batches[level];
+        batch = batches[b];
+        if (!batch.ready) {
+          list.pending++;
+          continue;
+        }
+      }
+      const entry = (s | level << 28) >>> 0;
+      if (bounds) {
+        for (let k = 0; k < 3; k++) {
+          if (sphere[k] - sphere[3] < bounds[k]) bounds[k] = sphere[k] - sphere[3];
+          if (sphere[k] + sphere[3] > bounds[k + 3]) bounds[k + 3] = sphere[k] + sphere[3];
+        }
+      }
+      if (batch.transparent) {
+        this.pushTransparent(entry, b, eye, forward);
+        list.visible++;
+        continue;
+      }
+      if (forwardOnly && !batch.deferrable) {
+        if (batch.forwardCount >= batch.forwardScratch.length) {
+          const grown = new Uint32Array(batch.forwardScratch.length * 2);
+          grown.set(batch.forwardScratch);
+          batch.forwardScratch = grown;
+        }
+        batch.forwardScratch[batch.forwardCount++] = entry;
+        this.forwardOnlyCount++;
+        continue;
+      }
+      if (batch.scratchCount >= batch.scratch.length) {
+        const grown = new Uint32Array(batch.scratch.length * 2);
+        grown.set(batch.scratch);
+        batch.scratch = grown;
+      }
+      batch.scratch[batch.scratchCount++] = entry;
+      list.visible++;
+    }
+    this.pack(list);
+    if (transparent) this.packTransparent(transparent);
+    if (forwardOnly) {
+      for (const batch of this.batches) {
+        const n = batch.forwardCount;
+        batch.forwardCount = 0;
+        batch.scratchCount = n;
+        if (n > 0) {
+          if (batch.scratch.length < n) batch.scratch = new Uint32Array(batch.forwardScratch.length);
+          batch.scratch.set(batch.forwardScratch.subarray(0, n));
+        }
+      }
+      this.pack(forwardOnly);
+      forwardOnly.visible = this.forwardOnlyCount;
+    }
+  }
+  /** Transparent-only CPU cull over blended batches' members (LOD slots aren't members). */
+  cullTransparentMembers(list, params, forward) {
+    this.transparentCount = 0;
+    const u32 = this.u32;
+    const eye = params.eye;
+    const sphere = scratchSphere;
+    for (const batch of this.batches) {
+      if (!batch.transparent || !batch.ready || batch.memberCount === 0) continue;
+      for (let m = 0; m < batch.memberCount; m++) {
+        const s = batch.members[m];
+        const flags = u32[s * INSTANCE_FLOATS + 13];
+        if ((flags & InstanceFlags.Visible) === 0) continue;
+        sphereOfSlot(sphere, this, s, flags, batch.mesh.bounds);
+        if (params.planes && !sphereInFrustum(params.planes, sphere)) continue;
+        if (flags & InstanceFlags.Range && eye) {
+          const dx = sphere[0] - eye[0];
+          const dy = sphere[1] - eye[1];
+          const dz = sphere[2] - eye[2];
+          const distance = f32(Math.sqrt(dx * dx + dy * dy + dz * dz));
+          if (distance < this.ranges[s * 2] || distance >= this.ranges[s * 2 + 1]) continue;
+        }
+        this.pushTransparent(s, batch.index, eye, forward);
+      }
+    }
+    this.packTransparent(list);
+  }
+  /**
+   * CPU culling with positional arguments: planes, flag mask, bounds, transparent list, eye, view
+   * direction, and the deferred forward-only list. LOD selects fresh (no hysteresis state).
+   */
+  cull(list, planes, require2 = 0, bounds, transparent, eye, forward, forwardOnly) {
+    legacy.planes = planes;
+    legacy.require = require2;
+    legacy.eye = eye;
+    this.cullCpu(list, legacy, bounds, transparent, forward, forwardOnly);
+  }
+  pushTransparent(entry, batch, eye, forward) {
+    const n = this.transparentCount;
+    if (n >= this.tSlots.length) {
+      const size = this.tSlots.length * 2;
+      const s = new Uint32Array(size);
+      s.set(this.tSlots);
+      this.tSlots = s;
+      const b = new Int32Array(size);
+      b.set(this.tBatches);
+      this.tBatches = b;
+      const d = new Float32Array(size);
+      d.set(this.tDepths);
+      this.tDepths = d;
+    }
+    const o = (entry & SLOT_MASK) * INSTANCE_FLOATS;
+    let depth = 0;
+    if (eye && forward) {
+      depth = (this.f32[o + 3] - eye[0]) * forward[0] + (this.f32[o + 7] - eye[1]) * forward[1] + (this.f32[o + 11] - eye[2]) * forward[2];
+    }
+    this.tSlots[n] = entry;
+    this.tBatches[n] = batch;
+    this.tDepths[n] = depth;
+    this.transparentCount = n + 1;
+  }
+  /** Sorts this cull's transparent instances back to front; runs of one batch share a draw. */
+  packTransparent(list) {
+    list.length = 0;
+    list.cullView = -1;
+    const n = this.transparentCount;
+    if (n === 0) {
+      list.visible = 0;
+      return;
+    }
+    const order = this.tOrder;
+    order.length = n;
+    for (let i = 0; i < n; i++) order[i] = i;
+    const depths = this.tDepths;
+    order.sort((a, b) => depths[b] - depths[a] || a - b);
+    this.reserve(n);
+    let item;
+    for (let k = 0; k < n; k++) {
+      const i = order[k];
+      const batch = this.batches[this.tBatches[i]];
+      if (!item || item.batch !== batch) {
+        item = this.item(list, batch);
+        item.first = this.visibleCount;
+        item.count = 0;
+      }
+      this.visible[this.visibleCount++] = this.tSlots[i];
+      item.count++;
+    }
+    list.visible = n;
+  }
+  reserve(n) {
+    if (this.visibleCount + n <= this.visible.length) return;
+    let size = this.visible.length * 2;
+    while (size < this.visibleCount + n) size *= 2;
+    const grown = new Uint32Array(size);
+    grown.set(this.visible.subarray(0, this.visibleCount));
+    this.visible = grown;
+  }
+  item(list, batch) {
+    let item = list.items[list.length];
+    if (!item) {
+      item = { batch, first: 0, count: 0, indirect: -1 };
+      list.items.push(item);
+    }
+    item.batch = batch;
+    item.indirect = -1;
+    list.length++;
+    return item;
+  }
+  /**
+   * False only when every instance of a small batch is hidden (Visibility), so views skip its
+   * draw. The GPU culler otherwise issues one indirect draw per batch, empty or not: a planet's
+   * pooled chunks are mostly hidden, and empty draws still cost their binds and calls.
+   */
+  anyVisible(batch) {
+    const n = batch.memberCount;
+    if (n === 0 || n !== batch.count || n > 8) return true;
+    for (let i = 0; i < n; i++) {
+      if (this.u32[batch.members[i] * INSTANCE_FLOATS + 13] & InstanceFlags.Visible) return true;
+    }
+    return false;
+  }
+  nearKeys = new Float64Array(0);
+  nearItems = [];
+  /**
+   * Reorders a camera's opaque draws nearest first within each run that shares a pipeline and
+   * material, so the depth test rejects hidden fragments before they're shaded (overdraw on heavy
+   * shaders, like terrain, costs the most). Pipeline and material switches stay as few as before.
+   * A batch's distance is its first member's origin: exact for single-instance draws (terrain
+   * chunks), a fair guess for instanced ones. No allocation after warm-up: one typed-array sort of
+   * packed keys (run, log distance, index).
+   */
+  orderNearFirst(list, eye) {
+    const n = list.length;
+    if (n < 2 || n >= 1 << 16) return;
+    if (this.nearKeys.length < n) this.nearKeys = new Float64Array(n * 2);
+    const keys = this.nearKeys.subarray(0, n);
+    const items = list.items;
+    const f = this.f32;
+    let run = 0;
+    for (let i = 0; i < n; i++) {
+      const batch = items[i].batch;
+      if (i > 0) {
+        const prev = items[i - 1].batch;
+        const a = prev.mesh.gpu?.share;
+        const b = batch.mesh.gpu?.share;
+        if (prev.material !== batch.material || this.batchKey(prev) !== this.batchKey(batch) || (a !== void 0 || b !== void 0) && a !== b)
+          run++;
+      }
+      let q = 0;
+      if (batch.memberCount > 0) {
+        const o = batch.members[0] * INSTANCE_FLOATS;
+        const dx = f[o + 3] - eye[0];
+        const dy = f[o + 7] - eye[1];
+        const dz = f[o + 11] - eye[2];
+        q = Math.min(
+          16777215,
+          Math.floor(Math.log2(1 + Math.sqrt(dx * dx + dy * dy + dz * dz)) * 524288)
+        );
+      }
+      keys[i] = Math.min(run, 8191) * 1099511627776 + q * 65536 + i;
+    }
+    if (run === n - 1) return;
+    keys.sort();
+    const copy = this.nearItems;
+    for (let i = 0; i < n; i++) copy[i] = items[i];
+    for (let i = 0; i < n; i++) items[i] = copy[keys[i] % 65536];
+  }
+  /** Copies each batch's scratch into the shared visible array, in draw order. */
+  pack(list) {
+    list.length = 0;
+    for (const batch of this.sorted) {
+      const n = batch.scratchCount;
+      if (n === 0) continue;
+      this.reserve(n);
+      this.visible.set(batch.scratch.subarray(0, n), this.visibleCount);
+      const item = this.item(list, batch);
+      item.first = this.visibleCount;
+      item.count = n;
+      this.visibleCount += n;
+      batch.scratchCount = 0;
+    }
+  }
+  createBindGroup(label, visible) {
+    return this.gpu.device.createBindGroup({
+      label,
+      layout: this.layout,
+      entries: [
+        { binding: 0, resource: { buffer: this.instanceBuffer.buffer } },
+        { binding: 1, resource: { buffer: visible } },
+        { binding: 2, resource: { buffer: this.prevBuffer.buffer } },
+        { binding: 3, resource: { buffer: this.deform.recordBuffer.buffer } },
+        { binding: 4, resource: { buffer: this.deform.poseBuffer.buffer } },
+        { binding: 5, resource: { buffer: this.deform.vertexBuffer.buffer } }
+      ]
+    });
+  }
+  /** Uploads this frame's CPU visible lists and (re)builds the bind groups the vertex stage reads. */
+  finishFrame() {
+    if (this.generation !== this.gpu.generation) this.upload();
+    if (this.visibleCount > 0) this.visibleBuffer.write(this.visible, 0, 0, this.visibleCount);
+    this.deform.upload();
+    const d = this.deform;
+    const deformKey = `${d.recordBuffer.version}/${d.poseBuffer.version}/${d.vertexBuffer.version}`;
+    const key = `${this.instanceBuffer.version}/${this.visibleBuffer.version}/${this.prevBuffer.version}/${deformKey}/${this.gpu.generation}`;
+    if (!this.bindGroup || this.bound !== key) {
+      this.bindGroup = this.createBindGroup("instances", this.visibleBuffer.buffer);
+      this.bound = key;
+    }
+    const g = this.gpuVisible;
+    if (g) {
+      const gkey = `${this.instanceBuffer.version}/${g.version}/${this.prevBuffer.version}/${deformKey}/${this.gpu.generation}`;
+      if (!this.gpuBindGroup || this.gpuBound !== gkey) {
+        this.gpuBindGroup = this.createBindGroup("instances/gpu-culled", g.buffer);
+        this.gpuBound = gkey;
+      }
+    }
+  }
+}
+const legacy = {
+  planes: null,
+  require: 0,
+  eye: void 0,
+  lodScale: 1,
+  orthographic: false,
+  lodState: void 0,
+  updateLod: true
+};
+function lodSize(radius, distance, params) {
+  if (params.orthographic) return f32(radius * params.lodScale);
+  return f32(radius * params.lodScale / Math.max(distance, 1e-4));
+}
+const ids = /* @__PURE__ */ new WeakMap();
+let nextId = 1;
+function idOf(o) {
+  let id = ids.get(o);
+  if (id === void 0) {
+    id = nextId++;
+    ids.set(o, id);
+  }
+  return id;
+}
+function createInstanceLayout(gpu) {
+  return gpu.layouts.bindGroupLayout({
+    label: "instances",
+    entries: [
+      {
+        binding: 0,
+        visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+        buffer: { type: "read-only-storage" }
+      },
+      {
+        binding: 1,
+        visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+        buffer: { type: "read-only-storage" }
+      },
+      { binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
+      // Deform records, poses (joint matrices, morph weights), and per-vertex deform data.
+      { binding: 3, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
+      { binding: 4, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
+      { binding: 5, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } }
+    ]
+  });
+}
+const Instances = defineResource("render/Instances", {
+  description: "The persistent GPU instance buffer: one slot per Mesh3d entity."
+});
+function tableChanged(table, since) {
+  return table.lastStructural > since || table.lastChanged(GlobalTransform) > since || table.lastChanged(Mesh3d) > since || table.lastChanged(ComputedVisibility) > since || table.lastChanged(InstanceSlot) > since || table.has(MeshMaterial) && table.lastChanged(MeshMaterial) > since || table.has(Lod) && table.lastChanged(Lod) > since || table.has(VisibilityRange) && table.lastChanged(VisibilityRange) > since || table.has(InstanceData) && table.lastChanged(InstanceData) > since;
+}
+let zeros = new Uint32Array(1024);
+function zeroTicks(n) {
+  if (zeros.length < n) zeros = new Uint32Array(Math.max(n, zeros.length * 2));
+  return zeros;
+}
+const DeformPath = defineResource("render/DeformPath", {
+  description: "Present when skinning and morph targets (skinningPlugin) are installed."
+});
+const warnedDeforms = /* @__PURE__ */ new WeakSet();
+function warnNoDeforms(world) {
+  if (warnedDeforms.has(world)) return;
+  warnedDeforms.add(world);
+  world.tryResource(LogResource)?.log(
+    "warn",
+    "An entity has SkinnedMesh or MorphWeights, but skinningPlugin isn't installed; it draws in its rest pose",
+    {
+      code: "render/feature-missing",
+      hint: "Add skinningPlugin from '@aethervtt/shard-render' (forwardPlugin includes it)."
+    }
+  );
+}
+const prepareInstances = defineSystem({
+  name: "render/prepare-instances",
+  description: "Assigns instance slots, writes changed transforms and batches, and uploads dirty slots.",
+  setup: (world) => ({
+    q: world.query({ with: [Mesh3d, GlobalTransform, ComputedVisibility, InstanceSlot] })
+  }),
+  run: ({ q }, world, ctx) => {
+    const store = world.resource(Instances);
+    const meshes = world.resource(Meshes);
+    const materials = world.resource(Materials);
+    const assets = world.resource(GpuAssetsResource);
+    assets.beginFrame();
+    store.beginFrame();
+    const deforms = world.hasResource(DeformPath);
+    const since = ctx.lastRunTick;
+    let hidden = 0;
+    let rows = 0;
+    const tableHidden = store.tableHidden;
+    for (const table of q.tables) {
+      const n = table.count;
+      if (n === 0) continue;
+      const cached = tableHidden[table.id];
+      if (cached !== void 0 && cached >= 0 && !tableChanged(table, since)) {
+        hidden += cached;
+        rows += n;
+        continue;
+      }
+      const hiddenBefore = hidden;
+      const slots = table.column(InstanceSlot, "slot");
+      const g = table.column(GlobalTransform, "matrix");
+      const gChanged = table.changedTicks(GlobalTransform);
+      const meshRefs = table.column(Mesh3d, "mesh");
+      const meshChanged = table.changedTicks(Mesh3d);
+      const hasMaterial = table.has(MeshMaterial);
+      const materialRefs = hasMaterial ? table.column(MeshMaterial, "material") : void 0;
+      const materialChanged = hasMaterial ? table.changedTicks(MeshMaterial) : zeroTicks(n);
+      const hasLod = table.has(Lod);
+      const lodLevels = hasLod ? table.column(Lod, "levels") : void 0;
+      const lodChanged = hasLod ? table.changedTicks(Lod) : zeroTicks(n);
+      const hasRange = table.has(VisibilityRange);
+      const rangeStart = hasRange ? table.column(VisibilityRange, "start") : void 0;
+      const rangeEnd = hasRange ? table.column(VisibilityRange, "end") : void 0;
+      const rangeChanged = hasRange ? table.changedTicks(VisibilityRange) : zeroTicks(n);
+      const hasData = !hasRange && table.has(InstanceData);
+      const dataX = hasData ? table.column(InstanceData, "x") : void 0;
+      const dataY = hasData ? table.column(InstanceData, "y") : void 0;
+      const dataChanged = hasData ? table.changedTicks(InstanceData) : zeroTicks(n);
+      const vis = table.column(ComputedVisibility, "visible");
+      const deformed = table.has(SkinnedMesh) || table.has(MorphWeights);
+      if (deformed && !deforms) warnNoDeforms(world);
+      const tableFlags = (deforms && table.has(SkinnedMesh) ? InstanceFlags.Skinned : 0) | (deforms && table.has(MorphWeights) ? InstanceFlags.Morph : 0) | (table.has(NotShadowCaster) ? 0 : InstanceFlags.Caster) | (table.has(NotShadowReceiver) ? 0 : InstanceFlags.Receiver) | (hasRange ? InstanceFlags.Range : 0) | (hasLod ? InstanceFlags.Lod : 0);
+      let u32 = store.u32;
+      let slotFlags = store.flags;
+      for (let i = 0; i < n; i++) {
+        let slot = slots[i] - 1;
+        let fresh = false;
+        if (slot < 0) {
+          slot = store.alloc(table.entities[i]);
+          slots[i] = slot + 1;
+          fresh = true;
+          u32 = store.u32;
+          slotFlags = store.flags;
+        }
+        const o = slot * INSTANCE_FLOATS;
+        const visible = vis[i] !== 0;
+        if (!visible) hidden++;
+        const flags = tableFlags | (visible ? InstanceFlags.Visible : 0);
+        const oldFlags = slotFlags[slot];
+        if (fresh || gChanged[i] > since) store.moveSlot(slot, g, i * 12, fresh);
+        if (fresh || ((oldFlags ^ flags) & InstanceFlags.Lod) !== 0 || meshChanged[i] > since || materialChanged[i] > since || lodChanged[i] > since) {
+          store.meshRefs[slot] = meshRefs[i] ?? null;
+          store.materialRefs[slot] = materialRefs?.[i] ?? null;
+          store.lods[slot] = hasLod ? {
+            levels: lodLevels[i],
+            hysteresis: table.column(Lod, "hysteresis")[i],
+            bias: table.column(Lod, "bias")[i]
+          } : null;
+          resolveSlot(store, slot, meshes, materials);
+        }
+        if (oldFlags !== flags) {
+          u32[o + 13] = flags;
+          slotFlags[slot] = flags;
+          store.markDirty(slot);
+        }
+        if (fresh || rangeChanged[i] > since) {
+          if (hasRange) store.setRange(slot, rangeStart[i], rangeEnd[i]);
+        }
+        if (hasData && (fresh || dataChanged[i] > since))
+          store.setRange(slot, dataX[i], dataY[i]);
+      }
+      tableHidden[table.id] = hidden - hiddenBefore;
+      rows += n;
+    }
+    store.settleMoved();
+    store.hiddenCount = hidden;
+    store.drawableCount = rows - store.pending.size;
+    if (store.pending.size > 0) {
+      for (const slot of store.pending) resolveSlot(store, slot, meshes, materials);
+    }
+    for (const batch of store.batches) {
+      if (batch.count === 0) continue;
+      const meshGone = batch.meshGuid !== void 0 && meshes.byGuid(batch.meshGuid) !== batch.mesh;
+      const materialGone = batch.materialGuid !== void 0 && materials.byGuid(batch.materialGuid) !== batch.material;
+      if (meshGone || materialGone) {
+        for (let s = 0; s < store.high; s++) {
+          const a = store.batchOf[s];
+          const inSet = a <= -2 && store.lodSets[-2 - a].batches.includes(batch.index);
+          if (a === batch.index || inSet) resolveSlot(store, s, meshes, materials);
+        }
+      }
+    }
+    for (const batch of store.batches) {
+      batch.ready = batch.count > 0 && assets.materialReady(world, batch.material);
+      const material = batch.material;
+      batch.transparent = isTransparent(material.type.blendOf(material.value));
+      batch.deferrable = material.type.deferrable(material.value);
+    }
+    store.upload();
+  }
+});
+function resolveSlot(store, slot, meshes, materials) {
+  const meshRef = store.meshRefs[slot];
+  const materialRef = store.materialRefs[slot];
+  const material = materialRef ? materials.get(materialRef) : store.defaultMaterial;
+  const lod = store.lods[slot];
+  if (lod && lod.levels.length > 0) {
+    const set = material ? store.lodSetFor(lod, material, materialRef?.guid ?? void 0, meshes) : void 0;
+    if (!set) {
+      store.assign(slot, -1);
+      store.pending.add(slot);
+      return;
+    }
+    store.pending.delete(slot);
+    store.assign(slot, -2 - set.index);
+    return;
+  }
+  const mesh = meshes.get(meshRef);
+  if (!mesh || !material) {
+    store.assign(slot, -1);
+    if (meshRef?.guid !== void 0 || !material) store.pending.add(slot);
+    else store.pending.delete(slot);
+    return;
+  }
+  store.pending.delete(slot);
+  store.assign(
+    slot,
+    store.batchFor(mesh, material, meshRef?.guid, materialRef?.guid ?? void 0).index
+  );
+}
+function observeInstanceRemovals(world) {
+  world.observe(onRemove(Mesh3d), ({ entity, world: world2 }) => {
+    if (!world2.has(entity, InstanceSlot)) return;
+    const store = world2.tryResource(Instances);
+    const value = world2.get(entity, InstanceSlot);
+    if (store && value.slot > 0) store.release(value.slot - 1);
+    const table = world2.entityTable(entity);
+    table.column(InstanceSlot, "slot")[world2.entityRow(entity)] = 0;
+  });
+}
+export {
+  DeformPath,
+  INSTANCE_BYTES,
+  INSTANCE_FLOATS,
+  InstanceData,
+  InstanceFlags,
+  InstanceSlot,
+  InstanceStore,
+  Instances,
+  LOD_BIT,
+  LOD_UNSET,
+  Lod,
+  MAX_LOD_LEVELS,
+  Mesh3d,
+  MeshMaterial,
+  MorphWeights,
+  NO_BATCH,
+  NotShadowCaster,
+  NotShadowReceiver,
+  SLOT_MASK,
+  SkinnedMesh,
+  VisibilityRange,
+  createDrawList,
+  createInstanceLayout,
+  lodSize,
+  observeInstanceRemovals,
+  prepareInstances,
+  selectLod,
+  slotSphere,
+  sphereInFrustum
+};