@aethervtt/shard-sprite 0.0.1 → 0.2.0

package/dist/index.js

@@ -23,6 +23,16 @@ import {
   SpriteClipStore,
   SpriteClips
 } from "./clip.js";
+import {
+  GROUND_TILE_SHADERS,
+  GroundTiles,
+  syncGroundTiles,
+  TileChunk,
+  TileLit,
+  TileUnlit,
+  tileDetail,
+  tilemapOnGround
+} from "./ground.js";
 import {
   Lighting2d,
   LightOccluder2d,
@@ -51,6 +61,12 @@ import {
   TILE_PIXELS,
   TILE_STRIDE
 } from "./lights2d.js";
+import {
+  editTiles,
+  findTilemapData,
+  readTiles,
+  tilemapMethods
+} from "./methods.js";
 import {
   boxPolygon,
   capsulePolygon,
@@ -68,6 +84,7 @@ import { spritePlugin } from "./plugin.js";
 import {
   describeSprites,
   prepareSprites,
+  resolveTiles,
   SPRITE_FLOATS,
   SpriteStore,
   Sprites,
@@ -94,12 +111,25 @@ import {
   TilemapDataSchema,
   TilemapDataStore,
   TilemapDatas,
-  tileAt
+  tileAt,
+  tilemapToText,
+  tileNames,
+  unknownTiles
 } from "./tilemap.js";
+import {
+  chunkRows,
+  readChunkRows,
+  rectRows,
+  rowsCanName,
+  TILE_FLAG_NAMES
+} from "./tilemap-format.js";
+import { validateTilemaps } from "./validate.js";
 export {
   AtlasPackImporter,
   AtlasPackSchema,
   CLIP_LOOPS,
+  GROUND_TILE_SHADERS,
+  GroundTiles,
   LIGHT2D_FLOATS,
   LightOccluder2d,
   LightView2d,
@@ -132,6 +162,7 @@ export {
   SpriteSlot,
   SpriteStore,
   Sprites,
+  TILE_FLAG_NAMES,
   TILE_MAX,
   TILE_PIXELS,
   TILE_STRIDE,
@@ -141,8 +172,11 @@ export {
   TextureAtlasSchema,
   TextureAtlasStore,
   TextureAtlases,
+  TileChunk,
   TileFlags,
   TileLayer,
+  TileLit,
+  TileUnlit,
   Tilemap,
   TilemapData,
   TilemapDataAssetType,
@@ -157,11 +191,14 @@ export {
   binLightsCpu,
   boxPolygon,
   capsulePolygon,
+  chunkRows,
   circlePolygon,
   convexHull,
   describeLights2d,
   describeSprites,
   distanceToLoop,
+  editTiles,
+  findTilemapData,
   layerBit,
   lightCircle,
   loopArea,
@@ -172,15 +209,28 @@ export {
   polygonSegments,
   prepareLights2d,
   prepareSprites,
+  readChunkRows,
+  readTiles,
+  rectRows,
   regionOutline,
+  resolveTiles,
+  rowsCanName,
   setTile,
   shadowFactorCpu,
   shadowRowCpu,
   simplifyLoop,
   spriteOutline,
   spritePlugin,
+  syncGroundTiles,
   tileAt,
   tileChunkEdges,
+  tileDetail,
+  tileNames,
+  tilemapMethods,
+  tilemapOnGround,
+  tilemapToText,
   traceAlpha,
-  transformSegments
+  transformSegments,
+  unknownTiles,
+  validateTilemaps
 };

package/dist/lighting-shaders.js

@@ -53,11 +53,11 @@ struct Segment2d {
 import shard::sprite::light2d::types::{ Light2d, Lighting2dView, TILE_PIXELS, TILE_STRIDE, TILE_MAX, SHADOW_RES, COARSE_RES, COARSE_SPAN, TAU, PI };
 
 @group(3) @binding(0) var<uniform> light_view: Lighting2dView;
-@group(3) @binding(1) var<storage, read> lights: array<Light2d>;
-@group(3) @binding(2) var<storage, read> light_tiles: array<u32>;
-@group(3) @binding(3) var<storage, read> shadow_map: array<u32>;
+@data @group(3) @binding(1) var<storage, read> lights: array<Light2d>;
+@data @group(3) @binding(2) var<storage, read> light_tiles: array<u32>;
+@data @group(3) @binding(3) var<storage, read> shadow_map: array<u32>;
 /** Per row, per 32 angles: the nearest and farthest occluder distance. */
-@group(3) @binding(4) var<storage, read> shadow_coarse: array<vec2f>;
+@data @group(3) @binding(4) var<storage, read> shadow_coarse: array<vec2f>;
 
 /** Min and max over the coarse bin holding continuous bin coordinate x. */
 fn coarse_at(row: u32, x: f32) -> vec2f {

package/dist/lights2d.d.ts

@@ -1,6 +1,6 @@
 import { type Entity, type Query, type World } from '@aethervtt/shard-core';
 import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
-import { type NodeDescriptor } from '@aethervtt/shard-render';
+import { DataStore, type NodeDescriptor } from '@aethervtt/shard-render';
 import { type TileLayer } from './tilemap.js';
 /** Floats per light record (see `Light2d` in lighting-shaders.ts). */
 export declare const LIGHT2D_FLOATS = 16;
@@ -20,6 +20,11 @@ export declare const MAX_SHADOWED = 64;
  * reaches the view. Works for any camera: the radius is the larger of the projected x and y offsets.
  */
 export declare function lightCircle(viewProj: ArrayLike<number>, width: number, height: number, x: number, y: number, z: number, r: number, out: Float32Array, o: number): boolean;
+/**
+ * Bins light circles into 16×16-pixel tiles, like the GPU, in its layout: per tile TILE_STRIDE
+ * u32s, the full count, then up to 64 light indices. Allocates nothing.
+ */
+export declare function binLightsInto(circles: Float32Array, count: number, tilesX: number, tilesY: number, out: Uint32Array): void;
 /** Bins light circles into 16×16-pixel tiles, like the GPU: a full count and up to 64 indices. */
 export declare function binLightsCpu(circles: Float32Array, count: number, tilesX: number, tilesY: number): {
     counts: Uint32Array;
@@ -30,6 +35,11 @@ export declare function binLightsCpu(circles: Float32Array, count: number, tiles
  * distance plus its penetration. `segments` holds SEGMENT_FLOATS per segment.
  */
 export declare function shadowRowCpu(lx: number, ly: number, radius: number, layers: number, segments: Float32Array, count: number, out: Float32Array): Float32Array;
+/**
+ * One light's shadow row written into `out` from `at`: shadowRowCpu's math, allocating nothing.
+ * `bits` views `segments` as u32 (their layer masks).
+ */
+export declare function writeShadowRow(lx: number, ly: number, radius: number, layers: number, segments: Float32Array, bits: Uint32Array, count: number, out: Float32Array, at: number): void;
 /** How lit a point is by a shadow row: the fragment shader's `shadow2d`, on the CPU. */
 export declare function shadowFactorCpu(row: Float32Array, softness: number, d: number, toX: number, toY: number): number;
 /** One occluder entity's segments, cached in world space until it changes. */
@@ -117,17 +127,23 @@ export declare class LightView2d {
     constructor(name: string);
     ensureLights(n: number): void;
     ensureSegments(n: number): void;
-    /** Uploads what changed. Segments go up only when the selection or an occluder changed. */
+    /**
+     * Uploads what changed. Segments go up only when the selection or an occluder changed. On
+     * baseline the tiles, shadow rows and coarse bins are made here on the CPU (baseline/lights2d.ts).
+     */
     upload(gpu: GpuContext, segmentKey: number): void;
 }
-interface ViewGpu {
+/** Loads the baseline tier's CPU lighting (0064), once: the sprite plugin does, on a baseline device. */
+export declare function loadBaselineLighting(): Promise<void>;
+export interface ViewGpu {
     generation: number;
     uniform: GpuBuffer;
-    lights: GpuBuffer;
+    /** What the fragment stage reads: storage on the full tier, data textures on baseline (0064). */
+    lights: DataStore;
     circles: GpuBuffer;
-    tiles: GpuBuffer;
-    shadowMap: GpuBuffer;
-    shadowCoarse: GpuBuffer;
+    tiles: DataStore;
+    shadowMap: DataStore;
+    shadowCoarse: DataStore;
     segments: GpuBuffer;
     shadowed: GpuBuffer;
     computeGroup?: {

package/dist/lights2d.js

@@ -9,6 +9,8 @@ import { GpuBuffer } from "@aethervtt/shard-gpu";
 import {
   Cameras,
   ComputedVisibility,
+  DataStore,
+  dataEntry,
   defineOverlay,
   Gpu,
   RenderPhase,
@@ -59,30 +61,50 @@ function lightCircle(viewProj, width, height, x, y, z, r, out, o) {
   out[o + 3] = 0;
   return px + rp > 0 && px - rp < width && py + rp > 0 && py - rp < height;
 }
-function binLightsCpu(circles, count, tilesX, tilesY) {
-  const counts = new Uint32Array(tilesX * tilesY);
-  const indices = new Uint32Array(tilesX * tilesY * TILE_MAX);
-  for (let t = 0; t < tilesX * tilesY; t++) {
-    const lx = t % tilesX * TILE_PIXELS;
-    const ly = Math.floor(t / tilesX) * TILE_PIXELS;
-    let n = 0;
-    for (let i = 0; i < count; i++) {
-      const cx = circles[i * 4];
-      const cy = circles[i * 4 + 1];
-      const r = circles[i * 4 + 2];
-      const qx = Math.min(Math.max(cx, lx), lx + TILE_PIXELS) - cx;
+function binLightsInto(circles, count, tilesX, tilesY, out) {
+  for (let t = 0; t < tilesX * tilesY; t++) out[t * TILE_STRIDE] = 0;
+  for (let i = 0; i < count; i++) {
+    const cx = circles[i * 4];
+    const cy = circles[i * 4 + 1];
+    const r = circles[i * 4 + 2];
+    const x0 = Math.max(0, Math.floor((cx - r) / TILE_PIXELS) - 1);
+    const x1 = Math.min(tilesX - 1, Math.floor((cx + r) / TILE_PIXELS));
+    const y0 = Math.max(0, Math.floor((cy - r) / TILE_PIXELS) - 1);
+    const y1 = Math.min(tilesY - 1, Math.floor((cy + r) / TILE_PIXELS));
+    for (let ty = y0; ty <= y1; ty++) {
+      const ly = ty * TILE_PIXELS;
       const qy = Math.min(Math.max(cy, ly), ly + TILE_PIXELS) - cy;
-      if (qx * qx + qy * qy > r * r) continue;
-      if (n < TILE_MAX) indices[t * TILE_MAX + n] = i;
-      n++;
+      for (let tx = x0; tx <= x1; tx++) {
+        const lx = tx * TILE_PIXELS;
+        const qx = Math.min(Math.max(cx, lx), lx + TILE_PIXELS) - cx;
+        if (qx * qx + qy * qy > r * r) continue;
+        const base = (ty * tilesX + tx) * TILE_STRIDE;
+        const n = out[base];
+        if (n < TILE_MAX) out[base + 1 + n] = i;
+        out[base] = n + 1;
+      }
     }
-    counts[t] = n;
+  }
+}
+function binLightsCpu(circles, count, tilesX, tilesY) {
+  const tiles = tilesX * tilesY;
+  const packed = new Uint32Array(tiles * TILE_STRIDE);
+  binLightsInto(circles, count, tilesX, tilesY, packed);
+  const counts = new Uint32Array(tiles);
+  const indices = new Uint32Array(tiles * TILE_MAX);
+  for (let t = 0; t < tiles; t++) {
+    counts[t] = packed[t * TILE_STRIDE];
+    indices.set(packed.subarray(t * TILE_STRIDE + 1, (t + 1) * TILE_STRIDE), t * TILE_MAX);
   }
   return { counts, indices };
 }
 function shadowRowCpu(lx, ly, radius, layers, segments, count, out) {
-  out.fill(FAR, 0, SHADOW_RES);
   const bits = new Uint32Array(segments.buffer, segments.byteOffset, segments.length);
+  writeShadowRow(lx, ly, radius, layers, segments, bits, count, out, 0);
+  return out;
+}
+function writeShadowRow(lx, ly, radius, layers, segments, bits, count, out, at) {
+  out.fill(FAR, at, at + SHADOW_RES);
   const step = Math.PI * 2 / SHADOW_RES;
   for (let s = 0; s < count; s++) {
     const o = s * SEGMENT_FLOATS;
@@ -118,12 +140,11 @@ function shadowRowCpu(lx, ly, radius, layers, segments, count, out) {
       if (Math.abs(den) < 1e-12) continue;
       const t = (ax * ey - ay * ex) / den;
       if (t <= 0) continue;
-      const w = (k % SHADOW_RES + SHADOW_RES) % SHADOW_RES;
+      const w = at + (k % SHADOW_RES + SHADOW_RES) % SHADOW_RES;
       const v = Math.fround(t + pen);
       if (v < out[w]) out[w] = v;
     }
   }
-  return out;
 }
 function shadowFactorCpu(row, softness, d, toX, toY) {
   const step = Math.PI * 2 / SHADOW_RES;
@@ -441,7 +462,10 @@ class LightView2d {
     this.segments = s;
     this.segmentBits = new Uint32Array(s.buffer);
   }
-  /** Uploads what changed. Segments go up only when the selection or an occluder changed. */
+  /**
+   * Uploads what changed. Segments go up only when the selection or an occluder changed. On
+   * baseline the tiles, shadow rows and coarse bins are made here on the CPU (baseline/lights2d.ts).
+   */
   upload(gpu, segmentKey) {
     let g = this.gpu;
     if (!g || g.generation !== gpu.generation) g = this.gpu = createViewGpu(gpu, this.name);
@@ -469,21 +493,28 @@ class LightView2d {
       g.segments.write(this.segments, 0, 0, this.segmentCount * SEGMENT_FLOATS);
       bytes += this.segmentCount * SEGMENT_FLOATS * 4;
     }
+    if (baseline && gpu.tier === "baseline")
+      bytes += baseline.lightOnCpu(this, g, segmentKey !== this.segmentKey);
     this.segmentKey = segmentKey;
     this.uploadedBytes = bytes;
   }
 }
+let baseline;
+async function loadBaselineLighting() {
+  baseline ??= await import("./baseline/lights2d.js");
+}
 function createViewGpu(gpu, name) {
   const storage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC;
   const buffer = (label, size, usage = storage) => new GpuBuffer(gpu, { label: `${name}/lights2d/${label}`, usage, size });
+  const data = (label, size) => new DataStore(gpu, { label: `${name}/lights2d/${label}`, usage: GPUBufferUsage.COPY_SRC, size });
   return {
     generation: gpu.generation,
     uniform: buffer("view", 48, GPUBufferUsage.UNIFORM),
-    lights: buffer("lights", LIGHT2D_FLOATS * 4 * 64),
+    lights: data("lights", LIGHT2D_FLOATS * 4 * 64),
     circles: buffer("circles", 16 * 64),
-    tiles: buffer("tiles", TILE_STRIDE * 4 * 1024),
-    shadowMap: buffer("shadow-map", SHADOW_RES * 4 * 4),
-    shadowCoarse: buffer("shadow-coarse", COARSE_RES * 8 * 4),
+    tiles: data("tiles", TILE_STRIDE * 4 * 1024),
+    shadowMap: data("shadow-map", SHADOW_RES * 4 * 4),
+    shadowCoarse: data("shadow-coarse", COARSE_RES * 8 * 4),
     segments: buffer("segments", SEGMENT_FLOATS * 4 * 256),
     shadowed: buffer("shadowed", MAX_SHADOWED * 4)
   };
@@ -825,10 +856,10 @@ function layoutsOf(gpu) {
       label: "lights2d/shade",
       entries: [
         { binding: 0, visibility: F, buffer: { type: "uniform" } },
-        { binding: 1, visibility: F, buffer: read },
-        { binding: 2, visibility: F, buffer: read },
-        { binding: 3, visibility: F, buffer: read },
-        { binding: 4, visibility: F, buffer: read }
+        dataEntry(gpu, 1, F),
+        dataEntry(gpu, 2, F),
+        dataEntry(gpu, 3, F),
+        dataEntry(gpu, 4, F)
       ]
     }),
     pipelines: /* @__PURE__ */ new Map()
@@ -855,7 +886,7 @@ function litView(world, view) {
 }
 function lights2dGroup(gpu, view) {
   const g = view.gpu;
-  const key = `${idOf(g.uniform.buffer)}/${idOf(g.lights.buffer)}/${idOf(g.tiles.buffer)}/${idOf(g.shadowMap.buffer)}/${idOf(g.shadowCoarse.buffer)}`;
+  const key = `${idOf(g.uniform.buffer)}/${dataKey(g.lights)}/${dataKey(g.tiles)}/${dataKey(g.shadowMap)}/${dataKey(g.shadowCoarse)}`;
   if (!g.renderGroup || g.renderGroup.key !== key) {
     g.renderGroup = {
       key,
@@ -864,16 +895,19 @@ function lights2dGroup(gpu, view) {
         layout: layoutsOf(gpu).render,
         entries: [
           { binding: 0, resource: { buffer: g.uniform.buffer } },
-          { binding: 1, resource: { buffer: g.lights.buffer } },
-          { binding: 2, resource: { buffer: g.tiles.buffer } },
-          { binding: 3, resource: { buffer: g.shadowMap.buffer } },
-          { binding: 4, resource: { buffer: g.shadowCoarse.buffer } }
+          { binding: 1, resource: g.lights.resource() },
+          { binding: 2, resource: g.tiles.resource() },
+          { binding: 3, resource: g.shadowMap.resource() },
+          { binding: 4, resource: g.shadowCoarse.resource() }
         ]
       })
     };
   }
   return g.renderGroup.group;
 }
+function dataKey(d) {
+  return `${idOf(d)}:${d.version}`;
+}
 function computePipeline(ctx, entry) {
   const gpu = ctx.gpu;
   const s = layoutsOf(gpu);
@@ -896,7 +930,8 @@ function lights2dNode(world) {
   return {
     kind: "compute",
     phase: RenderPhase.Sprites - 10,
-    enabled: (view) => litView(world, view.name) !== void 0,
+    // Compute is the full tier's: baseline lights on the CPU as it uploads (LightView2d.upload).
+    enabled: (view) => litView(world, view.name) !== void 0 && world.resource(Gpu).tier === "full",
     writes: ["lights2d"],
     run: (ctx) => {
       const view = litView(ctx.world, ctx.view.name);
@@ -907,7 +942,7 @@ function lights2dNode(world) {
       const coarse = computePipeline(ctx, "coarse");
       if (!bin || !clear || !shadows || !coarse) return;
       const g = view.gpu;
-      const key = `${idOf(g.uniform.buffer)}/${idOf(g.lights.buffer)}/${idOf(g.circles.buffer)}/${idOf(g.tiles.buffer)}/${idOf(g.shadowMap.buffer)}/${idOf(g.segments.buffer)}/${idOf(g.shadowed.buffer)}/${idOf(g.shadowCoarse.buffer)}`;
+      const key = `${idOf(g.uniform.buffer)}/${idOf(g.lights.gpuBuffer)}/${idOf(g.circles.buffer)}/${idOf(g.tiles.gpuBuffer)}/${idOf(g.shadowMap.gpuBuffer)}/${idOf(g.segments.buffer)}/${idOf(g.shadowed.buffer)}/${idOf(g.shadowCoarse.gpuBuffer)}`;
       if (!g.computeGroup || g.computeGroup.key !== key) {
         g.computeGroup = {
           key,
@@ -916,13 +951,13 @@ function lights2dNode(world) {
             layout: layoutsOf(ctx.gpu).compute,
             entries: [
               { binding: 0, resource: { buffer: g.uniform.buffer } },
-              { binding: 1, resource: { buffer: g.lights.buffer } },
+              { binding: 1, resource: { buffer: g.lights.gpuBuffer } },
               { binding: 2, resource: { buffer: g.circles.buffer } },
-              { binding: 3, resource: { buffer: g.tiles.buffer } },
-              { binding: 4, resource: { buffer: g.shadowMap.buffer } },
+              { binding: 3, resource: { buffer: g.tiles.gpuBuffer } },
+              { binding: 4, resource: { buffer: g.shadowMap.gpuBuffer } },
               { binding: 5, resource: { buffer: g.segments.buffer } },
               { binding: 6, resource: { buffer: g.shadowed.buffer } },
-              { binding: 7, resource: { buffer: g.shadowCoarse.buffer } }
+              { binding: 7, resource: { buffer: g.shadowCoarse.gpuBuffer } }
             ]
           })
         };
@@ -1080,6 +1115,7 @@ export {
   TILE_PIXELS,
   TILE_STRIDE,
   binLightsCpu,
+  binLightsInto,
   describeLights2d,
   lightCircle,
   lights2dGroup,
@@ -1087,7 +1123,9 @@ export {
   lights2dNode,
   lights2dOverlay,
   litView,
+  loadBaselineLighting,
   prepareLights2d,
   shadowFactorCpu,
-  shadowRowCpu
+  shadowRowCpu,
+  writeShadowRow
 };

package/dist/methods.d.ts

@@ -0,0 +1,82 @@
+import { type World } from '@aethervtt/shard-core';
+import type { AppMethod } from '@aethervtt/shard-runtime';
+import { type TextureAtlas } from './atlas.js';
+import { TilemapData } from './tilemap.js';
+export interface TileRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface ReadTilesOptions {
+    /** Layer name (default: the first). */
+    layer?: string;
+    /** Just this chunk ([cx, cy], in the data's chunkSize). */
+    chunk?: readonly number[];
+    /** Just this rect. */
+    rect?: TileRect;
+}
+export interface EditTilesOptions {
+    layer?: string;
+    /** Cells to set: tile by palette name ('.' clears), flags as "fx+r90". */
+    cells?: readonly {
+        x: number;
+        y: number;
+        tile: string;
+        flags?: string | number;
+    }[];
+    /** A rect filled with one tile. */
+    fill?: {
+        rect: TileRect;
+        tile: string;
+    };
+    /** One chunk's cells replaced by rows, as readTiles gives them. */
+    rows?: {
+        chunk: readonly number[];
+        rows: readonly string[];
+    };
+}
+/**
+ * A layer's cells as rows: all non-empty chunks (keyed "cx,cy"), one chunk, or a rect. Version 1
+ * maps name their tiles through the atlas.
+ */
+export declare function readTiles(data: TilemapData, options?: ReadTilesOptions, atlas?: {
+    names: readonly string[];
+}): {
+    layer: string;
+    width: number;
+    height: number;
+    chunkSize: number;
+    encoding: import("./tilemap-format.js").TileEncoding;
+    rect: TileRect;
+    rows: string[];
+} | {
+    layer: string;
+    width: number;
+    height: number;
+    chunkSize: number;
+    encoding: import("./tilemap-format.js").TileEncoding;
+    chunk: number[];
+    rows: string[];
+} | {
+    layer: string;
+    width: number;
+    height: number;
+    chunkSize: number;
+    encoding: import("./tilemap-format.js").TileEncoding;
+    chunks: Record<string, string[]>;
+};
+/**
+ * Applies cell edits through TileLayer.set, so renderers re-upload only the touched chunks.
+ * Returns how many cells changed. A version 1 map first gets a palette of the atlas's names.
+ */
+export declare function editTiles(data: TilemapData, options: EditTilesOptions, atlas?: {
+    names: readonly string[];
+}): number;
+/** A loaded tilemap data asset, and the atlas of a Tilemap drawing it (for version 1 names). */
+export declare function findTilemapData(world: World, asset: string): {
+    data: TilemapData;
+    guid: string | undefined;
+    atlas: TextureAtlas | undefined;
+};
+export declare const tilemapMethods: AppMethod[];