@aethervtt/shard-structure 0.0.0-stage → 0.2.0

package/dist/harness.d.ts

@@ -0,0 +1,27 @@
+import type { Entity } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import { OffscreenTarget } from '@aethervtt/shard-render';
+import { App } from '@aethervtt/shard-runtime';
+import { hostScene } from './fixtures.js';
+export interface Rig {
+    app: App;
+    host: ReturnType<typeof hostScene>;
+    camera: Entity;
+    sun: Entity;
+    target: OffscreenTarget;
+    view: string;
+    frame(): void;
+    look(eye: [number, number, number], at: [number, number, number]): void;
+    dispose(): Promise<void>;
+}
+export declare function rig(gpu: GpuContext, options?: {
+    width?: number;
+    height?: number;
+    shadowUpdate?: 'always' | 'on-change';
+    shadows?: boolean;
+    orthoHeight?: number;
+    /** Adds surfacePlugin (0068), for SurfaceMaterial walls and floors. */
+    surface?: boolean;
+    /** Adds interiorLightingPlugin (0069). */
+    interior?: boolean;
+}): Promise<Rig>;

package/dist/harness.js

@@ -0,0 +1,74 @@
+import {
+  Camera3d,
+  DirectionalLight,
+  Exposure,
+  forwardPlugin,
+  OffscreenTarget,
+  RenderTargets,
+  renderPlugin,
+  Tonemapping
+} from "@aethervtt/shard-render";
+import { surfacePlugin } from "@aethervtt/shard-render/surface";
+import { App } from "@aethervtt/shard-runtime";
+import { lookAt, Transform, TransformPlugin } from "@aethervtt/shard-transform";
+import { hostScene } from "./fixtures.js";
+import { interiorLightingPlugin } from "./interior-plugin.js";
+import { structurePlugin } from "./plugin.js";
+async function rig(gpu, options = {}) {
+  const app = new App().addPlugin(
+    TransformPlugin,
+    renderPlugin({ gpu, windowView: false }),
+    forwardPlugin({ msaa: 1 }),
+    structurePlugin
+  );
+  if (options.surface) app.addPlugin(surfacePlugin);
+  if (options.interior) app.addPlugin(interiorLightingPlugin);
+  await app.init();
+  const world = app.world;
+  const target = new OffscreenTarget(gpu, {
+    label: "structure",
+    width: options.width ?? 96,
+    height: options.height ?? 64
+  });
+  const ref = world.resource(RenderTargets).add(target, "structure");
+  const camera = world.spawn(
+    [
+      Camera3d,
+      options.orthoHeight ? { target: ref, projection: "orthographic", orthoHeight: options.orthoHeight, far: 500 } : { target: ref, fovY: 50 }
+    ],
+    [Exposure, { ev100: 12 }],
+    [Tonemapping, { dither: false }],
+    Transform
+  );
+  const sun = world.spawn(
+    [
+      DirectionalLight,
+      {
+        illuminance: 2e4,
+        shadows: options.shadows ?? true,
+        shadowUpdate: options.shadowUpdate ?? "always"
+      }
+    ],
+    [Transform, { rotation: lookAt([-3, 8, 2], [0, 0, 0]) }]
+  );
+  const host = hostScene(world);
+  return {
+    app,
+    host,
+    camera,
+    sun,
+    target,
+    view: `camera:${camera}`,
+    frame: () => app.update(1 / 60),
+    look(eye, at) {
+      world.set(camera, Transform, { translation: eye, rotation: lookAt(eye, at) });
+    },
+    async dispose() {
+      await app.dispose();
+      target.destroy();
+    }
+  };
+}
+export {
+  rig
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { type CompileReport, compileStructure, DOOR_DEMAND, roofAt, Structure, StructureState, swingDoors, } from './compile.js';
+export { CHANNELS, ContactMesh, type ContactSettings, CUTOUT_KINDS, Cutout, DOOR_STATES, DoorLeaf, defaultContact, defaultInterior, Floor, HINGES, INTERIOR_QUALITIES, type InteriorQuality, type InteriorSettings, Level, LIGHT_CHANNELS, OPENING_KINDS, Opening, Roof, StructureChunk, StructureSettings, type StructureSettingsValue, SWINGS, WALL_SHAPES, Wall, WindowPane, } from './components.js';
+export { CONTACT_CORE, CONTACT_CORE_BOOST, CONTACT_LIFT, CONTACT_STEP, CONTACT_STRIDE, type ContactEnv, type ContactLook, ContactQuads, type ContactReach, contactAlpha, contactChunks, contactQuads, emitContact, } from './contact.js';
+export { CONTACT_KEY, CONTACT_SHADERS, ContactShade } from './contact-shade.js';
+export { arcOf, type Centerline, CURVE_TOLERANCE, type CurveInput, pointAt, quadraticToCubic, sampleWall, type WallCurve, } from './curve.js';
+export { ClipScratch, chunkKey, chunkX, chunkZ, emitFloor, emitWall, type FloorShape, floorChunks, floorShape, insideRing, MeshBuilder, type OpeningShape, type Piece, ringInside, ringShape, ringsOverlap, type SlabFrame, type SlabOptions, slabY, type WallShape, wallChunks, wallLength, wallPieces, } from './geometry.js';
+export { type Barrier, type Bounds, buildRow, type Cover, clearRect, type FieldGrid, FieldLayer, packRect, packTexel, RowScratch, rasterBarrier, rasterCover, relaxation, rowBias, SolveScratch, screening, solveRect, type TexelRect, texelsOf, unpackBin, unpackVisibility, } from './interior.js';
+export { INTERIOR_QUALITY, Interior, type InteriorSolveReport, InteriorState, interiorLightingPlugin, interiorMethods, skyAt, updateInterior, } from './interior-plugin.js';
+export { structureMethods, structurePlugin } from './plugin.js';

package/dist/index.js

@@ -0,0 +1,189 @@
+import {
+  compileStructure,
+  DOOR_DEMAND,
+  roofAt,
+  Structure,
+  StructureState,
+  swingDoors
+} from "./compile.js";
+import {
+  CHANNELS,
+  ContactMesh,
+  CUTOUT_KINDS,
+  Cutout,
+  DOOR_STATES,
+  DoorLeaf,
+  defaultContact,
+  defaultInterior,
+  Floor,
+  HINGES,
+  INTERIOR_QUALITIES,
+  Level,
+  LIGHT_CHANNELS,
+  OPENING_KINDS,
+  Opening,
+  Roof,
+  StructureChunk,
+  StructureSettings,
+  SWINGS,
+  WALL_SHAPES,
+  Wall,
+  WindowPane
+} from "./components.js";
+import {
+  CONTACT_CORE,
+  CONTACT_CORE_BOOST,
+  CONTACT_LIFT,
+  CONTACT_STEP,
+  CONTACT_STRIDE,
+  ContactQuads,
+  contactAlpha,
+  contactChunks,
+  contactQuads,
+  emitContact
+} from "./contact.js";
+import { CONTACT_KEY, CONTACT_SHADERS, ContactShade } from "./contact-shade.js";
+import {
+  arcOf,
+  CURVE_TOLERANCE,
+  pointAt,
+  quadraticToCubic,
+  sampleWall
+} from "./curve.js";
+import {
+  ClipScratch,
+  chunkKey,
+  chunkX,
+  chunkZ,
+  emitFloor,
+  emitWall,
+  floorChunks,
+  floorShape,
+  insideRing,
+  MeshBuilder,
+  ringInside,
+  ringShape,
+  ringsOverlap,
+  slabY,
+  wallChunks,
+  wallLength,
+  wallPieces
+} from "./geometry.js";
+import {
+  buildRow,
+  clearRect,
+  FieldLayer,
+  packRect,
+  packTexel,
+  RowScratch,
+  rasterBarrier,
+  rasterCover,
+  relaxation,
+  rowBias,
+  SolveScratch,
+  screening,
+  solveRect,
+  texelsOf,
+  unpackBin,
+  unpackVisibility
+} from "./interior.js";
+import {
+  INTERIOR_QUALITY,
+  Interior,
+  InteriorState,
+  interiorLightingPlugin,
+  interiorMethods,
+  skyAt,
+  updateInterior
+} from "./interior-plugin.js";
+import { structureMethods, structurePlugin } from "./plugin.js";
+export {
+  CHANNELS,
+  CONTACT_CORE,
+  CONTACT_CORE_BOOST,
+  CONTACT_KEY,
+  CONTACT_LIFT,
+  CONTACT_SHADERS,
+  CONTACT_STEP,
+  CONTACT_STRIDE,
+  CURVE_TOLERANCE,
+  CUTOUT_KINDS,
+  ClipScratch,
+  ContactMesh,
+  ContactQuads,
+  ContactShade,
+  Cutout,
+  DOOR_DEMAND,
+  DOOR_STATES,
+  DoorLeaf,
+  FieldLayer,
+  Floor,
+  HINGES,
+  INTERIOR_QUALITIES,
+  INTERIOR_QUALITY,
+  Interior,
+  InteriorState,
+  LIGHT_CHANNELS,
+  Level,
+  MeshBuilder,
+  OPENING_KINDS,
+  Opening,
+  Roof,
+  RowScratch,
+  SWINGS,
+  SolveScratch,
+  Structure,
+  StructureChunk,
+  StructureSettings,
+  StructureState,
+  WALL_SHAPES,
+  Wall,
+  WindowPane,
+  arcOf,
+  buildRow,
+  chunkKey,
+  chunkX,
+  chunkZ,
+  clearRect,
+  compileStructure,
+  contactAlpha,
+  contactChunks,
+  contactQuads,
+  defaultContact,
+  defaultInterior,
+  emitContact,
+  emitFloor,
+  emitWall,
+  floorChunks,
+  floorShape,
+  insideRing,
+  interiorLightingPlugin,
+  interiorMethods,
+  packRect,
+  packTexel,
+  pointAt,
+  quadraticToCubic,
+  rasterBarrier,
+  rasterCover,
+  relaxation,
+  ringInside,
+  ringShape,
+  ringsOverlap,
+  roofAt,
+  rowBias,
+  sampleWall,
+  screening,
+  skyAt,
+  slabY,
+  solveRect,
+  structureMethods,
+  structurePlugin,
+  swingDoors,
+  texelsOf,
+  unpackBin,
+  unpackVisibility,
+  updateInterior,
+  wallChunks,
+  wallLength,
+  wallPieces
+};

package/dist/interior-plugin.d.ts

@@ -0,0 +1,206 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import { type InteriorLighting } from '@aethervtt/shard-render';
+import { type AppMethod } from '@aethervtt/shard-runtime';
+import { type StructureState } from './compile.js';
+import { type InteriorSettings } from './components.js';
+import { type Barrier, type Bounds, type Cover, type FieldGrid, FieldLayer, RowScratch, SolveScratch, type TexelRect } from './interior.js';
+/** Per quality: field texel (m), bins per light row, filter taps, coarse cells (texels in ~1 m). */
+export declare const INTERIOR_QUALITY: {
+    readonly low: {
+        readonly texel: 0.5;
+        readonly bins: 256;
+        readonly taps: 1;
+        readonly cells: 2;
+    };
+    readonly medium: {
+        readonly texel: 0.25;
+        readonly bins: 512;
+        readonly taps: 3;
+        readonly cells: 4;
+    };
+    readonly high: {
+        readonly texel: 0.125;
+        readonly bins: 1024;
+        readonly taps: 5;
+        readonly cells: 8;
+    };
+};
+interface WallCache {
+    layer: number;
+    bounds: Bounds;
+    barriers: Barrier[];
+    signature: string;
+    /** Index cells it's in (layer-qualified keys). */
+    cells: number[];
+}
+interface SlabCache {
+    /** Layers it covers: a roof its own level's; a floor every lower level's. */
+    layers: number[];
+    bounds: Bounds;
+    cover: Cover;
+    signature: string;
+}
+interface LightCache {
+    row: number;
+    x: number;
+    y: number;
+    z: number;
+    range: number;
+    layer: number;
+    /** The frame it was last seen, and the frame its row was last built. */
+    frame: number;
+    rebuilt: number;
+}
+interface LevelEntry {
+    entity: Entity;
+    elevation: number;
+    height: number;
+    ambient: [number, number, number];
+    fill: number;
+}
+/** The last field solve (structure.describe → interior.lastSolve). */
+export interface InteriorSolveReport {
+    /** Whole-field solve (bounds grew, quality or reach changed), or a region after an edit. */
+    full: boolean;
+    /** Regions re-solved: layer, and [minX, minZ, maxX, maxZ] in metres. */
+    regions: {
+        layer: number;
+        bounds: [number, number, number, number];
+    }[];
+    texels: number;
+    sweeps: number;
+    /** Texels uploaded. */
+    uploaded: number;
+    ms: number;
+}
+/** What the plugin keeps: the field, every piece's barriers and cover, and the blocked lights. */
+export declare class InteriorState {
+    settings: InteriorSettings;
+    /** The `StructureSettings.interior` object last merged (a patch replaces it). */
+    seen: object | undefined;
+    /** Settings the field and rows were last built with. */
+    builtTexel: number;
+    builtReach: number;
+    builtBins: number;
+    curveTolerance: number;
+    grid: FieldGrid | undefined;
+    layers: FieldLayer[];
+    levels: LevelEntry[];
+    /** Layer of each Level entity (1 + its rank by elevation); the ground level is layer 0. */
+    readonly levelLayer: Map<number, number>;
+    readonly walls: Map<number, WallCache>;
+    readonly slabs: Map<number, SlabCache>;
+    /** Openings' and cutouts' hosts as last seen, so an edit that moves one dirties both. */
+    readonly openingWall: Map<number, number>;
+    readonly cutoutHost: Map<number, number>;
+    readonly cells: Map<number, Set<number>>;
+    readonly lights: Map<number, LightCache>;
+    /** Rows not given to a light, lowest last (`pop` hands out the lowest). */
+    freeRows: number[];
+    rowCount: number;
+    rowData: Uint32Array<ArrayBuffer>;
+    /** Per layer, regions to rasterize and solve again. */
+    dirty: TexelRect[][];
+    readonly dirtyRows: Set<number>;
+    /** The field (and every row) is built from scratch next. */
+    full: boolean;
+    /** Lights over maxBlockedLights were reported. */
+    warnedRows: boolean;
+    warnedLevels: boolean;
+    last: InteriorSolveReport | null;
+    lastRows: {
+        lights: number;
+        ms: number;
+    };
+    frame: number;
+    seenLights: number;
+    readonly removedWalls: Entity[];
+    readonly removedSlabs: Entity[];
+    readonly removedOpenings: Entity[];
+    readonly removedCutouts: Entity[];
+    /** Point and spot lights whose component went (despawns included): their rows free first. */
+    readonly removedLights: Entity[];
+    levelsDirty: boolean;
+    /** Field regions and rows to upload this frame (unless the texture is new, and gets it all). */
+    readonly uploads: {
+        layer: number;
+        rect: TexelRect;
+    }[];
+    readonly rowUploads: Set<number>;
+    readonly scratch: SolveScratch;
+    readonly rowScratch: RowScratch;
+    readonly candidates: Barrier[];
+    readonly stamp: Map<number, number>;
+    /** The layer pieces on `group` (a Level, or the ground level's group) draw into; -1 for none. */
+    layerOfGroup(structure: StructureState, group: Entity): number;
+    /** The table entry (and so layer) whose [floor, top) holds y: the shader's rule. */
+    layerAtY(y: number): number;
+    /** The field's value at a point: 1 outdoors, as the lighting stage reads it (without the normal offset). */
+    skyAt(x: number, y: number, z: number): number;
+    describe(lighting: InteriorLighting | undefined): {
+        settings: {
+            sky: boolean;
+            blockLights: boolean;
+            quality: import("./components.js").InteriorQuality;
+            spillReach: number;
+            maxBlockedLights: number;
+        };
+        sky: boolean;
+        blockLights: boolean;
+        field: {
+            extent: number[];
+            texel: number;
+            size: number[];
+            layers: number;
+        } | null;
+        levels: {
+            level: number;
+            layer: number;
+            elevation: number;
+            height: number;
+        }[];
+        lastSolve: InteriorSolveReport | null;
+        lastRows: {
+            lights: number;
+            ms: number;
+        };
+        blockedLights: {
+            light: Entity;
+            row: number;
+            lastRebuild: number;
+        }[];
+        rows: {
+            used: number;
+            capacity: number;
+        };
+        bytes: number;
+    };
+}
+export declare const Interior: import("@aethervtt/shard-core").ResourceDef<InteriorState>;
+/**
+ * Keeps the field and the rows current: settings, levels, then edits (each a region of the field
+ * and the rows of lights in reach), then the lights themselves. Uploads only what changed; a still
+ * frame does no work and allocates nothing.
+ */
+export declare const updateInterior: import("@aethervtt/shard-core").SystemDef<{
+    walls: import("@aethervtt/shard-core").Query;
+    floors: import("@aethervtt/shard-core").Query;
+    roofs: import("@aethervtt/shard-core").Query;
+    openings: import("@aethervtt/shard-core").Query;
+    cutouts: import("@aethervtt/shard-core").Query;
+    levels: import("@aethervtt/shard-core").Query;
+    points: import("@aethervtt/shard-core").Query;
+    spots: import("@aethervtt/shard-core").Query;
+}>;
+/** Sky visibility at a point (0069): 1 outdoors, else the field there. For tests and agents. */
+export declare function skyAt(world: World, x: number, y: number, z: number): number;
+export declare const interiorMethods: AppMethod[];
+/**
+ * Interior lighting (0069): sky visibility from the plan scales ambient and image-based light
+ * (dark deep in a room, dark in a sealed one), and lights with blockedByWalls stop at their level's
+ * walls and closed doors. StructureSettings.interior sets the parts, quality and spill reach;
+ * Level.interiorAmbient and interiorFill light what the sky doesn't reach. Needs structurePlugin
+ * and render's interiorPlugin (in forwardPlugin).
+ */
+export declare const interiorLightingPlugin: import("@aethervtt/shard-runtime").Plugin;
+export {};