bimatter-viewer-react 0.11.12 → 1.0.0

package/lib/utils/GeometryUtils/meshBoundsTree.d.ts

@@ -0,0 +1,23 @@
+import type { BufferGeometry } from "three";
+import { MeshBVH } from "three-mesh-bvh";
+import type { BmtGeomData } from "../../Loaders/BmtLoader";
+/**
+ * Geometry streamed in chunks from a loader worker is revealed with the
+ * progressive draw range, the same as before the BVH moved to the pool.
+ */
+export declare function shouldUseProgressiveDrawRange(data: BmtGeomData): boolean;
+/**
+ * BVH built for the geometry's original index, or null when it is not ready
+ * yet or was built for another index (e.g. after removeByIds).
+ *
+ * Indexes are compared by length: visibility tools only ever shorten them,
+ * while the WebGPU backend may replace an odd-length Uint16 index with an
+ * equal Uint32 copy.
+ */
+export declare function getMeshOriginalBoundsTree(geometry: BufferGeometry, index: ArrayLike<number>): MeshBVH | null;
+/**
+ * Attaches a MeshBVH to the mesh geometry without blocking the main thread:
+ * a worker-built tree is deserialized, otherwise the build runs in the BVH
+ * worker pool. Returns a cancel function for unmounts.
+ */
+export declare function attachMeshBoundsTree(data: BmtGeomData, geometry: BufferGeometry, onAttached: () => void): () => void;

package/lib/workers/BMTWorker.d.ts

@@ -1,5 +1,6 @@
 import { type BmtGeomData, type BmtModelData } from "../Loaders/BmtLoader";
 import { type WorkerProgressEvent } from "./ProgressUtils";
+import { type WorkerBoundsTreeSource } from "./WorkerGeometrySplit";
 export type BmtWorkerSource = {
     buffer: ArrayBuffer;
     kind: "buffer";
@@ -40,6 +41,7 @@ export type BmtWorkerResponse = {
     taskId: string;
     type: "error";
 } | {
+    bvhSource?: WorkerBoundsTreeSource;
     chunk: BmtWorkerGeometryChunk;
     taskId: string;
     type: "chunk";

package/lib/workers/BvhWorker.d.ts

@@ -0,0 +1,12 @@
+import type { BmtIndexArray, BmtSerializedMeshBVH } from "../Loaders/BmtLoader";
+export type BvhWorkerRequest = {
+    id: number;
+    ind: BmtIndexArray;
+    pos: Float32Array;
+    type: "build-bvh";
+};
+export type BvhWorkerResponse = {
+    boundsTree: BmtSerializedMeshBVH | null;
+    id: number;
+    type: "bvh";
+};

package/lib/workers/BvhWorkerPool.d.ts

@@ -0,0 +1,16 @@
+import type { BmtGeomData, BmtIndexArray, BmtSerializedMeshBVH } from "../Loaders/BmtLoader";
+/**
+ * Builds a serialized indirect MeshBVH in a background worker. The passed
+ * arrays are transferred, so callers must hand over copies they do not need.
+ * Resolves with null when workers are unavailable or the build failed.
+ */
+export declare function requestWorkerBoundsTree(pos: Float32Array, ind: BmtIndexArray): Promise<BmtSerializedMeshBVH | null>;
+export declare function setPendingBoundsTree(geometry: BmtGeomData, boundsTree: Promise<BmtSerializedMeshBVH | null>): Promise<BmtSerializedMeshBVH | null>;
+/**
+ * Registers geometry streamed from a loader worker together with its BVH
+ * build. The serialized tree is stored on the geometry like the worker used
+ * to send it, so collected models keep it.
+ */
+export declare function registerWorkerGeometryBoundsTree(geometry: BmtGeomData, boundsTree: Promise<BmtSerializedMeshBVH | null>): Promise<BmtSerializedMeshBVH | null>;
+export declare function isWorkerStreamedGeometry(geometry: BmtGeomData): boolean;
+export declare function getPendingBoundsTree(geometry: BmtGeomData): Promise<BmtSerializedMeshBVH | null> | null;

package/lib/workers/IFCWorker.d.ts

@@ -1,6 +1,7 @@
 import type { BmtGeomData, BmtModelData } from "../Loaders/BmtLoader";
 import { type IfcCoordinationMatrixSource } from "../Loaders/IFCLoader/IFCLoader";
 import { type WorkerProgressEvent } from "./ProgressUtils";
+import { type WorkerBoundsTreeSource } from "./WorkerGeometrySplit";
 export type IfcWorkerSource = {
     kind: "buffer";
     buffer: ArrayBuffer;
@@ -54,6 +55,7 @@ export type IfcWorkerResponse = {
     taskId: string;
     type: "complete";
 } | {
+    bvhSource?: WorkerBoundsTreeSource;
     chunk: IfcWorkerGeometryChunk;
     taskId: string;
     type: "chunk";

package/lib/workers/ProgressUtils.d.ts

@@ -20,6 +20,10 @@ export declare class WorkerProgressUtils {
     private readonly emit;
     private readonly taskId;
     private readonly totalModels;
+    private lastEmitTime;
+    private lastMessage;
+    private lastModelIndex;
+    private lastPhase;
     constructor(options: WorkerProgressOptions);
     emitModelProgress(modelIndex: number, modelName: string | undefined, phase: WorkerProgressPhase, modelProgress: number, data?: Pick<WorkerProgressEvent, "loaded" | "message" | "total">): void;
     emitError(message: string): void;

package/lib/workers/WorkerGeometrySplit.d.ts

@@ -0,0 +1,23 @@
+import type { BmtGeomData, BmtIndexArray } from "../Loaders/BmtLoader";
+export declare const WORKER_CHUNK_MAX_VERTICES = 262144;
+export type WorkerBoundsTreeSource = {
+    ind: BmtIndexArray;
+    pos: Float32Array;
+};
+/**
+ * Splits a large mesh into parts of about maxVertices at element boundaries.
+ * Requires elements to be stored as contiguous vertex runs (as the BMT and
+ * IFC builders write them); otherwise the geometry is returned as is.
+ */
+export declare function splitGeometryByElements(geometry: BmtGeomData, maxVertices?: number): BmtGeomData[];
+/**
+ * Keeps geometry IDs unique within a model. Split parts and duplicated IDs get
+ * new IDs from the top of the uint32 range, which BMT export writes as is.
+ */
+export declare class WorkerGeometryIDs {
+    private nextGeometryID;
+    private readonly usedGeometryIDs;
+    allocate(preferredGeometryID?: number): number;
+}
+export declare function createBoundsTreeSource(geometry: BmtGeomData): WorkerBoundsTreeSource;
+export declare function collectGeometryTransferables(geometry: BmtGeomData, buffers: Set<ArrayBuffer>): void;

package/lib/workers/WorkerMeshBvh.d.ts

@@ -1,3 +1,3 @@
-import type { BmtGeomData, BmtSerializedMeshBVH } from "../Loaders/BmtLoader";
-export declare function attachWorkerBoundsTree(geometryData: BmtGeomData): BmtGeomData;
+import type { BmtIndexArray, BmtSerializedMeshBVH } from "../Loaders/BmtLoader";
+export declare function buildSerializedBoundsTree(positions: Float32Array, indices: BmtIndexArray): BmtSerializedMeshBVH | null;
 export declare function collectBoundsTreeTransferables(boundsTree: BmtSerializedMeshBVH | undefined, buffers: Set<ArrayBuffer>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "bimatter-viewer-react",
-    "version": "0.11.12",
+    "version": "1.0.0",
     "license": "PolyForm-Noncommercial-1.0.0",
     "type": "module",
     "main": "./lib/index.js",