bimatter-viewer-react 0.11.12 → 1.0.1

package/lib/sharedMeshMaterials.d.ts

@@ -0,0 +1,24 @@
+import type { DataTexture, Material, Plane } from "three";
+import type { BmtMaterialData } from "./Loaders/BmtLoader";
+import type { ViewerMaterialMode } from "./types";
+/**
+ * Materials shared by the meshes of one model that look the same. The cache
+ * must stay per model: preselection writes the element id into the material
+ * uniforms of every mesh of the preselected model, so a material shared
+ * between models would highlight the same id in all of them.
+ *
+ * Keys include everything a material is built from, so a cache can outlive
+ * palette or renderer changes without handing out a mismatched material.
+ */
+export declare class SharedMeshMaterials {
+    private readonly materials;
+    get<T extends Material>(key: string, create: () => T): T;
+    dispose(): void;
+}
+export declare function getSharedMeshMaterialKey(renderer: "webgl" | "webgpu", colorPaletteTexture: DataTexture, material: BmtMaterialData, materialMode: ViewerMaterialMode, useDoubleSideMaterial: boolean): string;
+/**
+ * Gives a model material the current section planes before it is rendered,
+ * so a mesh added while clipping is active never shows up unclipped for a
+ * frame. It also compiles the shader with the planes right away.
+ */
+export declare function applyMaterialClippingPlanes(material: Material, planes: Plane[] | undefined): void;

package/lib/utils/ClippingUtils/ClippingUtils.d.ts

@@ -112,6 +112,11 @@ export declare class ClippingUtils {
     private getSelectedWorldBox;
     setControlsEnabled(enabled: boolean): void;
     setSelectionInteractionDisabled(disabled: boolean): void;
+    /**
+     * The plane array model materials reference: the live planes while
+     * clipping is active, so dragging a plane needs no material update.
+     */
+    getMaterialPlanes(): Plane[];
     updateMaterials(): void;
     setActive(active: boolean): void;
     toggle(): void;
@@ -140,6 +145,7 @@ export declare function useClippingUtils(modelRef: ViewerModelRef, controlRef: V
     getPlanVisualObjects: () => Object3D[];
     setCapsCameraMotionActive: (active: boolean) => void;
     setEdgesCameraMotionActive: (active: boolean) => void;
+    getMaterialPlanes: () => Plane[];
     setCapsPreselection: (preselection: ClippingPreselection) => void;
     syncWithModel: () => void;
 };

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/WorkerErrors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns a worker "error" event into an Error with whatever the browser told
+ * us. Errors thrown inside a running task come back as messages instead, so
+ * an event without a message usually means the worker script never started.
+ */
+export declare function createWorkerEventError(workerName: string, event: ErrorEvent): Error;

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.1",
     "license": "PolyForm-Noncommercial-1.0.0",
     "type": "module",
     "main": "./lib/index.js",