@xeokit/xeokit-sdk 2.5.2-beta-11 → 2.5.2-beta-16

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

@@ -1,139 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,263 +0,0 @@
-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};