@aethervtt/shard-nav 0.0.1

package/dist/cache.d.ts

@@ -0,0 +1,31 @@
+import { type World } from '@aethervtt/shard-core';
+import type { PlatformFileSystem } from '@aethervtt/shard-platform';
+/** Where `shard bake nav` and `nav.bake` keep baked tiles, relative to the project root. */
+export declare const NAV_CACHE_PATH = ".shard/cache/nav/tiles.bin";
+/**
+ * Baked navmesh tiles by the key of the geometry and settings that made them: a tile whose key
+ * is here loads without running Recast. Null marks a tile that bakes to nothing walkable.
+ */
+export declare class NavCacheStore {
+    readonly tiles: Map<string, Uint8Array<ArrayBufferLike> | null>;
+    /** Where `save` writes, once `loadNavCache` connected a file system. */
+    fs: PlatformFileSystem | undefined;
+    path: string;
+    /** Tiles read from disk by the last load. */
+    loaded: number;
+    /** The cache as one file: magic, format, count, then per tile an 8-byte key and its data. */
+    encode(keys?: Iterable<string>): Uint8Array;
+    /** Reads a file written by `encode` into the cache. Returns how many tiles it held. */
+    decode(data: Uint8Array): number;
+}
+export declare const NavCache: import("@aethervtt/shard-core").ResourceDef<NavCacheStore>;
+/**
+ * Connects the cache to a project's file system and reads the tiles baked there, so navmeshes
+ * whose geometry hasn't changed load without running Recast. Call before loading scenes.
+ */
+export declare function loadNavCache(world: World, fs: PlatformFileSystem, path?: string): Promise<number>;
+/**
+ * Writes the tiles in `keys` (default: every tile in the cache) to the cache file. Returns the
+ * bytes written, or 0 when no writable file system is connected.
+ */
+export declare function saveNavCache(world: World, keys?: Iterable<string>): Promise<number>;

package/dist/cache.js

@@ -0,0 +1,90 @@
+import { defineResource, ShardError } from "@aethervtt/shard-core";
+const NAV_CACHE_PATH = ".shard/cache/nav/tiles.bin";
+const MAGIC = 1447120467;
+const FORMAT = 1;
+const EMPTY = 4294967295;
+class NavCacheStore {
+  tiles = /* @__PURE__ */ new Map();
+  /** Where `save` writes, once `loadNavCache` connected a file system. */
+  fs;
+  path = NAV_CACHE_PATH;
+  /** Tiles read from disk by the last load. */
+  loaded = 0;
+  /** The cache as one file: magic, format, count, then per tile an 8-byte key and its data. */
+  encode(keys = this.tiles.keys()) {
+    const entries = [];
+    let size = 12;
+    for (const key of keys) {
+      const bytes = this.tiles.get(key);
+      if (bytes === void 0) continue;
+      entries.push([key, bytes]);
+      size += 12 + (bytes?.length ?? 0);
+    }
+    const out = new Uint8Array(size);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, MAGIC, true);
+    view.setUint32(4, FORMAT, true);
+    view.setUint32(8, entries.length, true);
+    let o = 12;
+    for (const [key, bytes] of entries) {
+      view.setUint32(o, Number.parseInt(key.slice(0, 8), 16), true);
+      view.setUint32(o + 4, Number.parseInt(key.slice(8, 16), 16), true);
+      view.setUint32(o + 8, bytes ? bytes.length : EMPTY, true);
+      o += 12;
+      if (bytes) {
+        out.set(bytes, o);
+        o += bytes.length;
+      }
+    }
+    return out;
+  }
+  /** Reads a file written by `encode` into the cache. Returns how many tiles it held. */
+  decode(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (data.length < 12 || view.getUint32(0, true) !== MAGIC) {
+      throw new ShardError("nav/bad-cache", "The navmesh cache file is not a Shard nav cache", {
+        hint: `Delete ${this.path}; the next bake rewrites it.`
+      });
+    }
+    if (view.getUint32(4, true) !== FORMAT) return 0;
+    const count = view.getUint32(8, true);
+    let o = 12;
+    for (let i = 0; i < count; i++) {
+      const key = view.getUint32(o, true).toString(16).padStart(8, "0") + view.getUint32(o + 4, true).toString(16).padStart(8, "0");
+      const len = view.getUint32(o + 8, true);
+      o += 12;
+      if (len === EMPTY) this.tiles.set(key, null);
+      else {
+        this.tiles.set(key, data.slice(o, o + len));
+        o += len;
+      }
+    }
+    return count;
+  }
+}
+const NavCache = defineResource("nav/Cache", {
+  description: "Baked navmesh tiles by geometry key, loaded from and saved to .shard/cache/nav.",
+  init: () => new NavCacheStore()
+});
+async function loadNavCache(world, fs, path = NAV_CACHE_PATH) {
+  const cache = world.initResource(NavCache);
+  cache.fs = fs;
+  cache.path = path;
+  if (!await fs.exists(path)) return 0;
+  cache.loaded = cache.decode(await fs.readBytes(path));
+  return cache.loaded;
+}
+async function saveNavCache(world, keys) {
+  const cache = world.initResource(NavCache);
+  if (!cache.fs?.writable) return 0;
+  const bytes = cache.encode(keys);
+  await cache.fs.writeBytes(cache.path, bytes);
+  return bytes.length;
+}
+export {
+  NAV_CACHE_PATH,
+  NavCache,
+  NavCacheStore,
+  loadNavCache,
+  saveNavCache
+};

package/dist/components.d.ts

@@ -0,0 +1,88 @@
+import { AssetStore } from '@aethervtt/shard-assets';
+import { type Entity } from '@aethervtt/shard-core';
+import { NavGridData } from './grid.js';
+export declare const GRID_SOURCES: readonly ['data', 'tilemap', 'colliders'];
+export type GridSource = (typeof GRID_SOURCES)[number];
+export declare const NavGrid: import("@aethervtt/shard-core").ComponentDef<{
+    readonly source: import("@aethervtt/shard-core").FieldType<"colliders" | "data" | "tilemap", "u8">;
+    readonly width: import("@aethervtt/shard-core").FieldType<number, "u32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "u32">;
+    readonly cellSize: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly origin: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly diagonal: import("@aethervtt/shard-core").FieldType<"always" | "never" | "no-corners", "u8">;
+    readonly tilemap: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly layer: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly blockingTiles: import("@aethervtt/shard-core").FieldType<number[], "object">;
+    readonly data: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"NavGridData"> | null, "object">;
+    readonly mask: import("@aethervtt/shard-core").FieldType<number, "u16">;
+}>;
+export declare const NavSource: import("@aethervtt/shard-core").ComponentDef<{
+    readonly area: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}>;
+export declare const NavMesh: import("@aethervtt/shard-core").ComponentDef<{
+    readonly agentRadius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly agentHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxClimb: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxSlope: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly cellSize: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly cellHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly tileSize: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly boundsMin: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly boundsMax: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly frame: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+}>;
+export declare const OffMeshLink: import("@aethervtt/shard-core").ComponentDef<{
+    readonly to: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly bidirectional: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly area: import("@aethervtt/shard-core").FieldType<number, "u8">;
+}>;
+export declare const AGENT_STATUSES: readonly ['idle', 'moving', 'arrived', 'unreachable'];
+export type AgentStatus = (typeof AGENT_STATUSES)[number];
+export declare const NavAgentState: import("@aethervtt/shard-core").ComponentDef<{
+    readonly status: import("@aethervtt/shard-core").FieldType<"arrived" | "idle" | "moving" | "unreachable", "u8">;
+    readonly remaining: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly corners: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly velocity: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+export declare const DRIVES: readonly ['character', 'transform', 'velocity'];
+export type Drive = (typeof DRIVES)[number];
+export declare const NavAgent: import("@aethervtt/shard-core").ComponentDef<{
+    readonly destination: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly target: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly speed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly acceleration: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly stoppingDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly avoidance: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly repathInterval: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly drive: import("@aethervtt/shard-core").FieldType<"character" | "transform" | "velocity", "u8">;
+    readonly stopped: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly nav: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+}>;
+export interface NavAgentEventData {
+    entity: Entity;
+}
+export declare const NavArrived: import("@aethervtt/shard-core").EventDef<NavAgentEventData>;
+export declare const NavUnreachable: import("@aethervtt/shard-core").EventDef<NavAgentEventData>;
+/** Cost multiplier per area code: `{ 0: 1, 1: 3 }` makes area 1 three times as slow to cross. */
+export type NavAreasValue = Record<number, number>;
+export declare const NavAreas: import("@aethervtt/shard-core").ResourceDef<NavAreasValue>;
+export declare const NavGridDataSchema: import("@aethervtt/shard-core").ComponentDef<{
+    readonly width: import("@aethervtt/shard-core").FieldType<number, "u32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "u32">;
+    readonly costs: import("@aethervtt/shard-core").FieldType<string, "object">;
+}>;
+export declare function navGridFromJson(json: unknown): NavGridData;
+export declare function navGridToJson(grid: NavGridData): {
+    width: number;
+    height: number;
+    costs: string;
+};
+export declare class NavGridDataStore extends AssetStore<NavGridData, 'NavGridData'> {
+    constructor();
+}
+export declare const NavGridDatas: import("@aethervtt/shard-core").ResourceDef<NavGridDataStore>;
+export declare const NavGridDataAssetType: import("@aethervtt/shard-assets").AssetTypeDef<NavGridData>;
+/** `*.navgrid.json`: walkable cells and costs for a NavGrid. */
+export declare const NavGridDataImporter: import("@aethervtt/shard-assets").ImporterDef;

package/dist/components.js

@@ -0,0 +1,279 @@
+import { AssetStore, defineAssetType, defineDataAsset } from "@aethervtt/shard-assets";
+import {
+  defineComponent,
+  defineEvent,
+  defineResource,
+  defineSchema,
+  ShardError,
+  t
+} from "@aethervtt/shard-core";
+import { Transform } from "@aethervtt/shard-transform";
+import { DIAGONAL_MODES, NavGridData } from "./grid.js";
+const GRID_SOURCES = ["data", "tilemap", "colliders"];
+const NavGrid = defineComponent(
+  "nav/NavGrid",
+  {
+    source: t.enum(GRID_SOURCES, {
+      description: "data: costs from a *.navgrid.json (data). tilemap: a tilemap layer, cell per tile (size, cell size, and origin come from the tilemap). colliders: fixed 2D colliders rasterized into width \xD7 height cells."
+    }),
+    width: t.u32({ default: 32, min: 1, description: "colliders: cells across." }),
+    height: t.u32({ default: 32, min: 1, description: "colliders: cells up." }),
+    cellSize: t.vec2({
+      default: [1, 1],
+      min: 1e-3,
+      unit: "m",
+      description: "data, colliders: world size of one cell."
+    }),
+    origin: t.vec2({
+      unit: "m",
+      description: "data, colliders: world XY of cell (0, 0)'s lower-left corner, relative to the entity's position."
+    }),
+    diagonal: t.enum(DIAGONAL_MODES, {
+      description: "no-corners: diagonal steps unless they cut a blocked corner. never: four directions only. always: diagonals even past corners."
+    }),
+    tilemap: t.entity({
+      description: "tilemap: the Tilemap entity (default: this entity)."
+    }),
+    layer: t.string({ description: "tilemap: the layer name (default: the first layer)." }),
+    blockingTiles: t.list(t.u16, {
+      description: "tilemap: only these tiles block (empty: every non-empty tile blocks). Tile numbers as in the tilemap data (region + 1)."
+    }),
+    data: t.handle("NavGridData", { description: "data: the *.navgrid.json asset." }),
+    mask: t.u16({
+      default: 65535,
+      description: "colliders: collider layers (bitmask) that block cells."
+    })
+  },
+  {
+    description: "A 2D navigation grid in the XY plane: walkable cells with costs, A* with diagonal rules, paths pulled straight. Queries and NavAgents inside it use it.",
+    requires: [Transform]
+  }
+);
+const NavSource = defineComponent(
+  "nav/NavSource",
+  {
+    area: t.u8({
+      max: 62,
+      description: "Area code the triangles bake as (0: ground). Costs per area are in nav/Areas; paths prefer cheap areas."
+    })
+  },
+  {
+    description: "This entity's colliders (or, without a Collider, its Mesh3d) and those of descendants without their own NavSource feed the navmesh bake. Moving or changing one rebuilds the tiles it touches."
+  }
+);
+const NavMesh = defineComponent(
+  "nav/NavMesh",
+  {
+    agentRadius: t.f32({
+      default: 0.4,
+      min: 0,
+      unit: "m",
+      description: "Walls are this far from the walkable area."
+    }),
+    agentHeight: t.f32({
+      default: 1.8,
+      min: 0.01,
+      unit: "m",
+      description: "Minimum clearance under ceilings."
+    }),
+    maxClimb: t.f32({
+      default: 0.3,
+      min: 0,
+      unit: "m",
+      description: "Tallest step or ledge an agent walks up."
+    }),
+    maxSlope: t.f32({
+      default: 45,
+      min: 0,
+      max: 89.9,
+      unit: "deg",
+      description: "Steepest walkable slope."
+    }),
+    cellSize: t.f32({
+      default: 0.2,
+      min: 0.01,
+      unit: "m",
+      description: "Voxel size across: smaller follows edges closer and bakes slower."
+    }),
+    cellHeight: t.f32({ default: 0.1, min: 0.01, unit: "m", description: "Voxel height." }),
+    tileSize: t.u16({
+      default: 64,
+      min: 8,
+      max: 1024,
+      description: "Cells per tile side: the unit that rebuilds when a source changes."
+    }),
+    boundsMin: t.vec3({
+      unit: "m",
+      description: "World-space bake bounds, min corner. Equal to boundsMax (the default): bounds of every source."
+    }),
+    boundsMax: t.vec3({ unit: "m", description: "World-space bake bounds, max corner." }),
+    frame: t.entity({
+      description: "Bake and query in this entity's local space instead of the world's: its +Y is up. Positions and paths stay world-space in the API. Lets a navmesh ride a moving or rotating frame (a planet's surface) and keeps its tiles when the floating origin moves. Bounds are in this space."
+    })
+  },
+  {
+    description: "A navmesh baked with Recast from every NavSource, with OffMeshLinks. Tiles are cached by the geometry that made them. Queries and NavAgents inside it use it."
+  }
+);
+const OffMeshLink = defineComponent(
+  "nav/OffMeshLink",
+  {
+    to: t.entity({ description: "The link ends at this entity\u2019s position." }),
+    bidirectional: t.bool({ default: true, description: "Agents cross it both ways." }),
+    radius: t.f32({
+      default: 0.5,
+      min: 0.01,
+      unit: "m",
+      description: "How close to either end counts as on it."
+    }),
+    area: t.u8({ max: 62, description: "Area code (costs in nav/Areas)." })
+  },
+  {
+    description: "A jump, drop, ladder, or door between two navmesh points: from this entity\u2019s position to `to`. Agents cross it in a straight line.",
+    requires: [Transform]
+  }
+);
+const AGENT_STATUSES = ["idle", "moving", "arrived", "unreachable"];
+const NavAgentState = defineComponent(
+  "nav/NavAgentState",
+  {
+    status: t.enum(AGENT_STATUSES, {
+      readonly: true,
+      description: "idle: stopped or no navigation here. moving. arrived: within stoppingDistance. unreachable: no path; it walks to the closest point it can reach."
+    }),
+    remaining: t.f32({
+      unit: "m",
+      readonly: true,
+      description: "Distance left along the path."
+    }),
+    corners: t.u16({ readonly: true, description: "Corners left on the path." }),
+    velocity: t.vec3({ unit: "m/s", readonly: true, description: "Steering velocity." })
+  },
+  { description: "What a NavAgent is doing. Written by navigation; read-only." }
+);
+const DRIVES = ["character", "transform", "velocity"];
+const NavAgent = defineComponent(
+  "nav/NavAgent",
+  {
+    destination: t.vec3({
+      unit: "m",
+      description: "Where to go (world space). Writing it starts a new path."
+    }),
+    target: t.entity({
+      description: "Follow this entity instead of destination: repaths when it moves more than a cell or every repathInterval."
+    }),
+    speed: t.f32({ default: 3.5, min: 0, unit: "m/s", description: "Top speed." }),
+    acceleration: t.f32({ default: 8, min: 0, unit: "m/s\xB2" }),
+    radius: t.f32({
+      default: 0.4,
+      min: 0,
+      unit: "m",
+      description: "Personal space: agents steer to keep this far apart."
+    }),
+    stoppingDistance: t.f32({
+      default: 0.2,
+      min: 0,
+      unit: "m",
+      description: "Arrived this close to the destination."
+    }),
+    avoidance: t.bool({ default: true, description: "Steer around other agents." }),
+    repathInterval: t.f32({
+      default: 0.5,
+      min: 0,
+      unit: "s",
+      description: "With a moving target: path again at least this often."
+    }),
+    drive: t.enum(DRIVES, {
+      description: "character: writes CharacterIntent.move so physics walks it (slopes, steps, collisions; falls back to transform without a CharacterController). velocity: writes the rigid body\u2019s Velocity. transform: moves the Transform directly."
+    }),
+    stopped: t.bool({ description: "Hold position (status idle) until cleared." }),
+    nav: t.entity({
+      description: "The NavGrid or NavMesh to walk on (default: the one the agent stands in)."
+    })
+  },
+  {
+    description: "Walks to a destination or follows a target along navigation paths: arrives, avoids other agents, repaths. Status in NavAgentState; NavArrived and NavUnreachable on changes.",
+    requires: [Transform, NavAgentState]
+  }
+);
+const NavArrived = defineEvent("nav/NavArrived", {
+  description: "A NavAgent arrived at its destination or target."
+});
+const NavUnreachable = defineEvent("nav/NavUnreachable", {
+  description: "A NavAgent\u2019s destination has no path; it heads for the closest reachable point."
+});
+const NavAreas = defineResource("nav/Areas", {
+  description: 'Navmesh area costs by area code (NavSource.area, OffMeshLink.area): { "1": 3 } makes area 1 three times as costly. 0 excludes an area. Unlisted areas cost 1.',
+  init: () => ({ 0: 1 })
+});
+const NavGridDataSchema = defineSchema(
+  "nav/NavGridData",
+  {
+    width: t.u32({ min: 1, required: true, description: "Cells across." }),
+    height: t.u32({ min: 1, required: true, description: "Cells up." }),
+    costs: t.string({
+      description: "Base64 of width \xD7 height bytes, row by row from the bottom (y = 0): 0 blocked, 1 ground, more costs more. Empty: all 1."
+    })
+  },
+  { description: "Walkable cells and costs for a NavGrid with source: data." }
+);
+function navGridFromJson(json) {
+  const v = NavGridDataSchema.deserialize(json);
+  if (!v.costs) return new NavGridData(v.width, v.height);
+  const bin = atob(v.costs);
+  if (bin.length !== v.width * v.height) {
+    throw new ShardError(
+      "nav/invalid-grid",
+      `A ${v.width}\xD7${v.height} navgrid needs ${v.width * v.height} cost bytes, got ${bin.length}`,
+      { path: "/costs" }
+    );
+  }
+  const costs = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) costs[i] = bin.charCodeAt(i);
+  return new NavGridData(v.width, v.height, costs);
+}
+function navGridToJson(grid) {
+  let s = "";
+  for (let i = 0; i < grid.costs.length; i += 32768) {
+    s += String.fromCharCode(...grid.costs.subarray(i, i + 32768));
+  }
+  return { width: grid.width, height: grid.height, costs: btoa(s) };
+}
+class NavGridDataStore extends AssetStore {
+  constructor() {
+    super("NavGridData");
+  }
+}
+const NavGridDatas = defineResource("nav/NavGridDatas", {
+  description: "Loaded navgrid data by guid.",
+  init: () => new NavGridDataStore()
+});
+const NavGridDataAssetType = defineAssetType("NavGridData", {
+  store: NavGridDatas,
+  load: (artifact) => navGridFromJson(artifact.json),
+  update: (existing, next) => existing.copyFrom(next)
+});
+const NavGridDataImporter = defineDataAsset("NavGridData", NavGridDataSchema, {
+  extension: "navgrid"
+});
+export {
+  AGENT_STATUSES,
+  DRIVES,
+  GRID_SOURCES,
+  NavAgent,
+  NavAgentState,
+  NavAreas,
+  NavArrived,
+  NavGrid,
+  NavGridDataAssetType,
+  NavGridDataImporter,
+  NavGridDataSchema,
+  NavGridDataStore,
+  NavGridDatas,
+  NavMesh,
+  NavSource,
+  NavUnreachable,
+  OffMeshLink,
+  navGridFromJson,
+  navGridToJson
+};

package/dist/geometry.d.ts

@@ -0,0 +1,33 @@
+import type { Mesh } from '@aethervtt/shard-mesh';
+/**
+ * World-space triangles for a bake: 9 floats per triangle (three xyz corners) and an area code
+ * each. Grows by doubling; `clear` keeps the memory.
+ */
+export declare class TriangleSoup {
+    positions: Float32Array<ArrayBuffer>;
+    areas: Uint8Array<ArrayBuffer>;
+    count: number;
+    readonly min: Float64Array<ArrayBuffer>;
+    readonly max: Float64Array<ArrayBuffer>;
+    clear(): void;
+    private grow;
+    /** Adds a triangle given in world space. */
+    push(ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number, area: number): void;
+}
+/**
+ * Local-space triangles into a soup through a world matrix (affine 3×4, row by row). Winding is
+ * kept, or flipped under a mirroring matrix, so upward faces stay upward.
+ */
+export declare function pushTransformed(soup: TriangleSoup, local: ArrayLike<number>, indices: ArrayLike<number> | undefined, triangles: number, m: ArrayLike<number>, area: number): void;
+export declare function boxTriangles(hx: number, hy: number, hz: number): number[];
+/**
+ * A solid of revolution around Y from a profile of [radius, y] pairs, bottom to top, with
+ * `segments` sides. Rings of radius 0 close the ends.
+ */
+export declare function latheTriangles(profile: number[][], segments?: number): number[];
+export declare function sphereProfile(radius: number, center?: number, from?: number, to?: number, rings?: number): number[][];
+export declare function capsuleProfile(radius: number, halfHeight: number): number[][];
+/** Heightfield triangles in local space, as the physics collider lays them out. */
+export declare function heightfieldTriangles(rows: number, cols: number, heights: ArrayLike<number>, hx: number, hy: number, hz: number): number[];
+/** A render mesh's triangles through a world matrix. */
+export declare function pushMesh(soup: TriangleSoup, mesh: Mesh, m: ArrayLike<number>, area: number): void;