@xeokit/xeokit-sdk 2.6.65 → 2.6.67

package/src/viewer/scene/sectionCaps/index.js

@@ -0,0 +1 @@
+export * from "./SectionCaps.js";

package/src/viewer/scene/sectionPlane/SectionPlane.js

@@ -3,6 +3,11 @@ import {RenderState} from '../webgl/RenderState.js';
 import {math} from "../math/math.js";
 
 const tempVec3a = math.vec3();
+const tempVec3b = math.vec3();
+const tempVec4a = math.vec4();
+const front = math.vec3([0,  0, -1]);
+const back  = math.vec3([0,  0,  1]);
+const up    = math.vec3([0,  1,  0]);
 
 /**
  *  @desc An arbitrarily-aligned World-space clipping plane.
@@ -74,6 +79,8 @@ class SectionPlane extends Component {
         this._state = new RenderState({
             active: true,
             pos: math.vec3(),
+            quaternion: math.vec4(),
+            roll: 0,
             dir: math.vec3(),
             dist: 0
         });
@@ -135,6 +142,59 @@ class SectionPlane extends Component {
         return this._state.pos;
     }
 
+    /**
+     * Sets the quaternion of this SectionPlane's plane.
+     *
+     * Default value is ````[0, -1, 0, 0]````.
+     *
+     * @param {Number[]} value New quaternion.
+     */
+    set quaternion(value) {
+        this._state.quaternion.set(value || [0, 0, 0, -1]);
+        math.vec3ApplyQuaternion(this._state.quaternion, back, this._state.dir);
+        const quatUp = math.vec3ApplyQuaternion(this._state.quaternion, up, tempVec3a);
+        const dirOnlyQ = math.vec3PairToQuaternion(back, this._state.dir, tempVec4a);
+        const dirOnlyUp = math.vec3ApplyQuaternion(dirOnlyQ, up, tempVec3b);
+        const angle = Math.acos(Math.min(1, math.dotVec3(quatUp, dirOnlyUp)));
+        const sign = Math.sign(math.dotVec3(this._state.dir, math.cross3Vec3(quatUp, dirOnlyUp, tempVec3b)));
+        this._state.roll = sign * angle;
+        this._onDirUpdated();
+    }
+
+    /**
+     * Gets the quaternion of this SectionPlane's plane.
+     *
+     * Default value is ````[0, -1, 0, 0]````.
+     *
+     * @returns {Number[]} value Current quaternion.
+     */
+    get quaternion() {
+        return this._state.quaternion;
+    }
+
+    /**
+     * Sets the roll of this SectionPlane's plane.
+     *
+     * Default value is ````0````.
+     *
+     * @param {Number[]} value New roll.
+     */
+    set roll(value) {
+        this._state.roll = value || 0;
+        this._onDirRollUpdated();
+    }
+
+    /**
+     * Gets the roll of this SectionPlane's plane.
+     *
+     * Default value is ````0````.
+     *
+     * @returns {Number[]} value Current roll.
+     */
+    get roll() {
+        return this._state.roll;
+    }
+
     /**
      * Sets the direction of this SectionPlane's plane.
      *
@@ -143,7 +203,25 @@ class SectionPlane extends Component {
      * @param {Number[]} value New direction.
      */
     set dir(value) {
-        this._state.dir.set(value || [0, 0, -1]);
+        this._state.dir.set(value || front);
+        this._onDirRollUpdated();
+    }
+
+    _onDirRollUpdated() {
+        math.vec3PairToQuaternion(back, this._state.dir, this._state.quaternion);
+
+        tempVec4a[0] = 0;
+        tempVec4a[1] = 0;
+        tempVec4a[2] = -1;
+        tempVec4a[3] = this._state.roll;
+        math.angleAxisToQuaternion(tempVec4a, tempVec4a);
+
+        math.mulQuaternions(this._state.quaternion, tempVec4a, this._state.quaternion);
+
+        this._onDirUpdated();
+    }
+
+    _onDirUpdated() {
         this._state.dist = (-math.dotVec3(this._state.pos, this._state.dir));
         this.glRedraw();
         this.fire("dir", this._state.dir);

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

@@ -935,6 +935,9 @@ const Renderer = function (scene, options) {
                 pickProjMatrix = scene.camera.projMatrix;
                 projection     = scene.camera.projection;
 
+                nearAndFar[0] = scene.camera.project.near;
+                nearAndFar[1] = scene.camera.project.far;
+
                 pickResult.canvasPos = params.canvasPos;
 
             } else {
@@ -948,6 +951,9 @@ const Renderer = function (scene, options) {
                     pickProjMatrix = scene.camera.projMatrix;
                     projection     = scene.camera.projection;
 
+                    nearAndFar[0] = scene.camera.project.near;
+                    nearAndFar[1] = scene.camera.project.far;
+
                 } else {
 
                     worldRayOrigin.set(params.origin || [0, 0, 0]);
@@ -967,6 +973,9 @@ const Renderer = function (scene, options) {
                     pickProjMatrix = scene.camera.ortho.matrix;
                     projection     = "ortho";
 
+                    nearAndFar[0] = scene.camera.ortho.near;
+                    nearAndFar[1] = scene.camera.ortho.far;
+
                     pickResult.origin = worldRayOrigin;
                     pickResult.direction = worldRayDir;
                 }
@@ -1021,9 +1030,6 @@ const Renderer = function (scene, options) {
 
                     if (pickable.canPickWorldPos && pickable.canPickWorldPos()) {
 
-                        nearAndFar[0] = scene.camera.project.near;
-                        nearAndFar[1] = scene.camera.project.far;
-
                         gpuPickWorldPos(pickBuffer, pickable, canvasPos, pickViewMatrix, pickProjMatrix, nearAndFar, pickResult);
 
                         if (params.pickSurfaceNormal !== false) {
@@ -1296,13 +1302,16 @@ const Renderer = function (scene, options) {
 
             const snapRadiusInPixels = snapRadius || 30;
 
-            const vertexPickBuffer = renderBufferManager.getRenderBuffer("uniquePickColors-aabs", {
-                depthTexture: true,
-                size: [
-                    2 * snapRadiusInPixels + 1,
-                    2 * snapRadiusInPixels + 1,
-                ]
-            });
+            const vertexPickBuffer = renderBufferManager.getRenderBuffer(
+                `uniquePickColors-aabs-${snapRadiusInPixels}`,
+                {
+                    depthTexture: true,
+                    size: [
+                        2 * snapRadiusInPixels + 1,
+                        2 * snapRadiusInPixels + 1,
+                    ]
+                }
+            );
 
             frameCtx.snapVectorA = [
                 canvasPos ? getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth) : 0,

package/types/extras/PointerCircle/PointerCircle.d.ts

@@ -0,0 +1,50 @@
+import {Viewer} from "../../viewer";
+
+/**
+ * A PointerCircle shows a circle, centered at the position of the
+ * mouse or touch pointer.
+ */
+export class PointerCircle {
+    /**
+     * Constructs a new PointerCircle.
+     * @param {Viewer} viewer The Viewer
+     * @param {Object} [cfg] PointerCircle configuration.
+     * @param {boolean} [cfg.active=true] Whether PointerCircle is active. The PointerCircle can only be shown when this is `true` (default).
+     */
+    constructor(viewer: Viewer, cfg?: {
+        active?: boolean;
+    });
+
+    /**
+     * Show the circle at the given canvas coordinates and begin shrinking it.
+     */
+    start(circlePos: number[]): void;
+
+    /**
+     * Stop the shrinking circle and hide it.
+     */
+    stop(): void;
+
+    /**
+     * Sets the zoom factor for the lens.
+     *
+     * This is `2` by default.
+     *
+     * @param {number} durationMs
+     */
+    set durationMs(durationMs: number);
+
+    /**
+     * Gets the zoom factor for the lens.
+     *
+     * This is `2` by default.
+     *
+     * @returns {number} Number
+     */
+    get durationMs(): number;
+
+    /**
+     * Destroys this PointerCircle.
+     */
+    destroy(): void;
+}

package/types/extras/PointerCircle/index.d.ts

@@ -0,0 +1 @@
+export * from "./PointerCircle";

package/types/plugins/WebIFCLoaderPlugin/WebIFCLoaderPlugin.d.ts

@@ -21,12 +21,13 @@ import { ModelStats } from "../index";
 
 export declare type WebIFCLoaderPluginConfiguration = {
   id?: string;
-  wasmPath: string;
   objectDefaults?: any;
   dataSource?: IWebIFCDefaultDataSource;
   includeTypes?: string[];
   excludeTypes?: string[];
   excludeUnclassifiedObjects?: boolean;
+  WebIFC: any;
+  IfcAPI: any;
 };
 
 export declare type LoadWebIFCModel = {

package/types/plugins/XKTLoaderPlugin/XKTLoaderPlugin.d.ts

@@ -11,6 +11,8 @@ export declare type XKTLoaderPluginConfiguration = {
     includeTypes?: string[];
     /** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject.type} values in this list. */
     excludeTypes?: string[];
+    /** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject.id} values in this list. */
+    includeIds?: string[];
     /** When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link TreeViewPlugin}. */
     excludeUnclassifiedObjects?: boolean;
     /** Indicates whether to enable geometry reuse */
@@ -40,6 +42,8 @@ export declare type LoadXKTModel = {
     includeTypes?: string[]
     /** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject.type} values in this list. */
     excludeTypes?: string[];
+    /** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject.id} values in this list. */
+    includeIds?: string[]
     /** Whether or not xeokit renders the model with edges emphasized. */
     edges?: boolean;
     /** The model's World-space double-precision 3D origin. Use this to position the model within xeokit's World coordinate system, using double-precision coordinates. */
@@ -198,6 +202,30 @@ export declare class XKTLoaderPlugin extends Plugin {
      */
     get excludeTypes(): string[];
 
+    /**
+     * Sets the whitelist of the specified elements by this XKTLoaderPlugin.
+     *
+     * When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose ids are in this
+     * list. An object's id is indicated by its {@link MetaObject}'s {@link MetaObject#id}.
+     *
+     * Default value is ````undefined````.
+     *
+     * @type {String[]}
+     */
+    set includeIds(arg: string[]);
+
+    /**
+     * Gets the whitelist of the specified elements loaded by this XKTLoaderPlugin.
+     *
+     * When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose ids are in this
+     * list. An object's id is indicated by its {@link MetaObject}'s {@link MetaObject#id}.
+     *
+     * Default value is ````undefined````.
+     *
+     * @type {String[]}
+     */
+    get includeIds(): string[];
+
     /**
      * Sets whether we load objects that don't have IFC types.
      *

package/types/plugins/index.d.ts

@@ -19,6 +19,7 @@ export * from "./ViewCullPlugin";
 export * from "./XKTLoaderPlugin";
 export * from "./WebIFCLoaderPlugin";
 export * from "./XML3DLoaderPlugin";
+export * from "./lib/ui";
 
 export declare type ModelStats = {
   sourceFormat: string;

package/types/plugins/lib/ui/index.d.ts

@@ -0,0 +1,12 @@
+import { Viewer } from "../../../viewer";
+import { PointerCircle } from "../../../extras/PointerCircle";
+
+type Cleanup = () => void;
+
+type OnCancel = () => void;
+type OnChange = () => void;
+type OnCommit = () => void;
+
+type Ray2WorldPos = (origin: number[], direction: number[]) => boolean | number[];
+
+declare function touchPointSelector(viewer: Viewer, pointerCircle: PointerCircle, ray2WorldPos: Ray2WorldPos): (onCancel: OnCancel, onChange: OnChange, onCommit: OnCommit) => Cleanup;

package/types/viewer/scene/models/SceneModelMesh.d.ts

@@ -65,4 +65,11 @@ export declare class SceneModelMesh {
      */
     entity: SceneModelEntity;
 
+    /**
+     * Tells whether this SceneModelMesh is a solid or not
+     * 
+     * @type {Boolean}
+     */
+    isSolid(): boolean;
+
 }