@forgeax/engine-render 0.1.2

package/dist/chunk-QRXPSX4X.mjs

@@ -0,0 +1,659 @@
+import { TileLayer, decodeSortScope, Tilemap, MeshFilter, MeshRenderer, SpriteInstances, Layer, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, materialTextureValue, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-YAKEQPWO.mjs';
+import { err, ok, unwrapHandle } from '@forgeax/engine-types';
+import { createPrimitiveMesh } from '@forgeax/engine-geometry';
+import { decodeTileBits } from '@forgeax/engine-graphics-extras';
+import { frustum, mat4 } from '@forgeax/engine-math';
+import { ChildOf, Children, Transform } from '@forgeax/engine-scene';
+
+function resolveTilesetRuntime(world, guid, lookup) {
+  if (guid.length === 0) {
+    return err({
+      code: "tileset-atlas-not-found",
+      expected: "a non-empty durable atlas GUID",
+      hint: "load the atlas payload before extracting the tilemap",
+      detail: { guid }
+    });
+  }
+  const payload = lookup(guid);
+  if (payload === void 0) {
+    return err({
+      code: "tileset-atlas-not-found",
+      expected: `a loaded texture payload for atlas GUID ${guid}`,
+      hint: "load or retain the atlas before extracting the tilemap",
+      detail: { guid }
+    });
+  }
+  if ("code" in payload) {
+    return err({
+      code: "tileset-atlas-stale",
+      expected: `a current texture payload for atlas GUID ${guid}`,
+      hint: "rebuild the stale atlas projection before extracting the tilemap",
+      detail: { guid }
+    });
+  }
+  if (payload.kind !== "texture") {
+    return err({
+      code: "tileset-atlas-kind-mismatch",
+      expected: "a texture atlas payload",
+      hint: `replace atlas GUID ${guid} with a texture asset`,
+      detail: { guid, actualKind: payload.kind }
+    });
+  }
+  return ok({
+    guid,
+    payload,
+    handle: world.internSharedRef("TextureAsset", payload)
+  });
+}
+var atlasMaterialCache = /* @__PURE__ */ new WeakMap();
+var atlasOnlyMaterialCache = /* @__PURE__ */ new WeakMap();
+var unitQuadHandleByWorld = /* @__PURE__ */ new WeakMap();
+function unitQuadHandle(world) {
+  const existing = unitQuadHandleByWorld.get(world);
+  if (existing !== void 0) return existing;
+  const mesh = createPrimitiveMesh("quad").unwrap();
+  const handle = world.internSharedRef("MeshAsset", mesh);
+  unitQuadHandleByWorld.set(world, handle);
+  return handle;
+}
+var streamingCacheByWorld = /* @__PURE__ */ new WeakMap();
+function streamingCache(world) {
+  let cache = streamingCacheByWorld.get(world);
+  if (cache === void 0) {
+    cache = {
+      layers: /* @__PURE__ */ new Map(),
+      chunkEntities: /* @__PURE__ */ new Map(),
+      activeChunks: /* @__PURE__ */ new Map()
+    };
+    streamingCacheByWorld.set(world, cache);
+  }
+  return cache;
+}
+function resetTilemapChunkExtractCache() {
+  atlasMaterialCache = /* @__PURE__ */ new WeakMap();
+  atlasOnlyMaterialCache = /* @__PURE__ */ new WeakMap();
+}
+function resetTilemapDerivedEntityTracker() {
+  streamingCacheByWorld = /* @__PURE__ */ new WeakMap();
+}
+function _peekPerCellStreamingLayerKeys(world) {
+  const cache = streamingCacheByWorld.get(world);
+  if (cache === void 0) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const layerKey of cache.layers.keys()) {
+    if (Number.isFinite(Number(layerKey))) out.add(Number(layerKey));
+  }
+  for (const layerKey of cache.activeChunks.keys()) {
+    if (Number.isFinite(Number(layerKey))) out.add(Number(layerKey));
+  }
+  for (const key of cache.chunkEntities.keys()) {
+    const parts = key.split(":");
+    const entity = parts[0];
+    if (entity !== void 0 && Number.isFinite(Number(entity))) out.add(Number(entity));
+  }
+  return Array.from(out);
+}
+function encodeTilemapLayerValue(layerOrder, chunkIndex, sortScope = "layer") {
+  if (sortScope === "per-cell") return layerOrder << 20 | 0;
+  return layerOrder << 20 | chunkIndex & 1048575 | 0;
+}
+function resolveTilesetMaterial(world, tileset, regionIndex, lookup) {
+  const region = tileset.regions[regionIndex];
+  if (region === void 0) return 0;
+  const atlasIndex = region.atlasIndex ?? 0;
+  const atlasGuid = tileset.atlases[atlasIndex];
+  if (atlasGuid === void 0) return 0;
+  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
+  if (!atlas.ok) return 0;
+  const atlasHandle = atlas.value.handle;
+  const atlasId = unwrapHandle(atlasHandle);
+  const cacheKey = `${atlasId}|${regionIndex}`;
+  const cache = atlasMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
+  atlasMaterialCache.set(world, cache);
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const atlasSize = tileset.atlasSizes?.[atlasIndex];
+  const atlasWidth = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
+  );
+  const atlasHeight = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
+  );
+  const halfTexelU = 0.5 / atlasWidth;
+  const halfTexelV = 0.5 / atlasHeight;
+  const u = region.x / atlasWidth + halfTexelU;
+  const v = region.y / atlasHeight + halfTexelV;
+  const w = region.width / atlasWidth - 2 * halfTexelU;
+  const h = region.height / atlasHeight - 2 * halfTexelV;
+  const matPayload = {
+    kind: "material",
+    passes: [
+      {
+        name: "Forward",
+        program: { module: "forgeax::sprite" },
+        renderState: {
+          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
+          tags: { LightMode: "Forward" },
+          queue: 3e3
+        }
+      }
+    ],
+    values: {
+      colorTint: [1, 1, 1, 1],
+      baseColorTexture: materialTextureValue(atlasHandle),
+      region: [u, v, w, h],
+      pivotAndSize: [0.5, 0.5, 1, 1],
+      flipY: 1
+    }
+  };
+  const matHandle = world.allocSharedRef(
+    "MaterialAsset",
+    matPayload
+  );
+  const id = unwrapHandle(matHandle);
+  cache.set(cacheKey, id);
+  return id;
+}
+function resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) {
+  const atlasGuid = tileset.atlases[atlasIndex];
+  if (atlasGuid === void 0) return 0;
+  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
+  if (!atlas.ok) return 0;
+  const atlasHandle = atlas.value.handle;
+  const atlasId = unwrapHandle(atlasHandle);
+  const cacheKey = String(atlasId);
+  const cache = atlasOnlyMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
+  atlasOnlyMaterialCache.set(world, cache);
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const matPayload = {
+    kind: "material",
+    passes: [
+      {
+        name: "Forward",
+        program: { module: "forgeax::sprite" },
+        renderState: {
+          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
+          tags: { LightMode: "Forward" },
+          queue: 3e3
+        }
+      }
+    ],
+    values: {
+      colorTint: [1, 1, 1, 1],
+      baseColorTexture: materialTextureValue(atlasHandle),
+      region: [0, 0, 1, 1],
+      pivotAndSize: [0.5, 0.5, 1, 1],
+      flipY: 1
+    }
+  };
+  const matHandle = world.allocSharedRef(
+    "MaterialAsset",
+    matPayload
+  );
+  const id = unwrapHandle(matHandle);
+  cache.set(cacheKey, id);
+  return id;
+}
+function computeRegionUv(tileset, region, atlasIndex) {
+  const atlasSize = tileset.atlasSizes?.[atlasIndex];
+  const atlasWidth = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
+  );
+  const atlasHeight = Math.max(
+    1,
+    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
+  );
+  const halfTexelU = 0.5 / atlasWidth;
+  const halfTexelV = 0.5 / atlasHeight;
+  return [
+    region.x / atlasWidth + halfTexelU,
+    region.y / atlasHeight + halfTexelV,
+    region.width / atlasWidth - 2 * halfTexelU,
+    region.height / atlasHeight - 2 * halfTexelV
+  ];
+}
+var SQRT1_2 = Math.SQRT1_2;
+function effectivePivotYForTilemapFlip(pivotY, pivotX, flipV, flipDiagonal) {
+  const base = flipDiagonal ? pivotX : pivotY;
+  return flipV ? 1 - base : base;
+}
+function specFor(layerCols, chunkSize, cellIndex, packedTile, materialHandle, entry, atlasIndex) {
+  const cellX = cellIndex % layerCols;
+  const cellY = Math.floor(cellIndex / layerCols);
+  const chunkX = Math.floor(cellX / chunkSize);
+  const chunkY = Math.floor(cellY / chunkSize);
+  const chunksPerRow = Math.max(1, Math.ceil(layerCols / chunkSize));
+  const chunkIndex = chunkY * chunksPerRow + chunkX;
+  const { tileId } = decodeTileBits(packedTile);
+  return {
+    cellX,
+    cellY,
+    tileId,
+    packedTile,
+    materialHandle,
+    chunkIndex,
+    widthCells: entry.widthCells ?? 1,
+    heightCells: entry.heightCells ?? 1,
+    pivotX: entry.pivotX ?? 0.5,
+    pivotY: entry.pivotY ?? 0.5,
+    atlasIndex,
+    regionIndex: entry.regionIndex
+  };
+}
+function computeTileTrs(tilemap, spec, packedTile) {
+  const { flipH, flipV, flipDiagonal } = decodeTileBits(packedTile);
+  const basePivotForX = flipDiagonal ? spec.pivotY : spec.pivotX;
+  const effectivePivotX = flipH ? 1 - basePivotForX : basePivotForX;
+  const effectivePivotY = effectivePivotYForTilemapFlip(
+    spec.pivotY,
+    spec.pivotX,
+    flipV,
+    flipDiagonal
+  );
+  const tileSizeX = tilemap.tileSize[0] ?? 1;
+  const tileSizeY = tilemap.tileSize[1] ?? 1;
+  return {
+    posX: (spec.cellX + effectivePivotX + (0.5 - effectivePivotX) * spec.widthCells) * tileSizeX,
+    posY: (spec.cellY + effectivePivotY + (0.5 - effectivePivotY) * spec.heightCells) * tileSizeY,
+    scaleX: (flipH ? -1 : 1) * spec.widthCells * tileSizeX,
+    scaleY: (flipV ? -1 : 1) * spec.heightCells * tileSizeY,
+    quatZ: flipDiagonal ? SQRT1_2 : 0,
+    quatW: flipDiagonal ? SQRT1_2 : 1
+  };
+}
+function spawnDerivedRenderEntities(world, tilemap, layerEntity, layerOrder, spec, packedTile, sortScope = "layer") {
+  const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(tilemap, spec, packedTile);
+  const layerValue = encodeTilemapLayerValue(layerOrder, spec.chunkIndex, sortScope);
+  return world.spawn(
+    {
+      component: Transform,
+      data: {
+        pos: [posX, posY, 0],
+        quat: [0, 0, quatZ, quatW],
+        scale: [scaleX, scaleY, 1]
+      }
+    },
+    { component: MeshFilter, data: { assetHandle: unitQuadHandle(world) } },
+    {
+      component: MeshRenderer,
+      data: {
+        materials: [spec.materialHandle]
+      }
+    },
+    { component: Layer, data: { value: layerValue } },
+    { component: ChildOf, data: { parent: layerEntity } }
+  ).unwrap();
+}
+function spawnSpriteInstancesGroup(world, tilemap, tileset, layerEntity, layerOrder, chunkIndex, atlasIndex, materialHandle, cellSpecs) {
+  if (cellSpecs.length === 0) return void 0;
+  const N = cellSpecs.length;
+  const transforms = new Float32Array(N * 16);
+  const regions = new Float32Array(N * 4);
+  const tmpMat = new Float32Array(16);
+  const tmpF = tmpMat;
+  const tmpT = [0, 0, 0];
+  const tmpR = [0, 0, 0, 1];
+  const tmpS = [1, 1, 1];
+  const chunksPerRow = Math.max(1, Math.ceil(tilemap.cols / tilemap.chunkSize));
+  const chunkX = chunkIndex % chunksPerRow;
+  const chunkY = Math.floor(chunkIndex / chunksPerRow);
+  const chunkScaleX = tilemap.chunkSize * (tilemap.tileSize[0] ?? 1);
+  const chunkScaleY = tilemap.chunkSize * (tilemap.tileSize[1] ?? 1);
+  const chunkCenterX = (chunkX + 0.5) * chunkScaleX;
+  const chunkCenterY = (chunkY + 0.5) * chunkScaleY;
+  const invSX = chunkScaleX > 0 ? 1 / chunkScaleX : 1;
+  const invSY = chunkScaleY > 0 ? 1 / chunkScaleY : 1;
+  for (let i = 0; i < N; i++) {
+    const spec = cellSpecs[i];
+    const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(
+      tilemap,
+      spec,
+      spec.packedTile
+    );
+    tmpT[0] = posX;
+    tmpT[1] = posY;
+    tmpT[2] = 0;
+    tmpR[0] = 0;
+    tmpR[1] = 0;
+    tmpR[2] = quatZ;
+    tmpR[3] = quatW;
+    tmpS[0] = scaleX;
+    tmpS[1] = scaleY;
+    tmpS[2] = 1;
+    mat4.compose(tmpMat, tmpT, tmpR, tmpS);
+    const dst = i * 16;
+    for (let c = 0; c < 4; c++) {
+      const base = c * 4;
+      const w3 = tmpF[base + 3];
+      transforms[dst + base + 0] = (tmpF[base + 0] - chunkCenterX * w3) * invSX;
+      transforms[dst + base + 1] = (tmpF[base + 1] - chunkCenterY * w3) * invSY;
+      transforms[dst + base + 2] = tmpF[base + 2];
+      transforms[dst + base + 3] = w3;
+    }
+    const region = tileset.regions[spec.regionIndex];
+    if (region !== void 0) {
+      const [u, v, w, h] = computeRegionUv(tileset, region, atlasIndex);
+      regions[i * 4 + 0] = u;
+      regions[i * 4 + 1] = v;
+      regions[i * 4 + 2] = w;
+      regions[i * 4 + 3] = h;
+    }
+  }
+  const layerValue = encodeTilemapLayerValue(layerOrder, chunkIndex, "layer");
+  return world.spawn(
+    {
+      component: Transform,
+      data: {
+        pos: [chunkCenterX, chunkCenterY, 0],
+        quat: [0, 0, 0, 1],
+        scale: [chunkScaleX, chunkScaleY, 1]
+      }
+    },
+    { component: MeshFilter, data: { assetHandle: unitQuadHandle(world) } },
+    {
+      component: MeshRenderer,
+      data: {
+        materials: [materialHandle]
+      }
+    },
+    { component: SpriteInstances, data: { transforms, regions } },
+    { component: Layer, data: { value: layerValue } },
+    { component: ChildOf, data: { parent: layerEntity } }
+  ).unwrap();
+}
+function bucketTileLayer(world, layerEntity, parentEntity, lookup) {
+  const tilemapRes = world.get(parentEntity, Tilemap);
+  if (!tilemapRes.ok) return void 0;
+  const tilemap = tilemapRes.value;
+  const tilesetPayload = lookup(tilemap.tileset);
+  if (tilesetPayload === void 0 || "code" in tilesetPayload) return void 0;
+  if (tilesetPayload.kind !== "tileset") return void 0;
+  const tileset = tilesetPayload;
+  const layerRes = world.get(layerEntity, TileLayer);
+  if (!layerRes.ok) return void 0;
+  const layer = layerRes.value;
+  const tiles = layer.tiles;
+  const sortScope = decodeSortScope(layer.sortScope);
+  const useSpriteInstances = sortScope === "layer";
+  const specs = [];
+  for (let i = 0; i < tiles.length; i++) {
+    const packed = tiles[i] ?? 0;
+    if (packed === 0) continue;
+    const { tileId } = decodeTileBits(packed);
+    if (tileId === 0) continue;
+    const entry = tileset.tiles[tileId - 1];
+    if (entry === void 0) continue;
+    const region = tileset.regions[entry.regionIndex];
+    if (region === void 0) continue;
+    const atlasIndex = region.atlasIndex ?? 0;
+    const materialHandle = useSpriteInstances ? resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) : resolveTilesetMaterial(world, tileset, entry.regionIndex, lookup);
+    const spec = specFor(
+      tilemap.cols,
+      tilemap.chunkSize,
+      i,
+      packed,
+      materialHandle,
+      entry,
+      atlasIndex
+    );
+    specs.push(spec);
+  }
+  return {
+    tilemap,
+    layerOrder: layer.layerOrder,
+    sortScope,
+    tileset,
+    specs
+  };
+}
+function buildCameraFrustumPlanes(world) {
+  const query = world.query({ with: [Camera, Transform] }).unwrap();
+  let result = null;
+  for (const row of query) {
+    const camEntity = row.entity;
+    const camRes = world.get(camEntity, Camera);
+    const trRes = world.get(camEntity, Transform);
+    if (!camRes.ok || !trRes.ok) continue;
+    const cam = camRes.value;
+    const tr = trRes.value;
+    const { near, far } = cam;
+    if (near >= far) continue;
+    const proj = mat4.create();
+    if (cam.projection === CAMERA_PROJECTION_ORTHOGRAPHIC) {
+      mat4.orthographic(
+        proj,
+        cam.left,
+        cam.right,
+        cam.bottom,
+        cam.top,
+        near,
+        far
+      );
+    } else {
+      mat4.perspective(
+        proj,
+        cam.fov,
+        cam.aspect,
+        near,
+        far
+      );
+    }
+    const view = mat4.create();
+    mat4.invert(
+      view,
+      tr.world
+    );
+    const vp = mat4.create();
+    mat4.multiply(
+      vp,
+      proj,
+      view
+    );
+    const f = frustum.create();
+    frustum.fromViewProjection(f, vp);
+    result = f;
+    break;
+  }
+  return result;
+}
+function computeChunkStreamBounds(tilemap, specs) {
+  let minX = Number.MAX_VALUE;
+  let minY = Number.MAX_VALUE;
+  let maxX = -Number.MAX_VALUE;
+  let maxY = -Number.MAX_VALUE;
+  for (const spec of specs) {
+    const { posX, posY, scaleX, scaleY } = computeTileTrs(tilemap, spec, spec.packedTile);
+    const halfW = Math.abs(scaleX) * 0.5;
+    const halfH = Math.abs(scaleY) * 0.5;
+    const x0 = posX - halfW;
+    const x1 = posX + halfW;
+    const y0 = posY - halfH;
+    const y1 = posY + halfH;
+    if (x0 < minX) minX = x0;
+    if (y0 < minY) minY = y0;
+    if (x1 > maxX) maxX = x1;
+    if (y1 > maxY) maxY = y1;
+  }
+  return [minX, minY, -1, maxX, maxY, 1];
+}
+function purgeDerivedEntities(world, layerEntity) {
+  const r = world.get(layerEntity, Children);
+  if (!r.ok) return;
+  const snap = r.value.entities;
+  for (let i = 0; i < snap.length; i++) {
+    const e = snap[i];
+    if (e !== void 0) world.despawn(e);
+  }
+}
+function evictDeadPerCellStreamingCaches(work, world) {
+  const cache = streamingCache(world);
+  const aliveLayerKeys = /* @__PURE__ */ new Set();
+  for (const w of work) {
+    aliveLayerKeys.add(String(unwrapHandle(w.layerEntity)));
+  }
+  const deadLayerKeys = /* @__PURE__ */ new Set();
+  for (const layerKey of cache.activeChunks.keys()) {
+    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
+  }
+  for (const layerKey of cache.layers.keys()) {
+    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
+  }
+  for (const deadKey of deadLayerKeys) {
+    const activeSet = cache.activeChunks.get(deadKey);
+    if (activeSet !== void 0) {
+      for (const chunkIdx of activeSet) {
+        cache.chunkEntities.delete(`${deadKey}:${chunkIdx}`);
+      }
+      cache.activeChunks.delete(deadKey);
+    }
+    cache.layers.delete(deadKey);
+  }
+}
+function tilemapChunkExtractSystem(world, lookup = () => void 0) {
+  const streaming = streamingCache(world);
+  const work = [];
+  const tileLayerQuery = world.query({ read: [TileLayer, ChildOf] }).unwrap();
+  for (const row of tileLayerQuery) {
+    const layer = row.get(TileLayer);
+    const parent = row.get(ChildOf).parent;
+    if (parent === null) continue;
+    work.push({
+      layerEntity: row.entity,
+      parentEntity: parent,
+      dirty: layer.dirty,
+      sortScopeRaw: layer.sortScope
+    });
+  }
+  evictDeadPerCellStreamingCaches(work, world);
+  let frustumPlanes;
+  for (const w of work) {
+    const layerKey = String(unwrapHandle(w.layerEntity));
+    const isStreaming = decodeSortScope(w.sortScopeRaw) === "per-cell";
+    if (!isStreaming) {
+      const childrenRes = world.get(w.layerEntity, Children);
+      const childCount = childrenRes.ok ? childrenRes.value.entities.length : 0;
+      if (childCount > 0 && w.dirty === 0) continue;
+      purgeDerivedEntities(world, w.layerEntity);
+      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
+      if (bucket === void 0) continue;
+      const byChunkAtlas = /* @__PURE__ */ new Map();
+      for (const spec of bucket.specs) {
+        const key = (spec.chunkIndex & 1048575) << 16 | spec.atlasIndex & 65535;
+        const list = byChunkAtlas.get(key);
+        if (list === void 0) {
+          byChunkAtlas.set(key, [spec]);
+        } else {
+          list.push(spec);
+        }
+      }
+      for (const groupSpecs of byChunkAtlas.values()) {
+        const first = groupSpecs[0];
+        if (first === void 0) continue;
+        spawnSpriteInstancesGroup(
+          world,
+          bucket.tilemap,
+          bucket.tileset,
+          w.layerEntity,
+          bucket.layerOrder,
+          first.chunkIndex,
+          first.atlasIndex,
+          first.materialHandle,
+          groupSpecs
+        );
+      }
+      if (w.dirty !== 0) {
+        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
+      }
+      continue;
+    }
+    if (w.dirty !== 0 || !streaming.layers.has(layerKey)) {
+      const activeSet2 = streaming.activeChunks.get(layerKey);
+      if (activeSet2 !== void 0) {
+        for (const chunkIdx of activeSet2) {
+          const key = `${layerKey}:${chunkIdx}`;
+          const entities = streaming.chunkEntities.get(key);
+          if (entities !== void 0) {
+            for (const e of entities) world.despawn(e);
+            streaming.chunkEntities.delete(key);
+          }
+        }
+        activeSet2.clear();
+      }
+      streaming.layers.delete(layerKey);
+      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
+      if (bucket !== void 0) {
+        const byChunkSpecs = /* @__PURE__ */ new Map();
+        for (const spec of bucket.specs) {
+          const list = byChunkSpecs.get(spec.chunkIndex);
+          if (list === void 0) {
+            byChunkSpecs.set(spec.chunkIndex, [spec]);
+          } else {
+            list.push(spec);
+          }
+        }
+        const byChunk = /* @__PURE__ */ new Map();
+        for (const [chunkIdx, specs] of byChunkSpecs) {
+          byChunk.set(chunkIdx, {
+            specs,
+            bounds: computeChunkStreamBounds(bucket.tilemap, specs)
+          });
+        }
+        streaming.layers.set(layerKey, {
+          byChunk,
+          tilemap: bucket.tilemap,
+          layerOrder: bucket.layerOrder,
+          sortScope: bucket.sortScope
+        });
+      }
+      if (w.dirty !== 0) {
+        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
+      }
+    }
+    const cache = streaming.layers.get(layerKey);
+    if (cache === void 0) continue;
+    if (frustumPlanes === void 0) {
+      frustumPlanes = buildCameraFrustumPlanes(world);
+    }
+    const activeSet = streaming.activeChunks.get(layerKey) ?? /* @__PURE__ */ new Set();
+    streaming.activeChunks.set(layerKey, activeSet);
+    const { tilemap } = cache;
+    for (const [chunkIdx, entry] of cache.byChunk) {
+      const { specs, bounds } = entry;
+      const visible = frustumPlanes === null || frustum.intersectsBox(frustumPlanes, bounds);
+      const wasActive = activeSet.has(chunkIdx);
+      if (visible && !wasActive) {
+        const spawned = [];
+        for (const spec of specs) {
+          const e = spawnDerivedRenderEntities(
+            world,
+            tilemap,
+            w.layerEntity,
+            cache.layerOrder,
+            spec,
+            spec.packedTile,
+            cache.sortScope
+          );
+          spawned.push(unwrapHandle(e));
+        }
+        streaming.chunkEntities.set(`${layerKey}:${chunkIdx}`, spawned);
+        activeSet.add(chunkIdx);
+      } else if (!visible && wasActive) {
+        const key = `${layerKey}:${chunkIdx}`;
+        const entities = streaming.chunkEntities.get(key);
+        if (entities !== void 0) {
+          for (const e of entities) world.despawn(e);
+          streaming.chunkEntities.delete(key);
+        }
+        activeSet.delete(chunkIdx);
+      }
+    }
+  }
+}
+
+export { _peekPerCellStreamingLayerKeys, computeChunkStreamBounds, effectivePivotYForTilemapFlip, encodeTilemapLayerValue, resetTilemapChunkExtractCache, resetTilemapDerivedEntityTracker, resolveTilesetRuntime, tilemapChunkExtractSystem };
+//# sourceMappingURL=chunk-QRXPSX4X.mjs.map
+//# sourceMappingURL=chunk-QRXPSX4X.mjs.map