@aethervtt/shard-structure 0.0.0-stage → 0.2.0

package/dist/planar.js

@@ -0,0 +1,105 @@
+import { CURVE_TOLERANCE, pointAt, sampleWall } from "./curve.js";
+function lightChannel(segment) {
+  return segment.light ?? segment.sight;
+}
+function setLight(light) {
+  return light === "normal" || light === "none" ? light : void 0;
+}
+function planarBarriers(walls, openings, options = {}) {
+  const tolerance = options.tolerance ?? CURVE_TOLERANCE;
+  const byWall = /* @__PURE__ */ new Map();
+  for (const opening of openings) {
+    const list = byWall.get(opening.wall);
+    if (list) list.push(opening);
+    else byWall.set(opening.wall, [opening]);
+  }
+  const out = [];
+  const only = options.level;
+  for (const wall of walls) {
+    const level = wall.level ?? null;
+    if (only !== void 0 && level !== only) continue;
+    const tagged = only !== void 0 || wall.level !== void 0;
+    const curved = wall.shape === "arc" || wall.shape === "bezier";
+    const line = curved ? sampleWall(wall, tolerance) : void 0;
+    const dx = wall.b[0] - wall.a[0];
+    const dy = wall.b[1] - wall.a[1];
+    const length = line ? line.length : Math.sqrt(dx * dx + dy * dy);
+    if (length < 1e-6) continue;
+    const wallLight = setLight(wall.light);
+    const cut = (from, to, id, sight, movement, light, openingId) => {
+      const pieces = line ? curvedSpan(line, from, to, id, wall.id, sight, movement) : [span(wall, length, from, to, id, sight, movement)];
+      for (const piece of pieces) {
+        if (openingId !== void 0) piece.openingId = openingId;
+        if (light !== void 0) piece.light = light;
+        if (tagged) piece.level = level;
+        out.push(piece);
+      }
+    };
+    const list = (byWall.get(wall.id) ?? []).slice();
+    list.sort((p, q) => p.offset - q.offset || (p.id < q.id ? -1 : p.id > q.id ? 1 : 0));
+    let cursor = 0;
+    for (const opening of list) {
+      if (opening.offset > cursor)
+        cut(cursor, opening.offset, `struct:${wall.id}:${cursor}`, "normal", "normal", wallLight);
+      const open = opening.kind === "door" && opening.state === "open";
+      const light = setLight(opening.light);
+      cut(
+        opening.offset,
+        opening.offset + opening.width,
+        `struct-opening:${opening.id}`,
+        open ? "none" : opening.sight,
+        open ? "none" : opening.movement,
+        open && light !== void 0 ? "none" : light,
+        opening.id
+      );
+      cursor = opening.offset + opening.width;
+    }
+    if (cursor < length)
+      cut(cursor, length, `struct:${wall.id}:${cursor}`, "normal", "normal", wallLight);
+  }
+  return out;
+}
+function curvedSpan(line, from, to, id, wall, sight, movement) {
+  const at = new Float64Array(4);
+  const points = [];
+  const push = (s) => {
+    pointAt(line, s, at);
+    points.push([at[0], at[1]]);
+  };
+  push(from);
+  for (let i = 1; i < line.count - 1; i++) {
+    const s = line.s[i];
+    if (s > from + 1e-9 && s < to - 1e-9) push(s);
+  }
+  push(to);
+  const out = [];
+  for (let k = 0; k + 1 < points.length; k++) {
+    out.push({
+      id: k === 0 ? id : `${id}~${k}`,
+      sourceWallId: wall,
+      a: points[k],
+      b: points[k + 1],
+      sight,
+      movement
+    });
+  }
+  return out;
+}
+function span(wall, length, from, to, id, sight, movement) {
+  const ax = wall.a[0];
+  const ay = wall.a[1];
+  const dx = (wall.b[0] - ax) / length;
+  const dy = (wall.b[1] - ay) / length;
+  return {
+    id,
+    sourceWallId: wall.id,
+    a: [ax + dx * from, ay + dy * from],
+    b: [ax + dx * to, ay + dy * to],
+    sight,
+    movement
+  };
+}
+export {
+  lightChannel,
+  planarBarriers
+};

package/dist/plugin.d.ts

@@ -0,0 +1,10 @@
+import { type AppMethod } from '@aethervtt/shard-runtime';
+export declare const structureMethods: AppMethod[];
+/**
+ * Walls, openings and floors (0055): compiled into chunked, per-material meshes that rebuild only
+ * where an edit lands, door leaves that swing without rebuilding anything, and window panes. Levels,
+ * roofs and cutouts (0067): each level and roof is a group whose meshes are its children, so hiding
+ * one is a Visibility write. Contact shade (0068): noisy dark strips where walls meet floors and
+ * each other, one blended mesh per (group, chunk). Needs `forwardPlugin` (render/forward).
+ */
+export declare const structurePlugin: import("@aethervtt/shard-runtime").Plugin;

package/dist/plugin.js

@@ -0,0 +1,119 @@
+import { Derived, defineSchema, PostUpdate } from "@aethervtt/shard-core";
+import { box } from "@aethervtt/shard-mesh";
+import { MaterialAsset, Materials, Meshes, registerShaders, Shaders } from "@aethervtt/shard-render";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { Transform, TransformSystems } from "@aethervtt/shard-transform";
+import {
+  compileStructure,
+  FRAME_KEY,
+  observeRemovals,
+  Structure,
+  StructureState,
+  swingDoors
+} from "./compile.js";
+import {
+  ContactMesh,
+  Cutout,
+  DoorLeaf,
+  Floor,
+  Level,
+  Opening,
+  Roof,
+  StructureChunk,
+  StructureSettings,
+  Wall,
+  WindowPane
+} from "./components.js";
+import { CONTACT_KEY, CONTACT_SHADERS, ContactShade } from "./contact-shade.js";
+const structureMethods = [
+  {
+    name: "structure.describe",
+    description: "Structure: wall, opening, floor, roof, cutout, level and chunk counts, the groups (ground, levels, roofs: their chunks, meshes and whether hidden), the chunk grid, pieces per chunk, and the last compile (its dirty chunks and time).",
+    params: defineSchema("structure/DescribeParams", {}),
+    handler: ({ world }) => world.resource(Structure).describe()
+  }
+];
+function leafBox() {
+  const mesh = box();
+  const data = mesh.data();
+  const p = data.positions;
+  for (let i = 0; i < p.length; i += 3) {
+    p[i] = p[i] + 0.5;
+    p[i + 1] = p[i + 1] + 0.5;
+  }
+  mesh.update(data);
+  return mesh;
+}
+const structurePlugin = definePlugin({
+  name: "structure",
+  dependencies: ["render/forward", "core/transform"],
+  provides: [
+    Wall,
+    Opening,
+    Floor,
+    Level,
+    Roof,
+    Cutout,
+    StructureChunk,
+    DoorLeaf,
+    WindowPane,
+    ContactMesh,
+    ContactShade,
+    StructureSettings
+  ],
+  build(app) {
+    const world = app.world;
+    world.initResource(StructureSettings);
+    const state = new StructureState(world);
+    world.insertResource(Structure, state);
+    state.ground = world.spawn(Transform, Derived);
+    state.groupSlot(state.ground);
+    observeRemovals(world, state);
+    app.addSystems(PostUpdate, swingDoors.after(compileStructure).before(TransformSystems));
+    app.addSystems(PostUpdate, compileStructure.before(TransformSystems));
+    app.addMethod(...structureMethods);
+  },
+  ready(app) {
+    const world = app.world;
+    const state = world.resource(Structure);
+    const materials = world.resource(Materials);
+    state.defaultMaterial = materials.add(
+      new MaterialAsset({ baseColor: [0.62, 0.6, 0.57, 1], roughness: 0.85 }),
+      "structure:default"
+    );
+    state.materials.set(
+      FRAME_KEY,
+      materials.add(
+        new MaterialAsset({ baseColor: [0.29, 0.18, 0.1, 1], roughness: 0.6 }),
+        FRAME_KEY
+      )
+    );
+    state.glassMaterial = materials.add(
+      new MaterialAsset({
+        baseColor: [0.62, 0.76, 0.86, 0.28],
+        roughness: 0.05,
+        alphaMode: "alpha"
+      }),
+      "structure:glass"
+    );
+    state.leafMesh = world.resource(Meshes).add(leafBox(), "structure:leaf");
+    registerShaders(world.resource(Shaders), CONTACT_SHADERS);
+    const contact = state.contact;
+    state.contactMaterial = materials.add(
+      new MaterialAsset(
+        {
+          opacity: contact.opacity,
+          maxAlpha: contact.maxAlpha,
+          color: [...contact.color],
+          wobble: contact.wobble
+        },
+        ContactShade
+      ),
+      CONTACT_KEY
+    );
+  }
+});
+export {
+  structureMethods,
+  structurePlugin
+};

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@aethervtt/shard-structure",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./planar": {
+      "types": "./dist/planar.d.ts",
+      "default": "./dist/planar.js"
+    },
+    "./fixtures": {
+      "types": "./dist/fixtures.d.ts",
+      "default": "./dist/fixtures.js"
+    },
+    "./bench": {
+      "types": "./dist/bench.d.ts",
+      "default": "./dist/bench.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.2.0",
+    "@aethervtt/shard-mesh": "0.2.0",
+    "@aethervtt/shard-mirror": "0.2.0",
+    "@aethervtt/shard-render": "0.2.0",
+    "@aethervtt/shard-runtime": "0.2.0",
+    "@aethervtt/shard-texture": "0.2.0",
+    "@aethervtt/shard-transform": "0.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/structure"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
+  }
+}