@forgeax/engine-render 0.1.4 → 0.1.7

package/dist/chunk-JMSB7AR4.mjs

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=chunk-JMSB7AR4.mjs.map
-//# sourceMappingURL=chunk-JMSB7AR4.mjs.map

package/dist/chunk-JMSB7AR4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-JMSB7AR4.mjs"}

package/dist/chunk-KHI6K4C6.mjs

@@ -1,659 +0,0 @@
-import { TileLayer, decodeSortScope, Tilemap, MeshFilter, MeshRenderer, SpriteInstances, Layer, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, materialTextureValue, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-DJIMFYX6.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-KHI6K4C6.mjs.map
-//# sourceMappingURL=chunk-KHI6K4C6.mjs.map