@xeokit/xeokit-sdk 2.5.2-beta-10 → 2.5.2-beta-13

package/src/src/viewer/scene/math/rtcCoords.js

@@ -0,0 +1,139 @@
+import {math} from './math.js';
+
+const tempVec3a = math.vec3();
+
+/**
+ * Given a view matrix and a relative-to-center (RTC) coordinate origin, returns a view matrix
+ * to transform RTC coordinates to View-space.
+ *
+ * The returned view matrix is
+ *
+ * @private
+ */
+const createRTCViewMat = (function () {
+
+    const tempMat = new Float64Array(16);
+    const rtcCenterWorld = new Float64Array(4);
+    const rtcCenterView = new Float64Array(4);
+
+    return function (viewMat, rtcCenter, rtcViewMat) {
+        rtcViewMat = rtcViewMat || tempMat;
+        rtcCenterWorld[0] = rtcCenter[0];
+        rtcCenterWorld[1] = rtcCenter[1];
+        rtcCenterWorld[2] = rtcCenter[2];
+        rtcCenterWorld[3] = 1;
+        math.transformVec4(viewMat, rtcCenterWorld, rtcCenterView);
+        math.setMat4Translation(viewMat, rtcCenterView, rtcViewMat);
+        return rtcViewMat.slice ();
+    }
+}());
+
+/**
+ * Converts a World-space 3D position to RTC.
+ *
+ * Given a double-precision World-space position, returns a double-precision relative-to-center (RTC) center pos
+ * and a single-precision offset fom that center.
+ * @private
+ * @param {Float64Array} worldPos The World-space position.
+ * @param {Float64Array} rtcCenter Double-precision relative-to-center (RTC) center pos.
+ * @param {Float32Array} rtcPos Single-precision offset fom that center.
+ */
+function worldToRTCPos(worldPos, rtcCenter, rtcPos) {
+
+    const xHigh = Float32Array.from([worldPos[0]])[0];
+    const xLow = worldPos[0] - xHigh;
+
+    const yHigh = Float32Array.from([worldPos[1]])[0];
+    const yLow = worldPos[1] - yHigh;
+
+    const zHigh = Float32Array.from([worldPos[2]])[0];
+    const zLow = worldPos[2] - zHigh;
+
+    rtcCenter[0] = xHigh;
+    rtcCenter[1] = yHigh;
+    rtcCenter[2] = zHigh;
+
+    rtcPos[0] = xLow;
+    rtcPos[1] = yLow;
+    rtcPos[2] = zLow;
+}
+
+
+/**
+ * Converts a flat array of double-precision positions to RTC positions, if necessary.
+ *
+ * Conversion is necessary if the coordinates have values larger than can be expressed at single-precision. When
+ * that's the case, then this function will compute the RTC coordinates and RTC center and return true. Otherwise
+ * this function does nothing and returns false.
+ *
+ * When computing the RTC position, this function uses a modulus operation to ensure that, whenever possible,
+ * identical RTC centers are reused for different positions arrays.
+ *
+ * @private
+ * @param {Float64Array} worldPositions Flat array of World-space 3D positions.
+ * @param {Float64Array} rtcPositions Outputs the computed flat array of 3D RTC positions.
+ * @param {Float64Array} rtcCenter Outputs the computed double-precision relative-to-center (RTC) center pos.
+ * @param {Number} [cellSize=10000000] The size of each coordinate cell within the RTC coordinate system.
+ * @returns {Boolean} ````True```` if the positions actually needed conversion to RTC, else ````false````. When
+ * ````false````, we can safely ignore the data returned in ````rtcPositions```` and ````rtcCenter````,
+ * since ````rtcCenter```` will equal ````[0,0,0]````, and ````rtcPositions```` will contain identical values to ````positions````.
+ */
+function worldToRTCPositions(worldPositions, rtcPositions, rtcCenter, cellSize = 1000) {
+
+    const center = math.getPositionsCenter(worldPositions, tempVec3a);
+
+    const rtcCenterX = Math.round(center[0] / cellSize) * cellSize;
+    const rtcCenterY = Math.round(center[1] / cellSize) * cellSize;
+    const rtcCenterZ = Math.round(center[2] / cellSize) * cellSize;
+
+    rtcCenter[0] = rtcCenterX;
+    rtcCenter[1] = rtcCenterY;
+    rtcCenter[2] = rtcCenterZ;
+
+    const rtcNeeded = (rtcCenter[0] !== 0 || rtcCenter[1] !== 0 || rtcCenter[2] !== 0);
+
+    if (rtcNeeded) {
+        for (let i = 0, len = worldPositions.length; i < len; i += 3) {
+            rtcPositions[i + 0] = worldPositions[i + 0] - rtcCenterX;
+            rtcPositions[i + 1] = worldPositions[i + 1] - rtcCenterY;
+            rtcPositions[i + 2] = worldPositions[i + 2] - rtcCenterZ;
+        }
+    }
+
+    return rtcNeeded;
+}
+
+/**
+ * Converts an RTC 3D position to World-space.
+ *
+ * @private
+ * @param {Float64Array} rtcCenter Double-precision relative-to-center (RTC) center pos.
+ * @param {Float32Array} rtcPos Single-precision offset fom that center.
+ * @param {Float64Array} worldPos The World-space position.
+ */
+function rtcToWorldPos(rtcCenter, rtcPos, worldPos) {
+    worldPos[0] = rtcCenter[0] + rtcPos[0];
+    worldPos[1] = rtcCenter[1] + rtcPos[1];
+    worldPos[2] = rtcCenter[2] + rtcPos[2];
+    return worldPos;
+}
+
+/**
+ * Given a 3D plane defined by distance from origin and direction, and an RTC center position,
+ * return a plane position that is relative to the RTC center.
+ *
+ * @private
+ * @param dist
+ * @param dir
+ * @param rtcCenter
+ * @param rtcPlanePos
+ * @returns {*}
+ */
+function getPlaneRTCPos(dist, dir, rtcCenter, rtcPlanePos) {
+    const rtcCenterToPlaneDist = math.dotVec3(dir, rtcCenter) + dist;
+    const dirNormalized = math.normalizeVec3(dir, tempVec3a);
+    math.mulVec3Scalar(dirNormalized, -rtcCenterToPlaneDist, rtcPlanePos);
+    return rtcPlanePos;
+}
+
+export {createRTCViewMat, worldToRTCPos, worldToRTCPositions, rtcToWorldPos, getPlaneRTCPos};

package/src/src/viewer/scene/mementos/CameraMemento.js

@@ -0,0 +1,200 @@
+import {math} from "../math/math.js";
+
+/**
+ * @desc Saves and restores the state of a {@link Scene}'s {@link Camera}.
+ *
+ * ## See Also
+ *
+ * * {@link ModelMemento} - Saves and restores a snapshot of the visual state of the {@link Entity}'s of a model within a {@link Scene}.
+ * * {@link ObjectsMemento} - Saves and restores a snapshot of the visual state of the {@link Entity}'s that represent objects within a {@link Scene}.
+ *
+ * ## Usage
+ *
+ * In the example below, we'll create a {@link Viewer} and use an {@link XKTLoaderPlugin} to load an ````.xkt```` model. When the model has loaded, we'll save a snapshot of the {@link Camera} state in an CameraMemento. Then we'll move the Camera, and then we'll restore its original state again from the CameraMemento.
+ *
+ * ````javascript
+ * import {Viewer, XKTLoaderPlugin, CameraMemento} from "xeokit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *     canvasId: "myCanvas"
+ * });
+ *
+ * // Load a model
+ * const xktLoader = new XKTLoaderPlugin(viewer);
+ *
+ * const model = xktLoader.load({
+ *     id: "myModel",
+ *     src: "./models/xkt/schependomlaan/schependomlaan.xkt"
+ * });
+ *
+ * // Set camera
+ * viewer.camera.eye = [-2.56, 8.38, 8.27];
+ * viewer.camera.look = [13.44, 3.31, -14.83];
+ * viewer.camera.up = [0.10, 0.98, -0.14];
+ *
+ * model.on("loaded", () => {
+ *
+ *      // Model has loaded
+ *
+ *      // Save memento of camera state
+ *      const cameraMemento = new CameraMemento();
+ *
+ *      cameraMemento.saveCamera(viewer.scene);
+ *
+ *      // Move the camera
+ *      viewer.camera.eye = [45.3, 2.00, 5.13];
+ *      viewer.camera.look = [0.0, 5.5, 10.0];
+ *      viewer.camera.up = [0.10, 0.98, -0.14];
+ *
+ *      // Restore the camera state again
+ *      objectsMemento.restoreCamera(viewer.scene);
+ * });
+ * ````
+ */
+class CameraMemento {
+
+    /**
+     * Creates a CameraState.
+     *
+     * @param {Scene} [scene] When given, immediately saves the state of the given {@link Scene}'s {@link Camera}.
+     */
+    constructor(scene) {
+
+        /** @private */
+        this._eye = math.vec3();
+
+        /** @private */
+        this._look = math.vec3();
+
+        /** @private */
+        this._up = math.vec3();
+
+        /** @private */
+        this._projection = {};
+
+        if (scene) {
+            this.saveCamera(scene);
+        }
+    }
+
+    /**
+     * Saves the state of the given {@link Scene}'s {@link Camera}.
+     *
+     * @param {Scene} scene The scene that contains the {@link Camera}.
+     */
+    saveCamera(scene) {
+
+        const camera = scene.camera;
+        const project = camera.project;
+
+        this._eye.set(camera.eye);
+        this._look.set(camera.look);
+        this._up.set(camera.up);
+
+        switch (camera.projection) {
+
+            case "perspective":
+                this._projection = {
+                    projection: "perspective",
+                    fov: project.fov,
+                    fovAxis: project.fovAxis,
+                    near: project.near,
+                    far: project.far
+                };
+                break;
+
+            case "ortho":
+                this._projection = {
+                    projection: "ortho",
+                    scale: project.scale,
+                    near: project.near,
+                    far: project.far
+                };
+                break;
+
+            case "frustum":
+                this._projection = {
+                    projection: "frustum",
+                    left: project.left,
+                    right: project.right,
+                    top: project.top,
+                    bottom: project.bottom,
+                    near: project.near,
+                    far: project.far
+                };
+                break;
+
+            case "custom":
+                this._projection = {
+                    projection: "custom",
+                    matrix: project.matrix.slice()
+                };
+                break;
+        }
+    }
+
+    /**
+     * Restores a {@link Scene}'s {@link Camera} to the state previously captured with {@link CameraMemento#saveCamera}.
+     *
+     * @param {Scene} scene The scene.
+     * @param {Function} [done] When this callback is given, will fly the {@link Camera} to the saved state then fire the callback. Otherwise will just jump the Camera to the saved state.
+     */
+    restoreCamera(scene, done) {
+
+        const camera = scene.camera;
+        const savedProjection = this._projection;
+
+        function restoreProjection() {
+
+            switch (savedProjection.type) {
+
+                case "perspective":
+                    camera.perspective.fov = savedProjection.fov;
+                    camera.perspective.fovAxis = savedProjection.fovAxis;
+                    camera.perspective.near = savedProjection.near;
+                    camera.perspective.far = savedProjection.far;
+                    break;
+
+                case "ortho":
+                    camera.ortho.scale = savedProjection.scale;
+                    camera.ortho.near = savedProjection.near;
+                    camera.ortho.far = savedProjection.far;
+                    break;
+
+                case "frustum":
+                    camera.frustum.left = savedProjection.left;
+                    camera.frustum.right = savedProjection.right;
+                    camera.frustum.top = savedProjection.top;
+                    camera.frustum.bottom = savedProjection.bottom;
+                    camera.frustum.near = savedProjection.near;
+                    camera.frustum.far = savedProjection.far;
+                    break;
+
+                case "custom":
+                    camera.customProjection.matrix = savedProjection.matrix;
+                    break;
+            }
+        }
+
+        if (done) {
+            scene.viewer.cameraFlight.flyTo({
+                eye: this._eye,
+                look: this._look,
+                up: this._up,
+                orthoScale: savedProjection.scale,
+                projection: savedProjection.projection
+            }, () => {
+                restoreProjection();
+                done();
+            });
+        } else {
+            camera.eye = this._eye;
+            camera.look = this._look;
+            camera.up = this._up;
+            restoreProjection();
+            camera.projection = savedProjection.projection;
+        }
+    }
+}
+
+export {CameraMemento};

package/src/src/viewer/scene/mementos/ModelMemento.js

@@ -0,0 +1,263 @@
+import {math} from "../math/math.js";
+import {utils} from "../utils.js";
+
+const color = math.vec3();
+
+/**
+ * @desc Saves and restores a snapshot of the visual state of the {@link Entity}'s of a model within a {@link Scene}.
+ *
+ * ## Usage
+ *
+ * In the example below, we'll create a {@link Viewer} and use an {@link XKTLoaderPlugin} to load an ````.xkt```` model. When the model has loaded, we'll hide a couple of {@link Entity}s and save a snapshot of the visual states of all its Entitys in an ModelMemento. Then we'll show all the Entitys
+ * again, and then we'll restore the visual states of all the Entitys again from the ModelMemento, which will hide those two Entitys again.
+ *
+ * ## See Also
+ *
+ * * {@link CameraMemento} - Saves and restores the state of a {@link Scene}'s {@link Camera}.
+ * * {@link ObjectsMemento} - Saves and restores a snapshot of the visual state of the {@link Entity}'s that represent objects within a {@link Scene}.
+ *
+ * ````javascript
+ * import {Viewer, XKTLoaderPlugin,  ModelMemento} from "xeokit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *     canvasId: "myCanvas"
+ * });
+ *
+ * // Load a model
+ * const xktLoader = new XKTLoaderPlugin(viewer);
+ *
+ * const model = xktLoader.load({
+ *     id: "myModel",
+ *     src: "./models/xkt/schependomlaan/schependomlaan.xkt"
+ * });
+ *
+ * model.on("loaded", () => {
+ *
+ *      // Model has loaded
+ *
+ *      // Hide a couple of objects
+ *      viewer.scene.objects["0u4wgLe6n0ABVaiXyikbkA"].visible = false;
+ *      viewer.scene.objects["3u4wgLe3n0AXVaiXyikbYO"].visible = false;
+ *
+ *      // Save memento of all object states, which includes those two hidden objects
+ *      const ModelMemento = new ModelMemento();
+ *
+ * const metaModel = viewer.metaScene.metaModels
+ *      ModelMemento.saveObjects(viewer.scene);
+ *
+ *      // Show all objects
+ *      viewer.scene.setObjectsVisible(viewer.scene.objectIds, true);
+ *
+ *      // Restore the objects states again, which involves hiding those two objects again
+ *      ModelMemento.restoreObjects(viewer.scene);
+ * });
+ * `````
+ *
+ * ## Masking Saved State
+ *
+ * We can optionally supply a mask to focus what state we save and restore.
+ *
+ * For example, to save and restore only the {@link Entity#visible} and {@link Entity#clippable} states:
+ *
+ * ````javascript
+ * ModelMemento.saveObjects(viewer.scene, {
+ *     visible: true,
+ *     clippable: true
+ * });
+ *
+ * //...
+ *
+ * // Restore the objects states again
+ * ModelMemento.restoreObjects(viewer.scene);
+ * ````
+ */
+class ModelMemento {
+
+    /**
+     * Creates a ModelMemento.
+     *
+     * @param {MetaModel} [metaModel] When given, immediately saves the model's {@link Entity} states to this ModelMemento.
+     */
+    constructor(metaModel) {
+
+        /** @private */
+        this.objectsVisible = [];
+
+        /** @private */
+        this.objectsEdges = [];
+
+        /** @private */
+        this.objectsXrayed = [];
+
+        /** @private */
+        this.objectsHighlighted = [];
+
+        /** @private */
+        this.objectsSelected = [];
+
+        /** @private */
+        this.objectsClippable = [];
+
+        /** @private */
+        this.objectsPickable = [];
+
+        /** @private */
+        this.objectsColorize = [];
+
+        /** @private */
+        this.objectsOpacity = [];
+
+        /** @private */
+        this.numObjects = 0;
+
+        if (metaModel) {
+            const metaScene = metaModel.metaScene;
+            const scene = metaScene.scene;
+            this.saveObjects(scene, metaModel);
+        }
+    }
+
+    /**
+     * Saves a snapshot of the visual state of the {@link Entity}'s that represent objects within a model.
+     *
+     * @param {Scene} scene The scene.
+     * @param {MetaModel} metaModel Represents the model. Corresponds with an {@link Entity} that represents the model in the scene.
+     * @param {Object} [mask] Masks what state gets saved. Saves all state when not supplied.
+     * @param {boolean} [mask.visible] Saves {@link Entity#visible} values when ````true````.
+     * @param {boolean} [mask.visible] Saves {@link Entity#visible} values when ````true````.
+     * @param {boolean} [mask.edges] Saves {@link Entity#edges} values when ````true````.
+     * @param {boolean} [mask.xrayed] Saves {@link Entity#xrayed} values when ````true````.
+     * @param {boolean} [mask.highlighted] Saves {@link Entity#highlighted} values when ````true````.
+     * @param {boolean} [mask.selected] Saves {@link Entity#selected} values when ````true````.
+     * @param {boolean} [mask.clippable] Saves {@link Entity#clippable} values when ````true````.
+     * @param {boolean} [mask.pickable] Saves {@link Entity#pickable} values when ````true````.
+     * @param {boolean} [mask.colorize] Saves {@link Entity#colorize} values when ````true````.
+     * @param {boolean} [mask.opacity] Saves {@link Entity#opacity} values when ````true````.
+     */
+    saveObjects(scene, metaModel, mask) {
+
+        this.numObjects = 0;
+
+        this._mask = mask ? utils.apply(mask, {}) : null;
+
+        const visible = (!mask || mask.visible);
+        const edges = (!mask || mask.edges);
+        const xrayed = (!mask || mask.xrayed);
+        const highlighted = (!mask || mask.highlighted);
+        const selected = (!mask || mask.selected);
+        const clippable = (!mask || mask.clippable);
+        const pickable = (!mask || mask.pickable);
+        const colorize = (!mask || mask.colorize);
+        const opacity = (!mask || mask.opacity);
+
+        const metaObjects = metaModel.metaObjects;
+        const objects = scene.objects;
+
+        for (let i = 0, len = metaObjects.length; i < len; i++) {
+            const metaObject = metaObjects[i];
+            const objectId = metaObject.id;
+            const object = objects[objectId];
+            if (!object) {
+                continue;
+            }
+            if (visible) {
+                this.objectsVisible[i] = object.visible;
+            }
+            if (edges) {
+                this.objectsEdges[i] = object.edges;
+            }
+            if (xrayed) {
+                this.objectsXrayed[i] = object.xrayed;
+            }
+            if (highlighted) {
+                this.objectsHighlighted[i] = object.highlighted;
+            }
+            if (selected) {
+                this.objectsSelected[i] = object.selected;
+            }
+            if (clippable) {
+                this.objectsClippable[i] = object.clippable;
+            }
+            if (pickable) {
+                this.objectsPickable[i] = object.pickable;
+            }
+            if (colorize) {
+                const objectColor = object.colorize;
+                this.objectsColorize[i * 3 + 0] = objectColor[0];
+                this.objectsColorize[i * 3 + 1] = objectColor[1];
+                this.objectsColorize[i * 3 + 2] = objectColor[2];
+            }
+            if (opacity) {
+                this.objectsOpacity[i] = object.opacity;
+            }
+            this.numObjects++;
+        }
+    }
+
+    /**
+     * Restores a {@link Scene}'s {@link Entity}'s to their state previously captured with {@link ModelMemento#saveObjects}.
+     *
+     * Assumes that the model has not been destroyed or modified since saving.
+     *
+     * @param {Scene} scene The scene that was given to {@link ModelMemento#saveObjects}.
+     * @param {MetaModel} metaModel The metamodel that was given to {@link ModelMemento#saveObjects}.
+     */
+    restoreObjects(scene, metaModel) {
+
+        const mask = this._mask;
+
+        const visible = (!mask || mask.visible);
+        const edges = (!mask || mask.edges);
+        const xrayed = (!mask || mask.xrayed);
+        const highlighted = (!mask || mask.highlighted);
+        const selected = (!mask || mask.selected);
+        const clippable = (!mask || mask.clippable);
+        const pickable = (!mask || mask.pickable);
+        const colorize = (!mask || mask.colorize);
+        const opacity = (!mask || mask.opacity);
+
+        const metaObjects = metaModel.metaObjects;
+        const objects = scene.objects;
+
+        for (let i = 0, len = metaObjects.length; i < len; i++) {
+            const metaObject = metaObjects[i];
+            const objectId = metaObject.id;
+            const object = objects[objectId];
+            if (!object) {
+                continue;
+            }
+            if (visible) {
+                object.visible = this.objectsVisible[i];
+            }
+            if (edges) {
+                object.edges = this.objectsEdges[i];
+            }
+            if (xrayed) {
+                object.xrayed = this.objectsXrayed[i];
+            }
+            if (highlighted) {
+                object.highlighted = this.objectsHighlighted[i];
+            }
+            if (selected) {
+                object.selected = this.objectsSelected[i];
+            }
+            if (clippable) {
+                object.clippable = this.objectsClippable[i];
+            }
+            if (pickable) {
+                object.pickable = this.objectsPickable[i];
+            }
+            if (colorize) {
+                color[0] = this.objectsColorize[i * 3 + 0];
+                color[1] = this.objectsColorize[i * 3 + 1];
+                color[2] = this.objectsColorize[i * 3 + 2];
+                object.colorize = color;
+            }
+            if (opacity) {
+                object.opacity = this.objectsOpacity[i];
+            }
+        }
+    }
+}
+
+export {ModelMemento};