@aethervtt/shard-sprite 0.0.1 → 0.1.0

package/dist/baseline/lights2d.d.ts

@@ -0,0 +1,6 @@
+import { type LightView2d, type ViewGpu } from '../lights2d.js';
+/**
+ * Bins, shadows and reduces a view's lights into its fragment-stage data textures. Returns the
+ * bytes written. `segmentsChanged`: the occluder segments differ from last frame.
+ */
+export declare function lightOnCpu(view: LightView2d, g: ViewGpu, segmentsChanged: boolean): number;

package/dist/baseline/lights2d.js

@@ -0,0 +1,114 @@
+import {
+  binLightsInto,
+  COARSE_RES,
+  LIGHT2D_FLOATS,
+  SHADOW_RES,
+  TILE_STRIDE,
+  writeShadowRow
+} from "../lights2d.js";
+const SPAN = SHADOW_RES / COARSE_RES;
+const views = /* @__PURE__ */ new WeakMap();
+function stateOf(view) {
+  let s = views.get(view);
+  if (!s) {
+    s = {
+      tiles: new Uint32Array(0),
+      scratch: new Uint32Array(0),
+      rows: new Float32Array(0),
+      coarse: new Float32Array(0),
+      keys: new Float64Array(0)
+    };
+    views.set(view, s);
+  }
+  return s;
+}
+function lightOnCpu(view, g, segmentsChanged) {
+  const s = stateOf(view);
+  let bytes = 0;
+  const words = view.tilesX * view.tilesY * TILE_STRIDE;
+  if (s.scratch.length < words) {
+    s.scratch = new Uint32Array(words);
+    const tiles = new Uint32Array(words);
+    tiles.fill(4294967295);
+    s.tiles = tiles;
+  }
+  binLightsInto(view.circles, view.count, view.tilesX, view.tilesY, s.scratch);
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < words; i++) {
+    if (s.scratch[i] !== s.tiles[i]) {
+      if (first < 0) first = i;
+      last = i;
+      s.tiles[i] = s.scratch[i];
+    }
+  }
+  if (first >= 0) {
+    g.tiles.write(s.tiles, first * 4, first, last - first + 1);
+    bytes += (last - first + 1) * 4;
+  }
+  const rows = view.shadowedCount;
+  if (s.keys.length < rows * 4) {
+    const keys = new Float64Array(Math.max(rows, 1) * 4 * 2).fill(Number.NaN);
+    keys.set(s.keys);
+    s.keys = keys;
+    const grown = new Float32Array(keys.length / 4 * SHADOW_RES);
+    grown.set(s.rows);
+    s.rows = grown;
+    const coarse = new Float32Array(keys.length / 4 * COARSE_RES * 2);
+    coarse.set(s.coarse);
+    s.coarse = coarse;
+  }
+  let lo = -1;
+  let hi = -1;
+  for (let r = 0; r < rows; r++) {
+    const o = view.shadowed[r] * LIGHT2D_FLOATS;
+    const x = view.lights[o];
+    const y = view.lights[o + 1];
+    const radius = view.lights[o + 3];
+    const layers = view.lightBits[o + 14];
+    const k = r * 4;
+    if (!segmentsChanged && s.keys[k] === x && s.keys[k + 1] === y && s.keys[k + 2] === radius && s.keys[k + 3] === layers) {
+      continue;
+    }
+    s.keys[k] = x;
+    s.keys[k + 1] = y;
+    s.keys[k + 2] = radius;
+    s.keys[k + 3] = layers;
+    const at = r * SHADOW_RES;
+    writeShadowRow(
+      x,
+      y,
+      radius,
+      layers,
+      view.segments,
+      view.segmentBits,
+      view.segmentCount,
+      s.rows,
+      at
+    );
+    for (let c = 0; c < COARSE_RES; c++) {
+      let min = Number.POSITIVE_INFINITY;
+      let max = 0;
+      for (let i = 0; i < SPAN; i++) {
+        const v = s.rows[at + c * SPAN + i];
+        if (v < min) min = v;
+        if (v > max) max = v;
+      }
+      s.coarse[(r * COARSE_RES + c) * 2] = min;
+      s.coarse[(r * COARSE_RES + c) * 2 + 1] = max;
+    }
+    if (lo < 0) lo = r;
+    hi = r;
+  }
+  for (let r = rows; r < s.keys.length / 4; r++) s.keys[r * 4] = Number.NaN;
+  if (lo >= 0) {
+    const n = hi - lo + 1;
+    g.shadowMap.write(s.rows, lo * SHADOW_RES * 4, lo * SHADOW_RES, n * SHADOW_RES);
+    g.shadowCoarse.write(s.coarse, lo * COARSE_RES * 8, lo * COARSE_RES * 2, n * COARSE_RES * 2);
+    bytes += n * (SHADOW_RES + COARSE_RES * 2) * 4;
+  }
+  return bytes;
+}
+export {
+  lightOnCpu
+};

package/dist/ground.d.ts

@@ -0,0 +1,81 @@
+import { type AssetRef, type Entity, type World } from '@aethervtt/shard-core';
+import { Mesh } from '@aethervtt/shard-mesh';
+import { type PickDetail, type PickHit } from '@aethervtt/shard-render';
+import { type TextureAtlas } from './atlas.js';
+import { type TilemapData } from './tilemap.js';
+/** Marks a chunk mesh a ground tilemap spawned: which layer and chunk of which tilemap. */
+export declare const TileChunk: import("@aethervtt/shard-core").ComponentDef<{
+    readonly tilemap: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly layer: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly chunk: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+/** The rotation that lays a tilemap's XY plane on the ground, rows going +Z, facing up. */
+export declare function tilemapOnGround(elevation?: number): {
+    translation: [number, number, number];
+    rotation: [number, number, number, number];
+};
+/** Tiles lit like a floor: flat albedo from the atlas, an up normal, roughness 1. */
+export declare const TileLit: import("@aethervtt/shard-render").MaterialType;
+/** Tiles drawn without lighting: the atlas as it is, display-referred like any overlay. */
+export declare const TileUnlit: import("@aethervtt/shard-render").MaterialType;
+export declare const GROUND_TILE_SHADERS: Record<string, string>;
+interface ChunkState {
+    entity: Entity;
+    mesh: Mesh;
+    meshRef: AssetRef<'Mesh'>;
+}
+interface LayerState {
+    /** Edit log position and base (see TileLayer.edits): what's been rebuilt. */
+    cursor: number;
+    base: number;
+    chunks: Map<number, ChunkState>;
+    /** Chunks holding an animated tile: rebuilt when a frame turns. */
+    animated: number[];
+}
+interface GroundMap {
+    data: TilemapData;
+    dataVersion: number;
+    atlas: TextureAtlas;
+    atlasVersion: number;
+    chunkSize: number;
+    tileSize: [number, number];
+    material: AssetRef<'Material'>;
+    lit: '2d' | '3d' | 'none';
+    layers: LayerState[];
+    /** Tile id → region + 1 with animations applied, and what it was built from. */
+    remap: Uint32Array;
+    base: Uint32Array;
+    /** The palette's length when `base` was resolved: an edit naming a new tile grows it. */
+    paletteLength: number;
+    /** Tile ids that animate: chunks holding one rebuild when its frame turns. */
+    animatedIds: Set<number>;
+    band: number;
+    order: number;
+    level: number;
+    mask: number;
+    seen: number;
+}
+export interface GroundTilesState {
+    maps: Map<Entity, GroundMap>;
+    /** Chunk meshes rebuilt and uploaded last frame. */
+    chunkUploads: number;
+    materials: Map<string, AssetRef<'Material'>>;
+    frame: number;
+}
+export declare const GroundTiles: import("@aethervtt/shard-core").ResourceDef<GroundTilesState>;
+/**
+ * Keeps each ground tilemap's chunk meshes current: all of them when the map, its atlas or its
+ * settings change; the chunks its edits touched otherwise; animated chunks as their frames turn.
+ */
+export declare const syncGroundTiles: import("@aethervtt/shard-core").SystemDef<{
+    q: import("@aethervtt/shard-core").Query;
+}>;
+/** Frees a ground tilemap's chunks when it loses its Tilemap or GroundLayer. */
+export declare function observeGroundTiles(world: World): void;
+/**
+ * The tile under a pick (0059): the cell of the tilemap the hit landed on, and the tile there
+ * named as the palette names it. A ground chunk knows its layer; a tilemap in the sprite pass
+ * reports its topmost filled layer at the cell. Undefined for hits on anything else.
+ */
+export declare function tileDetail(world: World, hit: PickHit): PickDetail | undefined;
+export {};

package/dist/ground.js

@@ -0,0 +1,394 @@
+import {
+  affine,
+  ChildOf,
+  Derived,
+  defineComponent,
+  defineResource,
+  defineSystem,
+  onRemove,
+  t
+} from "@aethervtt/shard-core";
+import { Mesh } from "@aethervtt/shard-mesh";
+import {
+  defineMaterial,
+  GroundLayer,
+  MaterialAsset,
+  Materials,
+  Mesh3d,
+  Meshes,
+  MeshMaterial,
+  NotShadowCaster,
+  RenderLayers
+} from "@aethervtt/shard-render";
+import { Time } from "@aethervtt/shard-runtime";
+import { Textures } from "@aethervtt/shard-texture";
+import { GlobalTransform, Transform } from "@aethervtt/shard-transform";
+import { TextureAtlases } from "./atlas.js";
+import { resolveTiles } from "./render.js";
+import { Tilemap, TilemapDatas } from "./tilemap.js";
+const TileChunk = defineComponent(
+  "sprite/TileChunk",
+  {
+    tilemap: t.entity({ readonly: true, description: "The Tilemap this chunk belongs to." }),
+    layer: t.u16({ readonly: true, description: "Layer index in the tilemap data." }),
+    chunk: t.u32({ readonly: true, description: "Chunk index: cy \xB7 chunks across + cx." })
+  },
+  {
+    description: "A ground tilemap's chunk mesh: spawned and kept by the sprite plugin.",
+    serialize: false,
+    save: false
+  }
+);
+function tilemapOnGround(elevation = 0) {
+  return { translation: [0, elevation, 0], rotation: [-Math.SQRT1_2, 0, 0, Math.SQRT1_2] };
+}
+const TileLit = defineMaterial("sprite/TileLit", {
+  extends: "standard",
+  blend: "mask",
+  standardTextures: false,
+  fields: { atlas: t.handle("Texture", { description: "The tile atlas." }) },
+  colors: ["atlas"],
+  shader: "sprite::tile_lit",
+  description: "Lit ground tiles (a Tilemap on a GroundLayer, lit: 3d or 2d)."
+});
+const TileUnlit = defineMaterial("sprite/TileUnlit", {
+  extends: "none",
+  blend: "mask",
+  fields: { atlas: t.handle("Texture", { description: "The tile atlas." }) },
+  colors: ["atlas"],
+  shader: "sprite::tile_unlit",
+  description: "Unlit ground tiles (a Tilemap on a GroundLayer, lit: none)."
+});
+const GROUND_TILE_SHADERS = {
+  "sprite::tile_sample": `
+/** Trilinear at the larger axis's footprint, never anisotropic: a region's edge stays its edge. */
+fn tile_sample(atlas: texture_2d<f32>, s: sampler, uv: vec2f) -> vec4f {
+  let size = vec2f(textureDimensions(atlas));
+  let dx = dpdx(uv * size);
+  let dy = dpdy(uv * size);
+  let lod = 0.5 * log2(max(max(dot(dx, dx), dot(dy, dy)), 1e-8));
+  return textureSampleLevel(atlas, s, uv, lod);
+}`,
+  "sprite::tile_lit": `
+import shard::pbr::types::{ VertexOutput, PbrInput };
+import sprite::tile_sample::tile_sample;
+import material::tile_lit::{ TileLit_atlas, TileLit_atlas_sampler };
+
+override fn pbr_input(in: VertexOutput) -> PbrInput {
+  let c = tile_sample(TileLit_atlas, TileLit_atlas_sampler, in.uv);
+  var p: PbrInput;
+  p.base_color = c.rgb;
+  p.alpha = c.a;
+  p.normal = normalize(in.world_normal);
+  p.metallic = 0.0;
+  p.roughness = 1.0;
+  p.emissive = vec3f(0.0);
+  p.occlusion = 1.0;
+  return p;
+}`,
+  "sprite::tile_unlit": `
+import shard::pbr::types::VertexOutput;
+import shard::view::view;
+import sprite::tile_sample::tile_sample;
+import material::tile_unlit::{ TileUnlit_atlas, TileUnlit_atlas_sampler };
+
+override fn shade(in: VertexOutput) -> vec4f {
+  let c = tile_sample(TileUnlit_atlas, TileUnlit_atlas_sampler, in.uv);
+  return vec4f(c.rgb / view.exposure, c.a);
+}`
+};
+const GroundTiles = defineResource("sprite/GroundTiles", {
+  description: "Ground tilemaps (0059): their chunk meshes, and how many were rebuilt last frame.",
+  init: () => ({ maps: /* @__PURE__ */ new Map(), chunkUploads: 0, materials: /* @__PURE__ */ new Map(), frame: 0 })
+});
+const LITS = ["2d", "3d", "none"];
+function materialFor(world, state, texture, lit) {
+  const key = `${texture.guid}/${lit === "none" ? "none" : "3d"}`;
+  let ref = state.materials.get(key);
+  if (!ref) {
+    const materials = world.resource(Materials);
+    const material = lit === "none" ? new MaterialAsset({ atlas: texture }, TileUnlit) : new MaterialAsset({ atlas: texture, alphaMode: "mask", alphaCutoff: 0.5 }, TileLit);
+    ref = materials.add(material, `tiles:${key}`);
+    state.materials.set(key, ref);
+  }
+  return ref;
+}
+function buildChunk(map, layerIndex, chunk, texW, texH) {
+  const layer = map.data.layers[layerIndex];
+  const cs = map.chunkSize;
+  const chunksX = Math.ceil(layer.width / cs);
+  const cx = chunk % chunksX;
+  const cy = Math.floor(chunk / chunksX);
+  const [tw, th] = map.tileSize;
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+  const indices = [];
+  let animated = false;
+  const rects = map.atlas.rects;
+  for (let y = cy * cs; y < Math.min((cy + 1) * cs, layer.height); y++) {
+    for (let x = cx * cs; x < Math.min((cx + 1) * cs, layer.width); x++) {
+      const i = y * layer.width + x;
+      const id = layer.tiles[i];
+      if (id === 0) continue;
+      const region = (map.remap[Math.min(id, map.remap.length - 1)] ?? 0) - 1;
+      if (region < 0) continue;
+      if (map.animatedIds.has(id)) animated = true;
+      const u0 = (rects[region * 4] + 0.5) / texW;
+      const v0 = (rects[region * 4 + 1] + 0.5) / texH;
+      const u1 = (rects[region * 4] + rects[region * 4 + 2] - 0.5) / texW;
+      const v1 = (rects[region * 4 + 1] + rects[region * 4 + 3] - 0.5) / texH;
+      const flags = layer.flags[i];
+      const base = positions.length / 3;
+      for (const [ax, ay] of CORNERS) {
+        positions.push((x + ax) * tw, -(y + ay) * th, 0);
+        normals.push(0, 0, 1);
+        let sx = ax;
+        let sy = ay;
+        if (flags & 4) {
+          const r = sx;
+          sx = sy;
+          sy = 1 - r;
+        }
+        if (flags & 1) sx = 1 - sx;
+        if (flags & 2) sy = 1 - sy;
+        uvs.push(u0 + (u1 - u0) * sx, v0 + (v1 - v0) * sy);
+      }
+      indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+    }
+  }
+  if (indices.length === 0) return { mesh: void 0, animated };
+  const vertexCount = positions.length / 3;
+  return {
+    mesh: Mesh.create({
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: vertexCount > 65535 ? new Uint32Array(indices) : new Uint16Array(indices)
+    }),
+    animated
+  };
+}
+const CORNERS = [
+  [0, 0],
+  [1, 0],
+  [1, 1],
+  [0, 1]
+];
+function despawnMap(world, map) {
+  for (const layer of map.layers) {
+    for (const c of layer.chunks.values()) {
+      if (world.isAlive(c.entity)) world.despawn(c.entity);
+      world.resource(Meshes).delete(c.meshRef.guid);
+    }
+  }
+}
+const syncGroundTiles = defineSystem({
+  name: "sprite/ground-tiles",
+  description: "Builds and rebuilds the chunk meshes of tilemaps on the ground (0059).",
+  setup: (world) => ({ q: world.query({ with: [Tilemap, GroundLayer] }) }),
+  // Per frame with nothing edited and no frame turning, this reads columns and allocates nothing.
+  run: ({ q }, world) => {
+    const state = world.resource(GroundTiles);
+    state.frame++;
+    state.chunkUploads = 0;
+    const datas = world.tryResource(TilemapDatas);
+    const atlases = world.tryResource(TextureAtlases);
+    const textures = world.tryResource(Textures);
+    const time = world.tryResource(Time)?.elapsed ?? 0;
+    let seen = 0;
+    for (const table of q.tables) {
+      const dataRefs = table.column(Tilemap, "data");
+      const atlasRefs = table.column(Tilemap, "atlas");
+      const tileSizes = table.column(Tilemap, "tileSize");
+      const chunkSizes = table.column(Tilemap, "chunkSize");
+      const lits = table.column(Tilemap, "lit");
+      const bands = table.column(GroundLayer, "band");
+      const orders = table.column(GroundLayer, "order");
+      const levels = table.column(GroundLayer, "level");
+      const masks = table.has(RenderLayers) ? table.column(RenderLayers, "mask") : void 0;
+      for (let row = 0; row < table.count; row++) {
+        const entity = table.entities[row];
+        const data = datas?.get(dataRefs[row]);
+        const atlas = atlases?.get(atlasRefs[row]);
+        const texture = atlas?.texture ? textures?.get(atlas.texture) : void 0;
+        if (!data || !atlas || !texture || !atlas.texture) continue;
+        const lit = LITS[lits[row]] ?? "2d";
+        const mask = masks ? masks[row] : 1;
+        const tw = tileSizes[row * 2];
+        const th = tileSizes[row * 2 + 1];
+        const chunkSize = chunkSizes[row];
+        const band = bands[row];
+        const order = orders[row];
+        const level = levels[row];
+        let map = state.maps.get(entity);
+        const stale = !map || map.data !== data || map.dataVersion !== data.version || map.atlas !== atlas || map.atlasVersion !== atlas.version || map.chunkSize !== chunkSize || map.tileSize[0] !== tw || map.tileSize[1] !== th || map.lit !== lit || map.band !== band || map.order !== order || map.level !== level || map.mask !== mask;
+        if (stale) {
+          if (map) despawnMap(world, map);
+          const base = resolveTiles(world, data, atlas);
+          map = {
+            data,
+            dataVersion: data.version,
+            atlas,
+            atlasVersion: atlas.version,
+            chunkSize,
+            tileSize: [tw, th],
+            material: materialFor(world, state, atlas.texture, lit),
+            lit,
+            layers: data.layers.map((l) => ({
+              cursor: l.edits.length,
+              base: -1,
+              chunks: /* @__PURE__ */ new Map(),
+              animated: []
+            })),
+            remap: base.slice(),
+            base,
+            paletteLength: data.palette?.length ?? -1,
+            animatedIds: new Set(data.animations.map((a) => a.tile)),
+            band,
+            order,
+            level,
+            mask,
+            seen: 0
+          };
+          state.maps.set(entity, map);
+        }
+        const m = map;
+        m.seen = state.frame;
+        seen++;
+        if ((data.palette?.length ?? -1) !== m.paletteLength) {
+          m.base = resolveTiles(world, data, atlas);
+          m.remap = m.base.slice();
+          m.paletteLength = data.palette?.length ?? -1;
+        }
+        let frameChanged = false;
+        for (let k = 0; k < data.animations.length; k++) {
+          const a = data.animations[k];
+          if (a.frames.length === 0 || a.tile >= m.remap.length) continue;
+          const id = a.frames[Math.floor(time / a.frameTime) % a.frames.length];
+          const region = m.base[Math.min(id, m.base.length - 1)];
+          if (m.remap[a.tile] !== region) {
+            m.remap[a.tile] = region;
+            frameChanged = true;
+          }
+        }
+        for (let li = 0; li < data.layers.length; li++) {
+          const l = data.layers[li];
+          const ls = m.layers[li];
+          if (ls.base === l.editBase && ls.cursor === l.edits.length && !frameChanged) continue;
+          const cs = m.chunkSize;
+          const chunksX = Math.ceil(l.width / cs);
+          const dirty = /* @__PURE__ */ new Set();
+          if (ls.base !== l.editBase) {
+            for (let c = 0; c < chunksX * Math.ceil(l.height / cs); c++) dirty.add(c);
+            ls.base = l.editBase;
+          } else {
+            for (let k = ls.cursor; k < l.edits.length; k++) {
+              const i = l.edits[k];
+              dirty.add(
+                Math.floor(Math.floor(i / l.width) / cs) * chunksX + Math.floor(i % l.width / cs)
+              );
+            }
+          }
+          ls.cursor = l.edits.length;
+          if (frameChanged) for (let k = 0; k < ls.animated.length; k++) dirty.add(ls.animated[k]);
+          for (const c of dirty)
+            rebuild(world, state, entity, m, li, c, texture.width, texture.height);
+        }
+      }
+    }
+    if (seen === state.maps.size) return;
+    for (const [entity, map] of state.maps) {
+      if (map.seen === state.frame) continue;
+      despawnMap(world, map);
+      state.maps.delete(entity);
+    }
+  }
+});
+function rebuild(world, state, tilemap, map, li, c, texW, texH) {
+  const ls = map.layers[li];
+  const existing = ls.chunks.get(c);
+  const built = buildChunk(map, li, c, texW, texH);
+  state.chunkUploads++;
+  const at = ls.animated.indexOf(c);
+  if (built.mesh && built.animated) {
+    if (at === -1) ls.animated.push(c);
+  } else if (at !== -1) ls.animated.splice(at, 1);
+  if (!built.mesh) {
+    if (existing) {
+      if (world.isAlive(existing.entity)) world.despawn(existing.entity);
+      world.resource(Meshes).delete(existing.meshRef.guid);
+      ls.chunks.delete(c);
+    }
+    return;
+  }
+  if (existing && world.isAlive(existing.entity)) {
+    existing.mesh.update(built.mesh.data());
+    return;
+  }
+  const meshRef = world.resource(Meshes).add(built.mesh, `tiles:${tilemap}/${li}/${c}`);
+  const entity = world.spawn(
+    [Mesh3d, { mesh: meshRef }],
+    [MeshMaterial, { material: map.material }],
+    // Layers stack in order within the tilemap's band.
+    [GroundLayer, { band: map.band, order: map.order * 64 + li, level: map.level }],
+    [RenderLayers, { mask: map.mask }],
+    [TileChunk, { tilemap, layer: li, chunk: c }],
+    NotShadowCaster,
+    Derived,
+    Transform,
+    [ChildOf, { parent: tilemap }]
+  );
+  ls.chunks.set(c, { entity, mesh: built.mesh, meshRef });
+}
+function observeGroundTiles(world) {
+  const drop = ({ entity }) => {
+    const state = world.tryResource(GroundTiles);
+    const map = state?.maps.get(entity);
+    if (!map || !state) return;
+    despawnMap(world, map);
+    state.maps.delete(entity);
+  };
+  world.observe(onRemove(Tilemap), drop);
+  world.observe(onRemove(GroundLayer), drop);
+}
+const inverse = affine.create();
+const local = new Float32Array(3);
+function tileDetail(world, hit) {
+  const chunk = world.tryGet(hit.entity, TileChunk);
+  const tilemap = chunk ? chunk.tilemap : hit.entity;
+  const value = world.tryGet(tilemap, Tilemap);
+  const g = world.tryGet(tilemap, GlobalTransform)?.matrix;
+  if (!value || !g) return void 0;
+  const data = world.tryResource(TilemapDatas)?.get(value.data);
+  if (!data || data.layers.length === 0 || !affine.invert(inverse, g)) return void 0;
+  affine.transformPoint(local, inverse, hit.position);
+  const [tw, th] = value.tileSize;
+  const x = Math.floor(local[0] / tw);
+  const y = Math.floor(-local[1] / th);
+  let layer = chunk ? chunk.layer : -1;
+  if (!chunk) {
+    for (let li = data.layers.length - 1; li >= 0; li--) {
+      if (data.layers[li].get(x, y) !== 0) {
+        layer = li;
+        break;
+      }
+    }
+  }
+  const l = data.layers[layer];
+  if (!l || x < 0 || y < 0 || x >= l.width || y >= l.height) return void 0;
+  const atlas = world.tryResource(TextureAtlases)?.get(value.atlas);
+  const id = l.get(x, y);
+  return { kind: "tile", tilemap, layer: l.name, x, y, id, tile: data.tileName(id, atlas) ?? null };
+}
+export {
+  GROUND_TILE_SHADERS,
+  GroundTiles,
+  TileChunk,
+  TileLit,
+  TileUnlit,
+  observeGroundTiles,
+  syncGroundTiles,
+  tileDetail,
+  tilemapOnGround
+};

package/dist/index.d.ts

@@ -1,11 +1,15 @@
 export { AtlasPackImporter, AtlasPackSchema, packImages, packNormals, regionOutline, TextureAtlas, TextureAtlasAssetType, TextureAtlases, TextureAtlasImporter, TextureAtlasSchema, TextureAtlasStore, } from './atlas.js';
 export { animateSprites, CLIP_LOOPS, SpriteAnimation, SpriteAnimationEvent, type SpriteAnimationEventValue, SpriteClip, SpriteClipAssetType, SpriteClipImporter, SpriteClipSchema, SpriteClipStore, SpriteClips, } from './clip.js';
+export { GROUND_TILE_SHADERS, GroundTiles, type GroundTilesState, syncGroundTiles, TileChunk, TileLit, TileUnlit, tileDetail, tilemapOnGround, } from './ground.js';
 export { Lighting2d, LightOccluder2d, layerBit, OCCLUDER_SHAPES, type OccluderShape, PointLight2d, SpotLight2d, SpriteLighting, } from './lighting.js';
 export { binLightsCpu, describeLights2d, LIGHT2D_FLOATS, Lights2d, Lights2dStore, LightView2d, lightCircle, MAX_SHADOWED, OccluderStore, prepareLights2d, SEGMENT_FLOATS, SHADOW_RES, shadowFactorCpu, shadowRowCpu, TILE_MAX, TILE_PIXELS, TILE_STRIDE, } from './lights2d.js';
+export { type EditTilesOptions, editTiles, findTilemapData, type ReadTilesOptions, readTiles, type TileRect, tilemapMethods, } from './methods.js';
 export { boxPolygon, capsulePolygon, circlePolygon, convexHull, occluderSegments, polygonProblem, polygonSegments, spriteOutline, tileChunkEdges, transformSegments, } from './occluders.js';
 export { alphaOutline, distanceToLoop, loopArea, simplifyLoop, traceAlpha } from './outline.js';
 export { spritePlugin } from './plugin.js';
-export { describeSprites, prepareSprites, SPRITE_FLOATS, type SpriteBatch, SpriteStore, Sprites, TilemapStore, Tilemaps, } from './render.js';
+export { describeSprites, prepareSprites, resolveTiles, SPRITE_FLOATS, type SpriteBatch, SpriteStore, Sprites, TilemapStore, Tilemaps, } from './render.js';
 export { SPRITE_SHADERS } from './shaders.js';
 export { SPRITE_BLENDS, SPRITE_SORTS, SPRITE_SPACES, Sprite, Sprite2dSettings, type Sprite2dSettingsValue, SpriteSlot, } from './sprite.js';
-export { setTile, TileFlags, TileLayer, Tilemap, TilemapData, TilemapDataAssetType, TilemapDataImporter, TilemapDataSchema, TilemapDataStore, TilemapDatas, tileAt, } from './tilemap.js';
+export { setTile, TileFlags, TileLayer, Tilemap, TilemapData, TilemapDataAssetType, TilemapDataImporter, TilemapDataSchema, TilemapDataStore, TilemapDatas, tileAt, tilemapToText, tileNames, unknownTiles, } from './tilemap.js';
+export { type CellGrid, chunkRows, readChunkRows, rectRows, rowsCanName, TILE_FLAG_NAMES, type TileEncoding, } from './tilemap-format.js';
+export { validateTilemaps } from './validate.js';