@xeokit/xeokit-sdk 2.6.95 → 2.6.97

package/src/viewer/scene/webgl/Renderer.js

@@ -17,6 +17,9 @@ const vec3_0 = math.vec3([0,0,0]);
 
 const iota = (n) => { const ret = [ ]; for (let i = 0; i < n; ++i) ret.push(i); return ret; };
 
+const tempPlanes = iota(6).map(() => math.vec4());
+const tempVec4 = math.vec4();
+
 const bitShiftScreenZ = math.vec4([1.0 / (256.0 * 256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0]);
 
 const pixelToInt = pix => pix[0] + (pix[1] << 8) + (pix[2] << 16) + (pix[3] << 24);
@@ -26,6 +29,66 @@ const toWorldPos    = (p, origin, scale) => math.vec3([ p[0] * scale[0] + origin
                                                         p[1] * scale[1] + origin[1],
                                                         p[2] * scale[2] + origin[2] ]);
 
+const makeFrustumAABBIntersectionTest = function(camera) {
+    const m = math.mat4();
+    math.mulMat4(camera.projMatrix, camera.viewMatrix, m);
+
+    for (let i = 0; i < 3; ++i) {
+        tempPlanes[i * 2 + 0][0] = m[ 3] + m[i];
+        tempPlanes[i * 2 + 0][1] = m[ 7] + m[i + 4];
+        tempPlanes[i * 2 + 0][2] = m[11] + m[i + 8];
+        tempPlanes[i * 2 + 0][3] = m[15] + m[i + 12];
+
+        tempPlanes[i * 2 + 1][0] = m[ 3] - m[i];
+        tempPlanes[i * 2 + 1][1] = m[ 7] - m[i + 4];
+        tempPlanes[i * 2 + 1][2] = m[11] - m[i + 8];
+        tempPlanes[i * 2 + 1][3] = m[15] - m[i + 12];
+    }
+
+    // Normalize each plane
+    tempPlanes.forEach(p => math.divVec4Scalar(p, math.lenVec3(p), p));
+
+    return aabb => tempPlanes.every(p => {
+        // Compute the positive vertex (farthest in direction of normal)
+        tempVec4[0] = aabb[(p[0] >= 0) ? 3 : 0];
+        tempVec4[1] = aabb[(p[1] >= 0) ? 4 : 1];
+        tempVec4[2] = aabb[(p[2] >= 0) ? 5 : 2];
+        tempVec4[3] = 1;
+        return math.dotVec4(p, tempVec4) >= 0;
+    });
+};
+
+const makeRayAABBIntersectionTest = (O, D) => aabb => {
+    let tmin = -Infinity;
+    let tmax = Infinity;
+
+    for (let i = 0; i < 3; i++) {
+        const origin = O[i];
+        const direction = D[i];
+        const minBound = aabb[i];
+        const maxBound = aabb[i + 3];
+
+        if (Math.abs(direction) < 1e-8) {
+            // Ray is parallel to plane
+            if ((origin < minBound) || (origin > maxBound)) {
+                return false; // No intersection
+            }
+        } else {
+            const t1 = (minBound - origin) / direction;
+            const t2 = (maxBound - origin) / direction;
+
+            tmin = Math.max(tmin, Math.min(t1, t2)); // near
+            tmax = Math.min(tmax, Math.max(t1, t2)); // far
+
+            if (tmin > tmax) {
+                return false; // No intersection
+            }
+        }
+    }
+
+    return tmax >= 0; // Check if intersection is in front of ray
+};
+
 /**
  * @private
  */
@@ -789,6 +852,8 @@ const Renderer = function (scene, options) {
             gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
         }
 
+        frameCtx.testAABB = makeFrustumAABBIntersectionTest(scene.camera);
+
         const renderDrawables = function(drawables) {
 
         let normalDrawSAOBinLen = 0;
@@ -1123,6 +1188,8 @@ const Renderer = function (scene, options) {
             renderDrawables(uiDrawableList);
         }
 
+        frameCtx.testAABB = null;
+
         const endTime = Date.now();
         const frameStats = stats.frame;
 
@@ -1231,11 +1298,16 @@ const Renderer = function (scene, options) {
 
                 pickResult.canvasPos = params.canvasPos;
 
+                math.canvasPosToWorldRay(canvas, pickViewMatrix, pickProjMatrix, projection, canvasPos, tempVec3a, tempVec3b);
+                frameCtx.testAABB = makeRayAABBIntersectionTest(tempVec3a, tempVec3b);
             } else {
 
                 // Picking with arbitrary World-space ray
                 // Align camera along ray and fire ray through center of canvas
 
+                canvasPos[0] = canvas.clientWidth * 0.5;
+                canvasPos[1] = canvas.clientHeight * 0.5;
+
                 if (params.matrix) {
 
                     pickViewMatrix = params.matrix;
@@ -1245,6 +1317,8 @@ const Renderer = function (scene, options) {
                     nearAndFar[0] = camera.project.near;
                     nearAndFar[1] = camera.project.far;
 
+                    math.canvasPosToWorldRay(canvas, pickViewMatrix, pickProjMatrix, projection, canvasPos, tempVec3a, tempVec3b);
+                    frameCtx.testAABB = makeRayAABBIntersectionTest(tempVec3a, tempVec3b);
                 } else {
 
                     worldRayOrigin.set(params.origin || [0, 0, 0]);
@@ -1273,10 +1347,9 @@ const Renderer = function (scene, options) {
 
                     pickResult.origin = worldRayOrigin;
                     pickResult.direction = worldRayDir;
-                }
 
-                canvasPos[0] = canvas.clientWidth * 0.5;
-                canvasPos[1] = canvas.clientHeight * 0.5;
+                    frameCtx.testAABB = makeRayAABBIntersectionTest(pickResult.origin, pickResult.direction);
+                }
             }
 
             pickBuffer.bind();
@@ -1313,6 +1386,8 @@ const Renderer = function (scene, options) {
                 renderDrawables(uiDrawableList);
             }
 
+            frameCtx.testAABB = null;
+
             const pickID = pixelToInt(pickBuffer.read(0, 0));
             const pickable = (pickID >= 0) && pickIDs.items[pickID];
 
@@ -1844,4 +1919,4 @@ const Renderer = function (scene, options) {
     };
 };
 
-export {Renderer};
+export {Renderer};

package/types/plugins/IFCOpenShellLoaderPlugin/IFCOpenShellLoaderPlugin.d.ts

@@ -0,0 +1,107 @@
+import { Plugin, Viewer, SceneModel } from "../../viewer";
+import { ModelStats } from "../index";
+
+/**
+ * Default data source for loading IFC files in IFCOpenShellLoaderPlugin.
+ * Loads files via HTTP by default.
+ */
+export declare interface IFCOpenShellDefaultDataSource {
+  /**
+   * Loads the contents of the given IFC file as an ArrayBuffer.
+   * @param src Path or ID of the IFC file.
+   * @param ok Callback on success, receives the IFC file as an ArrayBuffer.
+   * @param error Callback on error, receives an Error.
+   */
+  getIFC(src: string | number, ok: (buffer: ArrayBuffer) => void, error: (e: Error) => void): void;
+
+  /** Whether to append a cache-busting query parameter to requests. */
+  get cacheBuster(): boolean;
+  set cacheBuster(value: boolean);
+}
+
+/**
+ * Configuration options for IFCOpenShellLoaderPlugin.
+ */
+export declare type IFCOpenShellLoaderPluginConfigs = {
+  /** Optional plugin ID. */
+  id?: string;
+  /** Custom data source for loading IFC files. */
+  dataSource?: IFCOpenShellDefaultDataSource;
+  /** Pyodide proxy for the ifcopenshell module. */
+  ifcopenshell: any;
+  /** Pyodide proxy for the ifcopenshell.geom module. */
+  ifcopenshell_geom: any;
+};
+
+/**
+ * Parameters for loading an IFC model with IFCOpenShellLoaderPlugin.
+ */
+export declare type LoadIFCOpenShellModel = {
+  /** Unique ID for the loaded SceneModel. */
+  id?: string;
+  /** Path to the IFC file. */
+  src?: string;
+  /** Whether to load IFC metadata (metaobject). */
+  loadMetadata?: boolean;
+  /** Whether to load IFC metadata property sets. Only works when `loadMetadata` is `true`. */
+  loadMetadataPropertySets?: boolean;
+  /** Exclude objects with types in this list. */
+  excludeTypes?: string[];
+  /** Render the model with edges emphasized. */
+  edges?: boolean;
+  /** World-space double-precision origin for the model. */
+  origin?: number[];
+  /** Single-precision position offset, relative to origin. */
+  position?: number[];
+  /** Model scale. */
+  scale?: number[];
+  /** Model orientation as Euler angles (degrees) for X, Y, Z. */
+  rotation?: number[];
+  /** Enable Scalable Ambient Obscurance (SAO) for the model. */
+  saoEnabled?: boolean;
+  /** Force rendering of backfaces for the model. */
+  backfaces?: boolean;
+  /** Globalize Entity and MetaObject IDs to avoid clashes. */
+  globalizeObjectIds?: boolean;
+  /** Collect model statistics. */
+  stats?: ModelStats;
+    /** Indicates if compact data texture scene representation is enabled for this model. */
+  dtxEnabled?: boolean;
+};
+
+/**
+ * Viewer plugin that uses IfcOpenShell to load BIM models directly from IFC files.
+ */
+export declare class IFCOpenShellLoaderPlugin extends Plugin {
+  /**
+   * Creates a new IFCOpenShellLoaderPlugin.
+   * @param viewer The Viewer instance.
+   * @param cfg Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?: IFCOpenShellLoaderPluginConfigs);
+
+  /**
+   * Sets a custom data source for loading IFC files.
+   * Default is IFCOpenShellDefaultDataSource, which loads via HTTP.
+   */
+  set dataSource(arg: IFCOpenShellDefaultDataSource);
+
+  /**
+   * Gets the current data source for loading IFC files.
+   * Default is IFCOpenShellDefaultDataSource, which loads via HTTP.
+   */
+  get dataSource(): IFCOpenShellDefaultDataSource;
+
+  /**
+   * Gets whether object and metaobject IDs are globalized to avoid clashes.
+   * Default is false.
+   */
+  get globalizeObjectIds(): boolean;
+
+  /**
+   * Loads an IFC model into the Viewer's scene.
+   * @param params Loading parameters.
+   * @returns SceneModel representing the loaded model.
+   */
+  load(params?: LoadIFCOpenShellModel): SceneModel;
+}

package/types/plugins/IFCOpenShellLoaderPlugin/index.d.ts

@@ -0,0 +1 @@
+export * from './IFCOpenShellLoaderPlugin';

package/types/plugins/index.d.ts

@@ -8,6 +8,7 @@ export * from "./DistanceMeasurementsPlugin";
 export * from "./DotBIMLoaderPlugin";
 export * from "./FastNavPlugin";
 export * from "./GLTFLoaderPlugin";
+export * from "./IFCOpenShellLoaderPlugin";
 export * from "./LASLoaderPlugin";
 export * from "./NavCubePlugin";
 export * from "./OBJLoaderPlugin";

package/types/viewer/scene/CameraControl/CameraControl.d.ts

@@ -170,20 +170,20 @@ export declare class CameraControl extends Component {
    *
    * See class docs for usage.
    *
-   * @param {{Number:Number}|String} value Either a set of new key mappings, or a string to select a keyboard layout,
+   * @param {{Number:(Number | Number[])[]} | String} value Either a set of new key mappings, or a string to select a keyboard layout,
    * which causes ````CameraControl```` to use the default key mappings for that layout.
    */
   set keyMap(arg: {
-    [key: number]: number;
-  });
+    [key: number]: (number | number[])[];
+  } | string);
 
   /**
    * Gets custom mappings of keys to {@link CameraControl} actions.
    *
-   * @returns {{Number:Number}} Current key mappings.
+   * @returns {{Number:(Number | Number[])[]}} Current key mappings.
    */
   get keyMap(): {
-    [key: number]: number;
+    [key: number]: (number | number[])[];
   };
 
   /**