@adatechnology/game-floorplan-three 0.10.0 → 0.10.2

package/dist/index.d.ts

@@ -1,15 +1,38 @@
-import { H as HouseRendererOptions, a as HouseRenderer } from './testing-CcAh3Eg1.js';
-export { A as AreaContext, B as BuildOptions, D as DEFAULT_SPECIMENS, b as Damageable, F as FLOORPLAN_AREA_ID, c as FloorplanEngineLike, d as FloorplanTestOptions, e as House, L as LightingOptions, M as Messages, S as SPECIMEN_AT, f as SpecimenDef, T as TemplateGroup, g as Translate, h as buildSpecimenMeshes, i as createFloorplanTestModule, j as createHouseScenarios, k as createTranslator, l as en, m as locales, p as ptBR, s as specimenSpec } from './testing-CcAh3Eg1.js';
+import { R as RoomRects, T as Three, H as HouseRendererOptions, a as HouseRenderer, b as HouseRecord } from './testing-BK7QmoUq.js';
+export { A as AreaContext, B as BuildOptions, D as DEFAULT_SPECIMENS, c as Damageable, F as FLOORPLAN_AREA_ID, d as FloorplanEngineLike, e as FloorplanTestOptions, f as House, g as HouseBoxCollider, h as HouseFurnitureCollider, i as HouseInteractable, j as HouseInteractives, k as HousePart, l as HousePlan, m as HousePoint, n as HouseTargetOptions, L as LightingOptions, M as Messages, S as SPECIMEN_AT, o as SpecimenDef, p as TemplateGroup, q as Translate, r as buildSpecimenMeshes, s as createFloorplanTestModule, t as createHouseScenarios, u as createTranslator, v as en, w as locales, x as ptBR, y as specimenSpec } from './testing-BK7QmoUq.js';
+import { DestructionEvent, DestructionWorld } from '@adatechnology/game-destruction';
 import { DestructibleSpec, WarmUpProbes } from '@adatechnology/game-contracts';
+import * as THREE_NS from 'three';
+import { Construction, Structure } from '@adatechnology/game-floorplan-structure';
+import { Rect } from '@adatechnology/game-floorplan';
+import '@adatechnology/game-destruction-three';
 import '@adatechnology/game-render-three';
+import '@adatechnology/game-props3d';
+import '@adatechnology/game-shapes-three';
+import '@adatechnology/game-vegetation';
+import '@adatechnology/game-interactables';
+import '@adatechnology/game-floorplan-interactables';
+import '@adatechnology/game-vegetation/three';
 
+/** A house as the shared draw budget reads it: its distance, its draw calls with and without the small pieces, and how to set its LOD. */
+interface LodHouse {
+    distance(focus: unknown): number;
+    stats: {
+        drawCalls: number;
+        drawCallsLOD1: number;
+    };
+    setLod(level: number): void;
+}
 declare const OPEN_ROOM_TYPES: Set<string>;
-declare const rectsOf: (c: any) => any;
-declare const isOpenArea: (c: any) => boolean;
-declare function planLod(houses: any, focus: any, budget: any): {
-    total: any;
-    levels: any;
-    houses: any;
+declare const rectsOf: (c: RoomRects) => readonly Rect[];
+declare const isOpenArea: (c: {
+    type: string;
+    outdoor?: boolean;
+}) => boolean;
+declare function planLod<H extends LodHouse>(houses: readonly H[], focus: unknown, budget: number): {
+    total: number;
+    levels: number[];
+    houses: H[];
 };
 
 declare const VERSION = "1.0.0";
@@ -18,7 +41,7 @@ declare const VERSION = "1.0.0";
  * Creates a house renderer: `create(THREE, options).build(result, { quality, night })` turns the result of `@adatechnology/game-floorplan`
  * (plus the structure of `@adatechnology/game-floorplan-structure`) into a three.js group. Port of the team's Casa3DSDK.
  */
-declare function create(THREE: any, options?: HouseRendererOptions): HouseRenderer;
+declare function create(THREE: Three, options?: HouseRendererOptions): HouseRenderer;
 
 /** A rectangle `[x0, z0, x1, z1]` in the house's coordinates. */
 type NavRect = [number, number, number, number];
@@ -35,8 +58,8 @@ interface NavHouseDef {
     id: string;
     floors: NavFloor[];
     stairs?: NavStair[];
-    groups?: unknown[];
-    roof?: unknown;
+    groups?: NavShowable[];
+    roof?: NavShowable;
     /** The fine grid also rules the ground floor inside the house (default: the ground floor uses the game's grid, except stairs and banisters). */
     own?: boolean;
     /** The house's rectangle (default: the union of its solids and stairs). */
@@ -64,7 +87,7 @@ interface NavFlight {
     axis: 0 | 1;
     from: number;
     to: number;
-    group: any;
+    group: StairGroup;
     yFrom: number;
     yTo: number;
     dir: number;
@@ -72,15 +95,39 @@ interface NavFlight {
     len: number;
     e: number;
 }
+/** What is drawn of a floor (or the roof): an object with `visible`, a function `show(visible)`, or a list of them. */
+type NavShowable = {
+    visible: boolean;
+} | ((visible: boolean) => void) | readonly NavShowable[] | null | undefined;
+/** The flights that share one stair footprint: the axis they climb along, the footprint and each flight's floors. */
+interface StairGroup {
+    ax: 0 | 1;
+    r: number[];
+    m: {
+        from: number;
+        to: number;
+        inv: boolean;
+    }[];
+}
+/** The path field of a floor on the coarse grid: free cells, distances and the BFS queue to the current target cell. */
+interface PathField {
+    gx: number;
+    gz: number;
+    free: Uint8Array;
+    d: Int16Array;
+    q: Int32Array;
+    target: number;
+    t: number;
+}
 interface NavHouse {
     id: string;
     own: boolean;
     floors: NavFloor[];
-    groups: unknown[];
-    roof: unknown;
+    groups: NavShowable[];
+    roof: NavShowable;
     flights: NavFlight[];
     grids: Uint8Array[];
-    fields: any[];
+    fields: (PathField | null)[];
     /** Triples (floor, cell, previous value) of the run-time changes of the grid. */
     journal: number[];
     shown: number;
@@ -121,6 +168,15 @@ interface FloorNavigator {
     undoChanges(houseId: string): void;
 }
 
+/** A box collider of the house: type, floor and rectangle. */
+interface NavBoxCollider {
+    type: string;
+    f: number;
+    x0: number;
+    z0: number;
+    x1: number;
+    z1: number;
+}
 /** The parts of a built house (`create(THREE, options).build(...)`) the navigator reads. */
 interface NavigableHouse {
     name?: string;
@@ -131,14 +187,11 @@ interface NavigableHouse {
             ceiling: number;
         }[];
     };
-    colliders: {
+    /** Its colliders; the box ones (`x0`..`z1`) of the solid types make the cells solid. */
+    colliders: readonly (NavBoxCollider | {
         type: string;
         f: number;
-        x0: number;
-        z0: number;
-        x1: number;
-        z1: number;
-    }[];
+    })[];
     stairs: {
         m: {
             ry: number;
@@ -147,8 +200,8 @@ interface NavigableHouse {
         to: number;
         rect: NavRect;
     }[];
-    floors: unknown[];
-    roof: unknown;
+    floors: NavShowable[];
+    roof: NavShowable;
 }
 interface NavigationDefOptions {
     /** Id the house registers with (default: the house's name). */
@@ -182,7 +235,7 @@ interface DestructibleHouse {
         }>;
     };
     destruction: {
-        onEvent(listener: (event: any) => void): () => void;
+        onEvent(listener: (event: DestructionEvent) => void): () => void;
         restore?: () => void;
     };
 }
@@ -234,7 +287,7 @@ interface FurnitureSpecResult {
     /** One part per box or cylinder the builder drew, origin at the centre of the footprint on the floor. */
     spec: DestructibleSpec;
     /** Draws the piece: one mesh per part, named by the part id, coloured as the builder coloured it. */
-    build(THREE: any): any;
+    build(THREE: Three): THREE_NS.Group;
     /** The widest high horizontal part and the height of its upper face (what loose things rest on), or null when the piece has none. */
     /** What loose things rest on. A solid top is boards: `parts` are all of them, `part` the one in the middle. */
     top: {
@@ -266,7 +319,7 @@ interface FurnitureSpecResult {
  * @example
  * const { spec, build, top } = furnitureSpec(THREE, 'bookcase') // 1.2 x 0.35 x 2 m, boards and books
  */
-declare function furnitureSpec(THREE: any, type: string, opts?: FurnitureSpecOptions): FurnitureSpecResult;
+declare function furnitureSpec(THREE: Three, type: string, opts?: FurnitureSpecOptions): FurnitureSpecResult;
 interface TapSpecOptions {
     /** `counter` (default): the tap of a sink, standing on the counter; `wall`: the tap of a laundry tub or a garden, with its plate on the wall. */
     kind?: 'counter' | 'wall';
@@ -279,7 +332,7 @@ interface TapSpecResult {
     /** The tap as parts (base, column, spout, lever), origin on the counter under the column (`counter`) or on the wall plate's centre line at the floor (`wall`). */
     spec: DestructibleSpec;
     /** Draws the tap: one mesh per part, named by the part id. */
-    build(THREE: any): any;
+    build(THREE: Three): THREE_NS.Group;
     /** Where the water leaves the spout, in the space of the spec. */
     spout: [number, number, number];
 }
@@ -287,7 +340,7 @@ interface TapSpecResult {
  * The team's tap (`counterTap` of the sink, `wallTap` of the laundry tub: `furniture/taps.ts`) drawn by the same code into parts, with the lever at rest. `spout` is where its
  * water thread starts, so a host can put a tap of the fluids world there; the water thread itself is not drawn.
  */
-declare function tapSpec(THREE: any, opts?: TapSpecOptions): TapSpecResult;
+declare function tapSpec(THREE: Three, opts?: TapSpecOptions): TapSpecResult;
 
 /** A free-standing wall built and drawn as the walls of the houses. */
 interface WallPieceOptions {
@@ -305,18 +358,18 @@ interface WallPieceOptions {
 }
 interface WallPiece {
     /** The plan of the wall: one storey, one exterior wall, no rooms and no roof; its `structure` is the houses' load path. */
-    readonly plan: any;
+    readonly plan: WallPlan;
     /** The destructible spec, as a house gives it (`house.structure.spec()`): the wall with its layers, units and breach on the ground, its concrete pillars (`wall_column_*`, at the ends and every 4 m at most) and the bond beam on both. */
-    readonly spec: any;
+    readonly spec: DestructibleSpec;
     /** Draws the wall with the house renderer: meshes carry `userData.destructionPart` of their part, in the space of the spec. */
-    build(THREE: any): any;
+    build(THREE: Three): THREE_NS.Group;
     /**
      * Once a drawing from `build` is in a destruction world as `objectId` (with this `spec`), the house renderer follows its events and draws on it what
      * a generic destruction renderer cannot: the bricks that shots and blows knock out (`chip`) and the opening of a breach, as gaps in the wall's
      * courses. `restore` puts the wall back (after `world.reset`), `dispose` stops following. `update` paints the damage of the events since the last call, once
      * per wall (call it every frame; without it the damage is painted 100 ms after the event).
      */
-    follow(root: any, world: any, objectId: string): {
+    follow(root: THREE_NS.Object3D, world: DestructionWorld, objectId: string): {
         restore(): void;
         dispose(): void;
         update(): void;
@@ -328,15 +381,20 @@ interface WallPiece {
      */
     warmUpProbes(THREE: unknown): WarmUpProbes;
 }
+/** The plan of a free-standing wall, with its construction and structure. */
+type WallPlan = HouseRecord & {
+    construction: Construction;
+    structure: Structure;
+};
 /**
  * The plan of a free-standing wall along x, centred on the origin: a one-storey plan whose only wall is exterior on both sides, with the masonry construction of
  * the houses (brick, concrete bond beam, strip footing) and the structure `buildStructure` gives the houses, without a roof.
  */
-declare function wallPlan(options: WallPieceOptions): any;
+declare function wallPlan(options: WallPieceOptions): WallPlan;
 /**
  * A free-standing wall (a target wall, a garden wall) built and drawn exactly as the walls of the houses: the structure of `game-floorplan-structure` (the wall on
  * the strip footing, the bond beam on it, the assembly's layers, units and breach) and the house renderer's plaster, paint, baseboard and sidewalk.
  */
-declare function wallPiece(THREE: any, options: WallPieceOptions): WallPiece;
+declare function wallPiece(THREE: Three, options: WallPieceOptions): WallPiece;
 
 export { type DestructibleHouse, type FloorNavigator, type FurnitureCatalogEntry, type FurnitureSpecOptions, type FurnitureSpecResult, HouseRenderer, HouseRendererOptions, type NavFlight, type NavFloor, type NavHouse, type NavHouseDef, type NavRect, type NavResult, type NavShape, type NavStair, type NavigableHouse, type NavigationDefOptions, type NavigatorBinding, OPEN_ROOM_TYPES, type TapSpecOptions, type TapSpecResult, VERSION, type WallPiece, type WallPieceOptions, bindNavigator, create, createFloorNavigator, create as createHouseRenderer, furnitureSpec, isOpenArea, navigationDefOf, planLod, rectsOf, tapSpec, wallPiece, wallPlan };