@aethervtt/shard-structure 0.0.0-stage → 0.2.0

package/dist/fixtures.js

@@ -0,0 +1,327 @@
+import { ChildOf } from "@aethervtt/shard-core";
+import { cylinder, sphere } from "@aethervtt/shard-mesh";
+import { createMirror } from "@aethervtt/shard-mirror";
+import {
+  GpuAssetsResource,
+  MaterialAsset,
+  Materials,
+  Mesh3d,
+  Meshes,
+  MeshMaterial
+} from "@aethervtt/shard-render";
+import { packMetallicRoughness, Texture, Textures } from "@aethervtt/shard-texture";
+import { Transform } from "@aethervtt/shard-transform";
+import {
+  LIMITS,
+  maxScene,
+  shadowStress
+} from "../fixtures/structure/index.mjs";
+import { Floor, Opening, Wall } from "./components.js";
+const PX_TO_WORLD = 1.5 / 70;
+function linear(hex) {
+  const c = (i) => {
+    const v = Number.parseInt(hex.slice(1 + i * 2, 3 + i * 2), 16) / 255;
+    return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  };
+  return [c(0), c(1), c(2), 1];
+}
+function sceneMaterialValue(doc, pxToWorld, texture, packed = null) {
+  const repeat = doc.repeat ?? { x: 1 / pxToWorld, y: 1 / pxToWorld };
+  const slot = (ref) => ref && {
+    texture: ref,
+    scale: [1 / (repeat.x * pxToWorld), 1 / (repeat.y * pxToWorld)],
+    rotation: (doc.rotation ?? 0) * Math.PI / 180,
+    wrap: doc.wrap === "mirrored-repeat" ? "mirror" : "repeat"
+  };
+  const value = {
+    baseColor: linear(doc.tint),
+    roughness: doc.roughness,
+    metallic: doc.metalness ?? 0
+  };
+  const base = doc.baseColorTexture ? texture(doc.baseColorTexture, "color") : null;
+  if (base) value.baseColorTexture = slot(base);
+  const normal = doc.normal ? texture(doc.normal.texture, "normal") : null;
+  if (normal) {
+    value.normalTexture = slot(normal);
+    value.normalScale = doc.normal.strength;
+  }
+  const ao = doc.ambientOcclusion ? texture(doc.ambientOcclusion.texture, "data") : null;
+  if (ao) {
+    value.occlusionTexture = slot(ao);
+    value.occlusionStrength = doc.ambientOcclusion.strength;
+  }
+  if (packed) value.metallicRoughnessTexture = slot(packed);
+  return value;
+}
+class HostScene {
+  world;
+  k;
+  materials;
+  walls;
+  openings;
+  floors;
+  props;
+  tokens;
+  /** Token root → its disc. */
+  discs = /* @__PURE__ */ new Map();
+  grid;
+  materialRefs = /* @__PURE__ */ new Map();
+  propMeshes = /* @__PURE__ */ new Map();
+  tokenDocs = /* @__PURE__ */ new Map();
+  propDocs = /* @__PURE__ */ new Map();
+  discMesh;
+  tokenMaterial;
+  /** Textures made from the host's images, by ref and use. */
+  textureRefs = /* @__PURE__ */ new Map();
+  images;
+  constructor(world, pxToWorld = PX_TO_WORLD, images) {
+    this.world = world;
+    this.k = pxToWorld;
+    this.images = images;
+    const k = pxToWorld;
+    const rev = (d) => d.rev;
+    const id = (d) => d.id;
+    this.materials = createMirror(world, {
+      key: id,
+      rev,
+      spawn: (doc) => {
+        const ref = world.resource(Materials).add(new MaterialAsset({}), `host:material/${doc.id}`);
+        this.materialRefs.set(doc.id, ref);
+        return world.spawn();
+      },
+      apply: (_e, doc) => {
+        const ref = this.materialRefs.get(doc.id);
+        world.resource(Materials).get(ref)?.set(this.materialValue(doc));
+      },
+      despawn: (e, w, key) => {
+        const ref = this.materialRefs.get(key);
+        if (ref) {
+          const material = w.resource(Materials).get(ref);
+          if (material) w.tryResource(GpuAssetsResource)?.releaseMaterial(material);
+          w.resource(Materials).delete(ref.guid);
+          this.materialRefs.delete(key);
+        }
+        w.despawn(e);
+      }
+    });
+    this.walls = createMirror(world, {
+      key: id,
+      rev,
+      spawn: () => world.spawn(Wall),
+      apply: (e, d) => world.set(e, Wall, {
+        a: [d.a.x * k, d.a.y * k],
+        b: [d.b.x * k, d.b.y * k],
+        shape: d.curve?.kind ?? "straight",
+        bow: d.curve?.kind === "arc" ? d.curve.bow * k : 0,
+        c0: d.curve?.kind === "bezier" ? [d.curve.c0.x * k, d.curve.c0.y * k] : [0, 0],
+        c1: d.curve?.kind === "bezier" ? [d.curve.c1.x * k, d.curve.c1.y * k] : [0, 0],
+        height: d.height * k,
+        thickness: d.thickness * k,
+        elevation: d.elevation * k,
+        material: this.materialRefs.get(d.materialId) ?? null
+      })
+    });
+    this.openings = createMirror(world, {
+      key: id,
+      rev,
+      spawn: () => world.spawn(Opening),
+      apply: (e, d) => world.set(e, Opening, {
+        wall: this.walls.entity(d.hostWallId) ?? null,
+        kind: d.kind,
+        offset: d.offset * k,
+        width: d.width * k,
+        height: d.height * k,
+        sill: d.sill * k,
+        frameWidth: d.frameWidth * k,
+        frameDepth: d.frameDepth * k,
+        frameMaterial: d.frameMaterialId ? this.materialRefs.get(d.frameMaterialId) ?? null : null,
+        hinge: d.hinge ?? "start",
+        swing: d.swing ?? "left",
+        state: d.state ?? "closed",
+        sight: d.sight,
+        movement: d.movement
+      })
+    });
+    this.floors = createMirror(world, {
+      key: id,
+      rev,
+      spawn: () => world.spawn(Floor),
+      apply: (e, d) => world.set(e, Floor, {
+        points: d.points.map((p) => [p.x * k, p.y * k]),
+        elevation: d.elevation * k,
+        material: d.surface.kind === "material" ? this.materialRefs.get(d.surface.materialId) ?? null : null
+      })
+    });
+    this.props = createMirror(world, {
+      key: id,
+      rev,
+      spawn: (d) => world.spawn(
+        [Mesh3d, { mesh: this.propMesh(d.asset) }],
+        [MeshMaterial, { material: this.materialRefs.values().next().value ?? null }],
+        Transform
+      ),
+      apply: (e, d) => {
+        this.propDocs.set(e, d);
+        this.placeProp(e, d);
+      },
+      despawn: (e) => {
+        this.propDocs.delete(e);
+        world.despawn(e);
+      }
+    });
+    this.tokens = createMirror(world, {
+      key: id,
+      rev,
+      spawn: () => {
+        const root = world.spawn(Transform);
+        const disc = world.spawn(
+          [Mesh3d, { mesh: this.disc() }],
+          [MeshMaterial, { material: this.tokenMat() }],
+          Transform,
+          [ChildOf, { parent: root }]
+        );
+        this.discs.set(root, disc);
+        return root;
+      },
+      apply: (e, d) => {
+        this.tokenDocs.set(e, d);
+        world.set(e, Transform, { translation: [d.x * k, 0, d.y * k] });
+        this.sizeToken(e, d);
+      },
+      despawn: (e) => {
+        this.discs.delete(e);
+        this.tokenDocs.delete(e);
+        world.despawn(e);
+      }
+    });
+  }
+  /** A scene material's value: its textures made from the host's images on first use. */
+  materialValue(doc) {
+    const texture = (ref, usage) => {
+      const key = `${usage}:${ref}`;
+      let t = this.textureRefs.get(key);
+      if (!t) {
+        const image = this.images?.(ref);
+        if (!image) return null;
+        t = this.world.resource(Textures).add(
+          Texture.create({
+            width: image.width,
+            height: image.height,
+            usage,
+            mips: [image.data],
+            mipmaps: true
+          }),
+          `host:texture/${key}`
+        );
+        this.textureRefs.set(key, t);
+      }
+      return t;
+    };
+    let packed = null;
+    if (doc.roughnessTexture || doc.metalnessTexture) {
+      const key = `mr:${doc.roughnessTexture ?? ""}:${doc.metalnessTexture ?? ""}`;
+      packed = this.textureRefs.get(key) ?? null;
+      if (!packed) {
+        const r = doc.roughnessTexture ? this.images?.(doc.roughnessTexture) : void 0;
+        const m = doc.metalnessTexture ? this.images?.(doc.metalnessTexture) : void 0;
+        if (r || m) {
+          packed = this.world.resource(Textures).add(packMetallicRoughness(r, m), `host:texture/${key}`);
+          this.textureRefs.set(key, packed);
+        }
+      }
+    }
+    return sceneMaterialValue(doc, this.k, texture, packed);
+  }
+  /** World size of one grid cell: the grid's pixel size through the visual scale. */
+  get cell() {
+    return (this.grid?.size ?? 70) * this.k;
+  }
+  /**
+   * Applies a full host state. Only documents whose revision changed are applied. A grid whose
+   * pixel size changed resizes cell-sized things (token footprints, props); its game distance,
+   * unit and diagonal rule place nothing.
+   */
+  sync(docs) {
+    const counts = { spawned: 0, applied: 0, removed: 0, resized: 0 };
+    const add = (c) => {
+      counts.spawned += c.spawned;
+      counts.applied += c.applied;
+      counts.removed += c.removed;
+    };
+    const resize = this.grid !== void 0 && this.grid.size !== docs.grid.size;
+    this.grid = docs.grid;
+    add(this.materials.sync(docs.materials));
+    add(this.walls.sync(docs.walls));
+    add(this.openings.sync(docs.openings));
+    add(this.floors.sync(docs.floors));
+    add(this.props.sync(docs.props));
+    add(this.tokens.sync(docs.tokens));
+    if (resize) {
+      for (const [e, d] of this.tokenDocs) this.sizeToken(e, d);
+      for (const [e, d] of this.propDocs) this.placeProp(e, d);
+      counts.resized = this.tokenDocs.size + this.propDocs.size;
+    }
+    return counts;
+  }
+  sizeToken(root, d) {
+    const disc = this.discs.get(root);
+    const footprint = d.size * this.cell * 0.9;
+    this.world.set(disc, Transform, {
+      translation: [0, 0.03, 0],
+      scale: [footprint, 0.06, footprint]
+    });
+  }
+  placeProp(e, d) {
+    const size = d.cells * this.cell;
+    const a = d.rotation * Math.PI / 360;
+    this.world.set(e, Transform, {
+      translation: [d.x * this.k, size / 2, d.y * this.k],
+      rotation: [0, Math.sin(a), 0, Math.cos(a)],
+      scale: [size, size, size]
+    });
+  }
+  disc() {
+    this.discMesh ??= this.world.resource(Meshes).add(
+      cylinder({ radius: 0.5, height: 1, segments: 32 }),
+      "host:token-disc"
+    );
+    return this.discMesh;
+  }
+  tokenMat() {
+    this.tokenMaterial ??= this.world.resource(Materials).add(
+      new MaterialAsset({ baseColor: [0.75, 0.2, 0.15, 1], roughness: 0.5 }),
+      "host:token"
+    );
+    return this.tokenMaterial;
+  }
+  /**
+   * One mesh per prop asset: spheres of about 1,950 triangles, so 256 props come to Aether's
+   * 500k prop triangles.
+   */
+  propMesh(asset) {
+    let ref = this.propMeshes.get(asset);
+    if (!ref) {
+      const n = Number.parseInt(asset.slice(asset.lastIndexOf("-") + 1), 10) || 0;
+      const segments = 31 + n % 3;
+      const mesh = sphere({ radius: 0.5, segments, rings: segments });
+      ref = this.world.resource(Meshes).add(mesh, `host:prop/${asset}`);
+      this.propMeshes.set(asset, ref);
+    }
+    return ref;
+  }
+}
+function hostScene(world, pxToWorld = PX_TO_WORLD, images) {
+  return new HostScene(world, pxToWorld, images);
+}
+import { brickMaterial, brickTextures } from "./bricks.js";
+export {
+  HostScene,
+  LIMITS,
+  PX_TO_WORLD,
+  brickMaterial,
+  brickTextures,
+  hostScene,
+  maxScene,
+  sceneMaterialValue,
+  shadowStress
+};

package/dist/geometry.d.ts

@@ -0,0 +1,178 @@
+import { type Centerline } from './curve.js';
+/** A wall in world units: a centreline in the XZ plane, extruded up from `elevation`. */
+export interface WallShape {
+    ax: number;
+    az: number;
+    bx: number;
+    bz: number;
+    height: number;
+    thickness: number;
+    elevation: number;
+    /** The sampled centreline (two samples for a straight wall). */
+    line: Centerline;
+}
+/** An opening along its host wall, in world units of arc length from the wall's start. */
+export interface OpeningShape {
+    kind: 'door' | 'window';
+    offset: number;
+    width: number;
+    height: number;
+    sill: number;
+    frameWidth: number;
+    frameDepth: number;
+}
+/**
+ * A box along a wall: `[s0, s1]` of arc length along it, `[y0, y1]` up, `half` either side of the
+ * centreline. Caps are the faces at s0 and s1; a piece that continues into another has none there.
+ */
+export interface Piece {
+    s0: number;
+    s1: number;
+    y0: number;
+    y1: number;
+    half: number;
+    capStart: boolean;
+    capEnd: boolean;
+    /** Whether the underside shows (a lintel over a door; not a wall standing on the floor). */
+    bottom: boolean;
+    /** A door or window frame, drawn with the opening's frame material. */
+    frame: boolean;
+    /** Index of the opening (in the list passed to `wallPieces`) this piece frames; -1 for wall. */
+    source: number;
+}
+/** Length of a wall's centreline (its arc length when curved). */
+export declare function wallLength(w: WallShape): number;
+/**
+ * Splits a wall around its openings (sorted by offset) into pieces: solid spans at full height,
+ * the wall below a window's sill and above an opening's head, and frame boxes. Returns the count
+ * written to `out` (entries are reused).
+ */
+export declare function wallPieces(w: WallShape, openings: readonly OpeningShape[], out: Piece[]): number;
+/** A chunk's key from its integer coordinates (each in ±32,767). */
+export declare function chunkKey(cx: number, cz: number): number;
+export declare function chunkX(key: number): number;
+export declare function chunkZ(key: number): number;
+/** Scratch for clipping: footprint quads, clipped to at most 8 points, with arc lengths. */
+export declare class ClipScratch {
+    readonly a: Float64Array<ArrayBuffer>;
+    readonly b: Float64Array<ArrayBuffer>;
+    readonly la: Int8Array<ArrayBuffer>;
+    readonly lb: Int8Array<ArrayBuffer>;
+    /** Arc length at each point. */
+    readonly sa: Float64Array<ArrayBuffer>;
+    readonly sb: Float64Array<ArrayBuffer>;
+    readonly tri: Float64Array<ArrayBuffer>;
+    /** A centreline point and normal (pointAt). */
+    readonly at: Float64Array<ArrayBuffer>;
+    /** The quad boundaries of the piece being walked: arc lengths. */
+    bounds: Float64Array<ArrayBuffer>;
+}
+/**
+ * Adds the keys of every chunk a wall's pieces overlap to `out` (a piece touching a chunk's edge
+ * without area in it doesn't count). The same quads and test decide what each chunk draws.
+ */
+export declare function wallChunks(w: WallShape, pieces: readonly Piece[], count: number, size: number, out: Set<number>, s: ClipScratch): void;
+/** Grows as vertices are added; `reset` keeps its memory. */
+export declare class MeshBuilder {
+    positions: Float32Array<ArrayBuffer>;
+    normals: Float32Array<ArrayBuffer>;
+    uvs: Float32Array<ArrayBuffer>;
+    tangents: Float32Array<ArrayBuffer>;
+    indices: Uint32Array<ArrayBuffer>;
+    vertexCount: number;
+    indexCount: number;
+    /** Local-space bounds of what was added. */
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+    reset(): void;
+    /** A vertex: position, normal, uv, and the tangent along u with its bitangent sign. */
+    vertex(x: number, y: number, z: number, nx: number, ny: number, nz: number, u: number, v: number, tx: number, ty: number, tz: number, tw: number): number;
+    triangle(a: number, b: number, c: number): void;
+    private growVertices;
+    /**
+     * A convex planar polygon as a fan, wound so its front faces along (nx, ny, nz). `first` is the
+     * index of its first vertex; the rest follow.
+     */
+    fan(first: number, count: number, nx: number, ny: number, nz: number): void;
+}
+/**
+ * Emits the parts of a wall's pieces inside one chunk square: tops, undersides where they show,
+ * the long sides, and caps at the wall's ends and around openings. Faces along the chunk's
+ * edges, and between the quads of a curve, are left open. `builder(i)` is where piece i goes (by
+ * its material). Returns whether anything was emitted.
+ */
+export declare function emitWall(w: WallShape, pieces: readonly Piece[], count: number, minX: number, minZ: number, maxX: number, maxZ: number, builder: (piece: number) => MeshBuilder, s: ClipScratch): boolean;
+/** A hole's frame (0067): a band `width` wide around ring `ring`, standing `depth` above the surface. */
+export interface SlabFrame {
+    ring: number;
+    width: number;
+    depth: number;
+}
+export interface SlabOptions {
+    /** Holes, each a simple polygon inside the outline, either winding. */
+    holes?: readonly ArrayLike<ArrayLike<number>>[];
+    /** Frames around holes (`ring` 1 is the first hole). */
+    frames?: readonly SlabFrame[];
+    thickness?: number;
+    /** Degrees: 0 is flat; more is one slope rising along `ridge` from the outline's lowest point. */
+    pitch?: number;
+    /** The direction the slope rises, (x, z). */
+    ridge?: ArrayLike<number>;
+}
+/** A floor or roof ready to clip: its rings, triangles and frames, computed once per edit. */
+export interface FloorShape {
+    /** Flat (x, z) pairs: the outline, then each hole. */
+    points: Float64Array;
+    /** Where each ring starts, in points, then the total: ring r is `rings[r]` to `rings[r + 1]`. */
+    rings: Uint32Array;
+    /** Per ring, the sign that turns an edge's left normal into the one pointing out of the slab. */
+    sides: Int8Array;
+    /** Three vertex indices per triangle. */
+    triangles: Uint32Array;
+    /** The surface's height at its lowest point: y = elevation + slope × (x·rx + z·rz − d0). */
+    elevation: number;
+    slope: number;
+    rx: number;
+    rz: number;
+    d0: number;
+    thickness: number;
+    frames: readonly SlabFrame[];
+    /** Each framed ring's points offset onto the slab by its frame's width (indexed as points). */
+    frameOuter: Float64Array;
+    /** Bounds of everything it draws (the outline and frames). */
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+}
+/** The surface height of a slab at (x, z). */
+export declare function slabY(f: FloorShape, x: number, z: number): number;
+/**
+ * Triangulates a slab: an outline (a simple polygon, either winding) with holes, and the frames
+ * around them.
+ */
+export declare function floorShape(points: ArrayLike<ArrayLike<number>>, elevation: number, options?: SlabOptions): FloorShape;
+/** One ring of a slab as a slab of its own on the same surface, `drop` below it (a hatch, a pane). */
+export declare function ringShape(f: FloorShape, ring: number, thickness: number, drop?: number): FloorShape;
+/** Adds the keys of every chunk a slab's surface or frames overlap to `out`. */
+export declare function floorChunks(f: FloorShape, size: number, out: Set<number>, s: ClipScratch): void;
+/**
+ * Adds the chunks a slab's ring covers to `out`: the hole's area, its rim and its frame. Moving a
+ * cutout changes nothing drawn outside these, whatever the new triangulation (0067).
+ */
+export declare function ringChunks(f: FloorShape, ring: number, size: number, out: Set<number>, s: ClipScratch): void;
+/**
+ * Emits a slab's part inside one chunk square: its surface (u, v in metres along it) and, when
+ * thick, its underside, edges and hole rims. Frames go to `frame(k)`, for frame k of `f.frames`.
+ */
+export declare function emitFloor(f: FloorShape, minX: number, minZ: number, maxX: number, maxZ: number, m: MeshBuilder, s: ClipScratch, frame?: (k: number) => MeshBuilder): boolean;
+/** Whether (x, z) is inside points `start` to `end` of a flat ring; on an edge counts as `edge`. */
+export declare function insideRing(points: ArrayLike<number>, start: number, end: number, x: number, z: number, edge: boolean): boolean;
+/** Whether ring `inner` (flat points) lies strictly inside ring `outer`, touching nowhere. */
+export declare function ringInside(inner: Float64Array, outer: Float64Array): boolean;
+/** Whether two rings (flat points) overlap or touch. */
+export declare function ringsOverlap(a: Float64Array, b: Float64Array): boolean;