opengeometry 2.0.18 → 3.0.0

package/src/rendering/lod/lod-controller.d.ts

@@ -0,0 +1,75 @@
+import * as THREE from 'three';
+import type { Body } from '../../bodies/body.js';
+import { type Runtime } from '../../runtime/runtime-state.js';
+type Tiers = {
+    temporary: number | undefined;
+    own: number | undefined;
+    global: number | undefined;
+};
+type SeenCamera = {
+    camera: THREE.Camera;
+    height: number;
+};
+type TemporaryTarget = {
+    deflection: number;
+};
+type PassInputs = {
+    revision: bigint;
+    flushed: bigint;
+    moving: boolean;
+    displayed: number;
+    groups: number[];
+};
+type ShapeLod = {
+    shapeId: string;
+    target?: number;
+    previous?: number;
+    failed: Set<string>;
+    pinned?: {
+        revision: number;
+        bucket: number;
+    };
+    forced?: number;
+    error?: {
+        revision: number;
+        error: unknown;
+    };
+    overrides?: {
+        pass: number;
+        tiers: Tiers;
+    };
+};
+export type LodState = {
+    shapes: Map<string, ShapeLod>;
+    camera: Float64Array;
+    frames: WeakMap<THREE.WebGLRenderer, number>;
+    bufferSize: THREE.Vector2;
+    initialised: boolean;
+    lastMotion: number;
+    lastSchedule: number;
+    settleTimer?: ReturnType<typeof setTimeout>;
+    lastSeen?: SeenCamera;
+    temporaries: TemporaryTarget[];
+    stale: boolean;
+    evaluated?: PassInputs;
+    drawn: Set<Body>;
+    walked: WeakMap<Body, number>;
+    refresh: () => void;
+};
+export declare function createLodState(refresh: () => void): LodState;
+export declare function observe(state: Runtime, camera: THREE.Camera, height: number, now: number): void;
+export declare function motionHint(state: Runtime, now: number): void;
+export declare function settleNow(state: Runtime): void;
+export declare function evaluatePass(state: Runtime, now: number, forced: boolean): boolean;
+export declare function wantedKey(state: Runtime, body: Body): number | undefined;
+export declare function overrideChanged(state: Runtime, shapeId?: string): void;
+export declare function pushTemporaryTarget(state: Runtime, deflection: number): TemporaryTarget;
+export declare function popTemporaryTarget(state: Runtime, token: TemporaryTarget): void;
+export declare function markFailed(state: Runtime, shapeId: string, revision: number, bucket: number): boolean;
+export declare function retryBucket(state: Runtime, shapeId: string, revision: number): number | undefined;
+export declare function shapePriority(state: Runtime, shapeId: string): number;
+export declare function recordError(state: Runtime, shapeId: string, revision: number, error: unknown): void;
+export declare function clearError(state: Runtime, shapeId: string, revision: number): void;
+export declare function capturedError(state: Runtime, body: Body): unknown;
+export declare function forceNextBucket(state: Runtime, shapeId: string, bucket: number): void;
+export {};

package/src/rendering/lod/screen-metrics.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function worldUnitsPerPixel(camera: THREE.Camera, bounds: [number, number, number, number, number, number], height: number): number;

package/src/rendering/materials/material-pool.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { type PoolEntry, type PooledMaterial } from './ref-counted-pool.js';
+export type MaterialAppearance = {
+    color: number;
+    opacity: number;
+};
+export type SurfaceEntry = PoolEntry<THREE.MeshStandardMaterial>;
+export type LineEntry = PoolEntry<THREE.LineBasicMaterial>;
+export declare function surfaceMaterial(value: MaterialAppearance): PooledMaterial<THREE.MeshStandardMaterial>;
+export declare function lineMaterial(value: MaterialAppearance): PooledMaterial<THREE.LineBasicMaterial>;
+export declare function releaseSurface(key: string): void;
+export declare function releaseLine(key: string): void;

package/src/rendering/materials/ref-counted-pool.d.ts

@@ -0,0 +1,12 @@
+export type PoolEntry<M> = {
+    material: M;
+    refs: number;
+};
+export type PooledMaterial<M> = {
+    key: string;
+    material: M;
+};
+export declare function acquire<M>(pool: Map<string, PoolEntry<M>>, key: string, create: () => M): PooledMaterial<M>;
+export declare function release<M extends {
+    dispose(): void;
+}>(pool: Map<string, PoolEntry<M>>, key: string): void;

package/src/rendering/provider.d.ts

@@ -0,0 +1,19 @@
+import type { DisplayBuffers } from '../dto/display-buffers.js';
+export type TessellationRequest = {
+    shapeId: string;
+    revision: number;
+    bucket: number;
+    priority: number;
+    maxTriangles: number;
+    smoothAngle?: number | undefined;
+    generation: number;
+};
+export type TessellationProvider = {
+    readonly activeBackend: 'worker' | 'inline';
+    ensureSnapshot(shapeId: string, revision: number): Promise<void>;
+    request(value: TessellationRequest): Promise<DisplayBuffers>;
+    cancelShape(shapeId: string, generation: number): void;
+    drop(shapeId: string, revision: number): void;
+    dispose(): void;
+    compute?(value: TessellationRequest): DisplayBuffers;
+};

package/src/rendering/records/geometry-record.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import type { DisplayBuffers } from '../../dto/display-buffers.js';
+export declare function recordKey(shapeId: string, revision: number, bucket: number, smoothAngle?: number): string;
+export declare class GeometryRecord {
+    readonly shapeId: string;
+    readonly key: string;
+    readonly surface: THREE.BufferGeometry | null;
+    readonly outline: THREE.BufferGeometry;
+    readonly origin: THREE.Vector3;
+    readonly faceRanges: Uint32Array;
+    readonly edgeIds: Uint32Array;
+    readonly smoothEdges: Uint8Array;
+    readonly revision: number;
+    readonly bucket: number;
+    readonly triangles: number;
+    readonly bytes: number;
+    refs: number;
+    lastUse: number;
+    constructor(shapeId: string, buffers: DisplayBuffers, smoothAngle?: number);
+    dispose(): void;
+}

package/src/rendering/records/record-pool.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+import type { Bounds } from '../../dto/bounds.js';
+import { type GeometryRecord } from './geometry-record.js';
+export declare class RecordPool {
+    private records;
+    private byShape;
+    private idle;
+    private idleBytes;
+    private placeholders;
+    private placeholderOf;
+    private clock;
+    get(shapeId: string, revision: number, bucket: number, smoothAngle?: number): GeometryRecord | undefined;
+    put(record: GeometryRecord): GeometryRecord;
+    retain(record: GeometryRecord): void;
+    release(record: GeometryRecord): void;
+    purge(shapeId: string, revision?: number): void;
+    releaseIdle(): {
+        records: number;
+        bytes: number;
+    };
+    placeholder(shapeId: string, revision: number, bounds: () => Bounds | null): THREE.BufferGeometry;
+    releasePlaceholder(geometry: THREE.BufferGeometry): boolean;
+    clear(): void;
+    private owns;
+    private touch;
+    private setIdle;
+    private drop;
+    private evict;
+}

package/src/rendering/records/validate-display-buffers.d.ts

@@ -0,0 +1,2 @@
+import type { DisplayBuffers } from '../../dto/display-buffers.js';
+export declare function validateDisplayBuffers(value: unknown): DisplayBuffers;

package/src/rendering/tessellation-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/src/rendering/worker/job-queue.d.ts

@@ -0,0 +1,8 @@
+import type { TessellateMessage } from '../worker-protocol.js';
+export declare class JobQueue {
+    private readonly jobs;
+    get size(): number;
+    push(job: TessellateMessage): number | undefined;
+    cancel(shapeId: string, generation: number): number | undefined;
+    next(): TessellateMessage | undefined;
+}

package/src/rendering/worker/message-guards.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerMessage } from '../worker-protocol.js';
+export type GuardFailure = {
+    request: number | undefined;
+    error: {
+        code: 'InvalidParameter';
+        message: string;
+    };
+};
+export declare function parseWorkerMessage(data: unknown): WorkerMessage | GuardFailure;

package/src/rendering/worker/snapshot-cache.d.ts

@@ -0,0 +1,10 @@
+import type { OGTessellator } from '../../kernel/kernel-loader.js';
+export declare class SnapshotCache {
+    private readonly entries;
+    private totalBytes;
+    private clock;
+    load(key: string, bytes: Uint8Array, tessellator: OGTessellator): void;
+    drop(key: string, tessellator: OGTessellator): void;
+    touch(key: string): number | undefined;
+    evict(except: string, tessellator: OGTessellator): string[];
+}

package/src/rendering/worker-backend.d.ts

@@ -0,0 +1,44 @@
+import type { DisplayBuffers } from '../dto/display-buffers.js';
+import { OGError } from '../errors.js';
+import type { OGWorldGraph } from '../kernel/kernel-loader.js';
+import type { TessellationProvider, TessellationRequest } from './provider.js';
+export type WorkerSend = {
+    kind: 'tessellate';
+    shapeId: string;
+    bucket: number;
+    priority: number;
+    generation: number;
+};
+export declare class WorkerBackend implements TessellationProvider {
+    private graph;
+    private module;
+    private workerURL;
+    private onFailure;
+    readonly activeBackend: "worker";
+    readonly sendLog: WorkerSend[];
+    private live;
+    private nextRequest;
+    private pending;
+    private snapshots;
+    private latestGenerations;
+    private readonly ready;
+    private restarts;
+    private failed;
+    private disposed;
+    private fallback;
+    constructor(graph: OGWorldGraph, module: WebAssembly.Module, workerURL: string | URL, onFailure: (error: OGError) => void);
+    get worker(): Worker | undefined;
+    private boot;
+    private crash;
+    private fail;
+    private drain;
+    private receive;
+    private send;
+    private recordSend;
+    ensureSnapshot(shapeId: string, revision: number): Promise<void>;
+    request(value: TessellationRequest): Promise<DisplayBuffers>;
+    private buffersFrom;
+    cancelShape(shapeId: string, generation: number): void;
+    drop(shapeId: string, revision: number): void;
+    dispose(): void;
+}

package/src/rendering/worker-protocol.d.ts

@@ -0,0 +1,52 @@
+import type { DisplayBuffers } from '../dto/display-buffers.js';
+import type { TessellationRequest } from './provider.js';
+export type WorkerError = {
+    code: string;
+    message: string;
+    details?: unknown;
+};
+export type SnapshotMessage = {
+    kind: 'snapshot';
+    request: number;
+    shapeId: string;
+    revision: number;
+    bytes: Uint8Array;
+};
+export type TessellateMessage = TessellationRequest & {
+    kind: 'tessellate';
+    request: number;
+};
+export type WorkerMessage = {
+    kind: 'init';
+    request: 0;
+    module: WebAssembly.Module;
+} | SnapshotMessage | TessellateMessage | {
+    kind: 'cancel';
+    shapeId: string;
+    generation: number;
+} | {
+    kind: 'drop';
+    shapeId: string;
+    revision: number;
+};
+export type WorkerReply = {
+    request: number;
+    ok: true;
+} | {
+    request: number;
+    ok: true;
+    buffers: DisplayBuffers;
+} | {
+    request: number | undefined;
+    error: WorkerError;
+} | {
+    request: number;
+    superseded: true;
+} | {
+    request: number;
+    missingSnapshot: true;
+} | {
+    kind: 'evicted';
+    shapeId: string;
+    revision: number;
+};

package/src/runtime/create-runtime.d.ts

@@ -0,0 +1,7 @@
+import { type CreateOptions, type Runtime } from './runtime-state.js';
+export type KernelInput = {
+    wasmURL?: string | URL;
+    wasmModule?: WebAssembly.Module;
+};
+export declare function createRuntimeOnce(input: KernelInput, options: CreateOptions): Promise<Runtime>;
+export declare function createRuntime(module: WebAssembly.Module, options: CreateOptions): Runtime;

package/src/runtime/event-bus.d.ts

@@ -0,0 +1,3 @@
+import type { Events, Listener } from '../dto/events.js';
+export declare function on(event: Events, handler: Listener): () => boolean;
+export declare function emit(event: Events, detail: unknown): void;

package/src/runtime/reset.d.ts

@@ -0,0 +1 @@
+export declare function reset(): void;

package/src/runtime/runtime-state.d.ts

@@ -0,0 +1,68 @@
+import type { Body } from '../bodies/body.js';
+import type { Bounds } from '../dto/bounds.js';
+import type { Events, Listener } from '../dto/events.js';
+import type { OGWorldGraph } from '../kernel/kernel-loader.js';
+import type { OGMark } from '../marks/og-mark.js';
+import type { HostGroups } from '../rendering/lod/host-groups.js';
+import type { LodState } from '../rendering/lod/lod-controller.js';
+import type { LineEntry, SurfaceEntry } from '../rendering/materials/material-pool.js';
+import type { TessellationProvider } from '../rendering/provider.js';
+import type { RecordPool } from '../rendering/records/record-pool.js';
+export type CreateOptions = {
+    workerURL?: string | URL;
+    tessellation?: 'worker' | 'inline';
+};
+export type LimboEntry = {
+    watermark: number;
+    parent: Body['parent'];
+};
+export type Runtime = {
+    graph: OGWorldGraph;
+    provider: TessellationProvider;
+    records: RecordPool;
+    bodies: Map<string, Body>;
+    pickTargets: WeakMap<object, Body>;
+    byShape: Map<string, Set<Body>>;
+    limbo: Map<Body, LimboEntry>;
+    listeners: Map<Events, Set<Listener>>;
+    revision: bigint;
+    readyShapes: Set<string>;
+    renderPassActive: boolean;
+    graphMoved: boolean;
+    pass: number;
+    displayed: Map<Body, number>;
+    hostDrawn: WeakMap<Body, boolean>;
+    groups: HostGroups;
+    pending: Map<string, Promise<void>>;
+    generations: Map<string, number>;
+    shapeBuckets: Map<string, {
+        revision: number;
+        floor: number;
+        static: number;
+        error?: unknown;
+    }>;
+    displayBounds: Map<Body, {
+        revision: bigint;
+        bounds: Bounds | null;
+    }>;
+    lod: LodState;
+    module: WebAssembly.Module;
+    createOptions: CreateOptions;
+    displayDeflection?: number;
+    poisoned: boolean;
+    flushes: number;
+    marks: Map<number, OGMark>;
+    flushing: boolean;
+    surfacePool: Map<string, SurfaceEntry>;
+    linePool: Map<string, LineEntry>;
+    epoch: number;
+};
+export declare function runtime(): Runtime;
+export declare function currentRuntime(): Runtime | undefined;
+export declare function setRuntime(value: Runtime | undefined): void;
+export declare function pendingCreate(): Promise<Runtime> | undefined;
+export declare function setPendingCreate(value: Promise<Runtime> | undefined): void;
+export declare function nextEpoch(): number;
+export declare function bodyKey(handle: number, generation: number): string;
+export declare function reindexShape(state: Runtime, body: Body, previousShapeId: string | null): void;
+export declare function releaseShapeIfEmpty(state: Runtime, shapeId: string, revision: number): void;

package/src/testing/internals.d.ts

@@ -0,0 +1,18 @@
+import type { Body } from '../bodies/body.js';
+import { type WorkerSend } from '../rendering/worker-backend.js';
+export { register, unregister } from '../bodies/body-registry.js';
+export { ensureGeometry, flush, wanted } from '../rendering/geometry/geometry-scheduler.js';
+export { noteDisplayed } from '../rendering/geometry/render-pass.js';
+export { wantedBucket } from '../rendering/lod/deflection.js';
+export { parseWorkerMessage } from '../rendering/worker/message-guards.js';
+export { emit } from '../runtime/event-bus.js';
+export { currentRuntime, runtime } from '../runtime/runtime-state.js';
+export { worldGraph as graph } from '../world-graph/world-graph-client.js';
+export declare function activeBackend(): 'worker' | 'inline';
+export declare function flushCount(): number;
+export declare function displayed(body: Body): boolean;
+export declare function pinWantedBucket(shapeId: string, bucket: number): void;
+export declare function workerSendLog(): WorkerSend[];
+export declare function postToWorker(message: unknown, options?: {
+    awaitCrash?: boolean;
+}): Promise<void>;

package/src/world-graph/codec.d.ts

@@ -0,0 +1,45 @@
+import type { ShapeReport } from '../dto/boolean-report.js';
+import type { Bounds } from '../dto/bounds.js';
+import type { Brep } from '../dto/brep.js';
+import type { ChangeSet } from '../dto/change-set.js';
+import type { Creation } from '../dto/creation.js';
+import type { AnalyticExchangeBodyV2 } from '../dto/ifc-body.js';
+import type { MarkStats } from '../dto/mark-stats.js';
+import type { NodeInfo } from '../dto/node-info.js';
+import type { Placement } from '../dto/placement.js';
+import type { CurvedRegion2D, OffsetPath2D, OffsetRegion, RegionOperation } from '../dto/regions.js';
+import type { StepExport } from '../dto/step-export.js';
+export declare function encode(value: unknown): string;
+export declare function scope(options?: {
+    instances?: 'all';
+}): string;
+export declare function operationParams(kind: string, params: Record<string, unknown>, call: string): Record<string, unknown>;
+export declare function polylinePoints(params: Record<string, unknown>, call: string): Float64Array;
+export declare function regionsJson(regions: unknown, call: string): string;
+export declare function regionOperation(value: unknown, call: string): RegionOperation;
+export declare function curvedRegionsJson(regions: unknown, call: string): string;
+export declare function numberList(value: unknown, call: string, label: string): Float64Array;
+export declare function offsetHolesJson(holes: unknown, call: string): string;
+export declare function decodeOffsetPath(text: string, call: string): OffsetPath2D;
+export declare function decodeRegions(text: string, call: string): OffsetRegion[];
+export declare function decodeCurvedRegions(text: string, call: string): CurvedRegion2D[];
+export declare function decodeNodeInfo(text: string, call: string): NodeInfo;
+export declare function decodeCreation(text: string, call: string): Creation;
+export declare function decodePlacement(text: string, call: string): Placement;
+export declare function decodeChildren(text: string, call: string): string[];
+export declare function decodeParent(text: string, call: string): string | null;
+export declare function decodeBounds(text: string, call: string): Bounds | null;
+export declare function decodeIfcBody(text: string, call: string): AnalyticExchangeBodyV2;
+export declare function decodeBrep(text: string, call: string): Brep;
+export declare function decodeShapeReport(text: string, call: string): ShapeReport | null;
+export declare function decodeMarkStats(text: string, call: string): MarkStats;
+export declare function decodeDisplayBuckets(text: string, call: string): {
+    floor: number;
+    static: number;
+};
+export declare function decodeChangeSet(packet: unknown, call: string): {
+    changes: ChangeSet;
+    matrices: Float64Array;
+};
+export declare function decodeChanges(text: string, call: string): ChangeSet;
+export declare function decodeStepExport(value: unknown, call: string): StepExport;

package/src/world-graph/world-graph-client.d.ts

@@ -0,0 +1,13 @@
+import type { NodeInfo } from '../dto/node-info.js';
+import type { OGWorldGraph } from '../kernel/kernel-loader.js';
+export declare function worldGraph(): OGWorldGraph;
+export declare function node(ogId: string, label: string): NodeInfo;
+export declare function checkHandle(label: string, target: {
+    handle: number;
+    generation: number;
+}): void;
+export declare function creation(value: string, label: string): string;
+export declare function displayBuckets(ogId: string, label: string): {
+    floor: number;
+    static: number;
+};