npm - @xeokit/xeokit-sdk - Versions diffs - 2.5.2-beta-11 → 2.5.2-beta-16 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (463) hide show

package/src/src/viewer/scene/CameraControl/lib/CameraUpdater.js DELETED Viewed

@@ -1,312 +0,0 @@
-import {math} from "../../math/math.js";
-const SCALE_DOLLY_EACH_FRAME = 1; // Recalculate dolly speed for eye->target distance on each Nth frame
-const EPSILON = 0.001;
-const tempVec3 = math.vec3();
-/**
- * Handles camera updates on each "tick" that were scheduled by the various controllers.
- *
- * @private
- */
-class CameraUpdater {
-    constructor(scene, controllers, configs, states, updates) {
-        this._scene = scene;
-        const camera = scene.camera;
-        const pickController = controllers.pickController;
-        const pivotController = controllers.pivotController;
-        const panController = controllers.panController;
-        let countDown = SCALE_DOLLY_EACH_FRAME; // Decrements on each tick
-        let dollyDistFactor = 1.0; // Calculated when countDown is zero
-        let followPointerWorldPos = null; // Holds the pointer's World position when configs.followPointer is true
-        this._onTick = scene.on("tick", () => {
-            if (!(configs.active && configs.pointerEnabled)) {
-                return;
-            }
-            let cursorType = "default";
-            //----------------------------------------------------------------------------------------------------------
-            // Dolly decay
-            //------------------------------------------------------------------------------------  ----------------------
-            if (Math.abs(updates.dollyDelta) < EPSILON) {
-                updates.dollyDelta = 0;
-            }
-            //----------------------------------------------------------------------------------------------------------
-            // Rotation decay
-            //----------------------------------------------------------------------------------------------------------
-            if (Math.abs(updates.rotateDeltaX) < EPSILON) {
-                updates.rotateDeltaX = 0;
-            }
-            if (Math.abs(updates.rotateDeltaY) < EPSILON) {
-                updates.rotateDeltaY = 0;
-            }
-            if (updates.rotateDeltaX !== 0 || updates.rotateDeltaY !== 0) {
-                updates.dollyDelta = 0;
-            }
-            //----------------------------------------------------------------------------------------------------------
-            // Dolly speed eye->look scaling
-            //
-            // If pointer is over an object, then dolly speed is proportional to the distance to that object.
-            //
-            // If pointer is not over an object, then dolly speed is proportional to the distance to the last
-            // object the pointer was over. This is so that we can dolly to structures that may have gaps through
-            // which empty background shows, that the pointer may inadvertently be over. In these cases, we don't
-            // want dolly speed wildly varying depending on how accurately the user avoids the gaps with the pointer.
-            //----------------------------------------------------------------------------------------------------------
-            if (configs.followPointer) {
-                if (--countDown <= 0) {
-                    countDown = SCALE_DOLLY_EACH_FRAME;
-                    if (updates.dollyDelta !== 0) {
-                        if (updates.rotateDeltaY === 0 && updates.rotateDeltaX === 0) {
-                            if (configs.followPointer && states.followPointerDirty) {
-                                pickController.pickCursorPos = states.pointerCanvasPos;
-                                pickController.schedulePickSurface = true;
-                                pickController.update();
-                                if (pickController.pickResult && pickController.pickResult.worldPos) {
-                                    followPointerWorldPos = pickController.pickResult.worldPos;
-                                } else {
-                                    dollyDistFactor = 1.0;
-                                    followPointerWorldPos = null;
-                                }
-                                states.followPointerDirty = false;
-                            }
-                        }
-                        if (followPointerWorldPos) {
-                            const dist = Math.abs(math.lenVec3(math.subVec3(followPointerWorldPos, scene.camera.eye, tempVec3)));
-                            dollyDistFactor = dist / configs.dollyProximityThreshold;
-                        }
-                        if (dollyDistFactor < configs.dollyMinSpeed) {
-                            dollyDistFactor = configs.dollyMinSpeed;
-                        }
-                    }
-                }
-            }
-            const dollyDeltaForDist = (updates.dollyDelta * dollyDistFactor);
-            //----------------------------------------------------------------------------------------------------------
-            // Rotation
-            //----------------------------------------------------------------------------------------------------------
-            if (updates.rotateDeltaY !== 0 || updates.rotateDeltaX !== 0) {
-                if ((!configs.firstPerson) && configs.followPointer && pivotController.getPivoting()) {
-                    pivotController.continuePivot(updates.rotateDeltaY, updates.rotateDeltaX);
-                    pivotController.showPivot();
-                } else {
-                    if (updates.rotateDeltaX !== 0) {
-                        if (configs.firstPerson) {
-                            camera.pitch(-updates.rotateDeltaX);
-                        } else {
-                            camera.orbitPitch(updates.rotateDeltaX);
-                        }
-                    }
-                    if (updates.rotateDeltaY !== 0) {
-                        if (configs.firstPerson) {
-                            camera.yaw(updates.rotateDeltaY);
-                        } else {
-                            camera.orbitYaw(updates.rotateDeltaY);
-                        }
-                    }
-                }
-                updates.rotateDeltaX *= configs.rotationInertia;
-                updates.rotateDeltaY *= configs.rotationInertia;
-                cursorType = "grabbing";
-            }
-            //----------------------------------------------------------------------------------------------------------
-            // Panning
-            //----------------------------------------------------------------------------------------------------------
-            if (Math.abs(updates.panDeltaX) < EPSILON) {
-                updates.panDeltaX = 0;
-            }
-            if (Math.abs(updates.panDeltaY) < EPSILON) {
-                updates.panDeltaY = 0;
-            }
-            if (Math.abs(updates.panDeltaZ) < EPSILON) {
-                updates.panDeltaZ = 0;
-            }
-            if (updates.panDeltaX !== 0 || updates.panDeltaY !== 0 || updates.panDeltaZ !== 0) {
-                const vec = math.vec3();
-                vec[0] = updates.panDeltaX;
-                vec[1] = updates.panDeltaY;
-                vec[2] = updates.panDeltaZ;
-                let verticalEye;
-                let verticalLook;
-                if (configs.constrainVertical) {
-                    if (camera.xUp) {
-                        verticalEye = camera.eye[0];
-                        verticalLook = camera.look[0];
-                    } else if (camera.yUp) {
-                        verticalEye = camera.eye[1];
-                        verticalLook = camera.look[1];
-                    } else if (camera.zUp) {
-                        verticalEye = camera.eye[2];
-                        verticalLook = camera.look[2];
-                    }
-                    camera.pan(vec);
-                    const eye = camera.eye;
-                    const look = camera.look;
-                    if (camera.xUp) {
-                        eye[0] = verticalEye;
-                        look[0] = verticalLook;
-                    } else if (camera.yUp) {
-                        eye[1] = verticalEye;
-                        look[1] = verticalLook;
-                    } else if (camera.zUp) {
-                        eye[2] = verticalEye;
-                        look[2] = verticalLook;
-                    }
-                    camera.eye = eye;
-                    camera.look = look;
-                } else {
-                    camera.pan(vec);
-                }
-                cursorType = "grabbing";
-            }
-            updates.panDeltaX *= configs.panInertia;
-            updates.panDeltaY *= configs.panInertia;
-            updates.panDeltaZ *= configs.panInertia;
-            //----------------------------------------------------------------------------------------------------------
-            // Dollying
-            //----------------------------------------------------------------------------------------------------------
-            if (dollyDeltaForDist !== 0) {
-                if (dollyDeltaForDist < 0) {
-                    cursorType = "zoom-in";
-                } else {
-                    cursorType = "zoom-out";
-                }
-                if (configs.firstPerson) {
-                    let verticalEye;
-                    let verticalLook;
-                    if (configs.constrainVertical) {
-                        if (camera.xUp) {
-                            verticalEye = camera.eye[0];
-                            verticalLook = camera.look[0];
-                        } else if (camera.yUp) {
-                            verticalEye = camera.eye[1];
-                            verticalLook = camera.look[1];
-                        } else if (camera.zUp) {
-                            verticalEye = camera.eye[2];
-                            verticalLook = camera.look[2];
-                        }
-                    }
-                    if (configs.followPointer) {
-                        const dolliedThroughSurface = panController.dollyToCanvasPos(followPointerWorldPos, states.pointerCanvasPos, -dollyDeltaForDist);
-                        if (dolliedThroughSurface) {
-                            states.followPointerDirty = true;
-                        }
-                    } else {
-                        camera.pan([0, 0, dollyDeltaForDist]);
-                        camera.ortho.scale = camera.ortho.scale - dollyDeltaForDist;
-                    }
-                    if (configs.constrainVertical) {
-                        const eye = camera.eye;
-                        const look = camera.look;
-                        if (camera.xUp) {
-                            eye[0] = verticalEye;
-                            look[0] = verticalLook;
-                        } else if (camera.yUp) {
-                            eye[1] = verticalEye;
-                            look[1] = verticalLook;
-                        } else if (camera.zUp) {
-                            eye[2] = verticalEye;
-                            look[2] = verticalLook;
-                        }
-                        camera.eye = eye;
-                        camera.look = look;
-                    }
-                } else if (configs.planView) {
-                    if (configs.followPointer) {
-                        const dolliedThroughSurface = panController.dollyToCanvasPos(followPointerWorldPos, states.pointerCanvasPos, -dollyDeltaForDist);
-                        if (dolliedThroughSurface) {
-                            states.followPointerDirty = true;
-                        }
-                    } else {
-                        camera.ortho.scale = camera.ortho.scale + dollyDeltaForDist;
-                        camera.zoom(dollyDeltaForDist);
-                    }
-                } else { // Orbiting
-                    if (configs.followPointer) {
-                        const dolliedThroughSurface = panController.dollyToCanvasPos(followPointerWorldPos, states.pointerCanvasPos, -dollyDeltaForDist);
-                        if (dolliedThroughSurface) {
-                            states.followPointerDirty = true;
-                        }
-                    } else {
-                        camera.ortho.scale = camera.ortho.scale + dollyDeltaForDist;
-                        camera.zoom(dollyDeltaForDist);
-                    }
-                }
-                updates.dollyDelta *= configs.dollyInertia;
-            }
-            pickController.fireEvents();
-            document.body.style.cursor = cursorType;
-        });
-    }
-    destroy() {
-        this._scene.off(this._onTick);
-    }
-}
-export {CameraUpdater};

package/src/src/viewer/scene/CameraControl/lib/controllers/PanController.js DELETED Viewed

@@ -1,112 +0,0 @@
-import {math} from "../../../math/math.js";
-const screenPos = math.vec4();
-const viewPos = math.vec4();
-const tempVec3a = math.vec3();
-const tempVec3b = math.vec3();
-const tempVec3c = math.vec3();
-const tempVec4a = math.vec4();
-const tempVec4b = math.vec4();
-const tempVec4c = math.vec4();
-/**
- * @private
- */
-class PanController {
-    constructor(scene) {
-        this._scene = scene;
-    }
-    /**
-     * Dollys the Camera towards the given target 2D canvas position.
-     *
-     * When the target's corresponding World-space position is also provided, then this function will also test if we've
-     * dollied past the target, and will return ````true```` if that's the case.
-     *
-     * @param [optionalTargetWorldPos] Optional world position of the target
-     * @param targetCanvasPos Canvas position of the target
-     * @param dollyDelta Amount to dolly
-     * @return True if optionalTargetWorldPos was given, and we've dollied past that position.
-     */
-    dollyToCanvasPos(optionalTargetWorldPos, targetCanvasPos, dollyDelta) {
-        let dolliedThroughSurface = false;
-        const camera = this._scene.camera;
-        if (optionalTargetWorldPos) {
-            const eyeToWorldPosVec = math.subVec3(optionalTargetWorldPos, camera.eye, tempVec3a);
-            const eyeWorldPosDist = math.lenVec3(eyeToWorldPosVec);
-            dolliedThroughSurface = (eyeWorldPosDist < dollyDelta);
-        }
-        if (camera.projection === "perspective") {
-            camera.ortho.scale = camera.ortho.scale - dollyDelta;
-            const unprojectedWorldPos = this._unproject(targetCanvasPos, tempVec4a);
-            const offset = math.subVec3(unprojectedWorldPos, camera.eye, tempVec4c);
-            const moveVec = math.mulVec3Scalar(math.normalizeVec3(offset), -dollyDelta, []);
-            camera.eye = [camera.eye[0] - moveVec[0], camera.eye[1] - moveVec[1], camera.eye[2] - moveVec[2]];
-            camera.look = [camera.look[0] - moveVec[0], camera.look[1] - moveVec[1], camera.look[2] - moveVec[2]];
-            if (optionalTargetWorldPos) {
-                // Subtle UX tweak - if we have a target World position, then set camera eye->look distance to
-                // the same distance as from eye->target. This just gives us a better position for look,
-                // if we subsequently orbit eye about look, so that we don't orbit a position that's
-                // suddenly a lot closer than the point we pivoted about on the surface of the last object
-                // that we click-drag-pivoted on.
-                const eyeTargetVec = math.subVec3(optionalTargetWorldPos, camera.eye, tempVec3a);
-                const lenEyeTargetVec = math.lenVec3(eyeTargetVec);
-                const eyeLookVec = math.mulVec3Scalar(math.normalizeVec3(math.subVec3(camera.look, camera.eye, tempVec3b)), lenEyeTargetVec);
-                camera.look = [camera.eye[0] + eyeLookVec[0], camera.eye[1] + eyeLookVec[1], camera.eye[2] + eyeLookVec[2]];
-            }
-        } else if (camera.projection === "ortho") {
-            // - set ortho scale, getting the unprojected targetCanvasPos before and after, get that difference in a vector;
-            // - get the vector in which we're dollying;
-            // - add both vectors to camera eye and look.
-            const worldPos1 = this._unproject(targetCanvasPos, tempVec4a);
-            camera.ortho.scale = camera.ortho.scale - dollyDelta;
-            camera.ortho._update(); // HACK
-            const worldPos2 = this._unproject(targetCanvasPos, tempVec4b);
-            const offset = math.subVec3(worldPos2, worldPos1, tempVec4c);
-            const eyeLookMoveVec = math.mulVec3Scalar(math.normalizeVec3(math.subVec3(camera.look, camera.eye, tempVec3a)), -dollyDelta, tempVec3b);
-            const moveVec = math.addVec3(offset, eyeLookMoveVec, tempVec3c);
-            camera.eye = [camera.eye[0] - moveVec[0], camera.eye[1] - moveVec[1], camera.eye[2] - moveVec[2]];
-            camera.look = [camera.look[0] - moveVec[0], camera.look[1] - moveVec[1], camera.look[2] - moveVec[2]];
-        }
-        return dolliedThroughSurface;
-    }
-    _unproject(canvasPos, worldPos) {
-        const camera = this._scene.camera;
-        const transposedProjectMat = camera.project.transposedMatrix;
-        const Pt3 = transposedProjectMat.subarray(8, 12);
-        const Pt4 = transposedProjectMat.subarray(12);
-        const D = [0, 0, -1.0, 1];
-        const screenZ = math.dotVec4(D, Pt3) / math.dotVec4(D, Pt4);
-        camera.project.unproject(canvasPos, screenZ, screenPos, viewPos, worldPos);
-        return worldPos;
-    }
-    destroy() {
-    }
-}
-export {PanController};

package/src/src/viewer/scene/CameraControl/lib/controllers/PickController.js DELETED Viewed

@@ -1,265 +0,0 @@
-import {math} from "../../../math/math.js";
-import {Scene} from "../../../scene/Scene.js";
-import {PickResult} from "../../../webgl/PickResult.js";
-const DEFAULT_SNAP_PICK_RADIUS = 45;
-const DEFAULT_SNAP_MODE = "vertex";
-/**
- *
- * @private
- */
-class PickController {
-    constructor(cameraControl, configs) {
-        /**
-         * @type {Scene}
-         */
-        this._scene = cameraControl.scene;
-        this._cameraControl = cameraControl;
-        this._scene.canvas.canvas.oncontextmenu = function (e) {
-            e.preventDefault();
-        };
-        this._configs = configs;
-        /**
-         * Set true to schedule picking of an Entity.
-         * @type {boolean}
-         */
-        this.schedulePickEntity = false;
-        /**
-         * Set true to schedule picking of a position on teh surface of an Entity.
-         * @type {boolean}
-         */
-        this.schedulePickSurface = false;
-        /**
-         * Set true to schedule snap-picking with surface picking as a fallback - used for measurement.
-         * @type {boolean}
-         */
-        this.scheduleSnapOrPick = false;
-        /**
-         * The canvas position at which to do the next scheduled pick.
-         * @type {Number[]}
-         */
-        this.pickCursorPos = math.vec2();
-        /**
-         * Will be true after picking to indicate that something was picked.
-         * @type {boolean}
-         */
-        this.picked = false;
-        /**
-         * Will be true after picking to indicate that a position on the surface of an Entity was picked.
-         * @type {boolean}
-         */
-        this.pickedSurface = false;
-        /**
-         * Will hold the PickResult after after picking.
-         * @type {PickResult}
-         */
-        this.pickResult = null;
-        this._lastPickedEntityId = null;
-        this._lastHash = null;
-        this._needFireEvents = 0;
-    }
-    /**
-     * Immediately attempts a pick, if scheduled.
-     */
-    update() {
-        if (!this._configs.pointerEnabled) {
-            return;
-        }
-        if (!this.schedulePickEntity && !this.schedulePickSurface) {
-            return;
-        }
-        const hash = `${~~this.pickCursorPos[0]}-${~~this.pickCursorPos[1]}-${this.scheduleSnapOrPick}-${this.schedulePickSurface}-${this.schedulePickEntity}`;
-        if (this._lastHash === hash) {
-            return;
-        }
-        this.picked = false;
-        this.pickedSurface = false;
-        this.snappedOrPicked = false;
-        this.hoveredSnappedOrSurfaceOff = false;
-        const hasHoverSurfaceSubs = this._cameraControl.hasSubs("hoverSurface");
-        if (this.scheduleSnapOrPick) {
-            const snapPickResult = this._scene.pick({
-                canvasPos: this.pickCursorPos,
-                snapRadius: this._configs.snapRadius,
-                snapToVertex: this._configs.snapToVertex,
-                snapToEdge: this._configs.snapToEdge,
-            });
-            if (snapPickResult && (snapPickResult.snappedToEdge || snapPickResult.snappedToVertex)) {
-                this.snapPickResult = snapPickResult;
-                this.snappedOrPicked = true;
-                this._needFireEvents++;
-            } else {
-                this.schedulePickSurface = true; // Fallback
-                this.snapPickResult = null;
-            }
-        }
-        if (this.schedulePickSurface) {
-            if (this.pickResult && this.pickResult.worldPos) {
-                const pickResultCanvasPos = this.pickResult.canvasPos;
-                if (pickResultCanvasPos[0] === this.pickCursorPos[0] && pickResultCanvasPos[1] === this.pickCursorPos[1]) {
-                    this.picked = true;
-                    this.pickedSurface = true;
-                    this._needFireEvents += hasHoverSurfaceSubs ? 1 : 0;
-                    this.schedulePickEntity = false;
-                    this.schedulePickSurface = false;
-                    if (this.scheduleSnapOrPick) {
-                        this.snappedOrPicked = true;
-                    } else {
-                        this.hoveredSnappedOrSurfaceOff = true;
-                    }
-                    this.scheduleSnapOrPick = false;
-                    return;
-                }
-            }
-        }
-        if (this.schedulePickEntity) {
-            if (this.pickResult && (this.pickResult.canvasPos || this.pickResult.snappedCanvasPos)) {
-                const pickResultCanvasPos = this.pickResult.canvasPos || this.pickResult.snappedCanvasPos;
-                if (pickResultCanvasPos[0] === this.pickCursorPos[0] && pickResultCanvasPos[1] === this.pickCursorPos[1]) {
-                    this.picked = true;
-                    this.pickedSurface = false;
-                    this.schedulePickEntity = false;
-                    this.schedulePickSurface = false;
-                    return;
-                }
-            }
-        }
-        if (this.schedulePickSurface || (this.scheduleSnapOrPick && !this.snapPickResult)) {
-            this.pickResult = this._scene.pick({
-                pickSurface: true,
-                pickSurfaceNormal: false,
-                canvasPos: this.pickCursorPos
-            });
-            if (this.pickResult) {
-                this.picked = true;
-                if (this.scheduleSnapOrPick) {
-                    this.snappedOrPicked = true;
-                } else {
-                    this.pickedSurface = true;
-                }
-                this._needFireEvents++;
-            } else if (this.scheduleSnapOrPick) {
-                this.hoveredSnappedOrSurfaceOff = true;
-                this._needFireEvents++;
-            }
-        } else { // schedulePickEntity == true
-            this.pickResult = this._scene.pick({
-                canvasPos: this.pickCursorPos
-            });
-            if (this.pickResult) {
-                this.picked = true;
-                this.pickedSurface = false;
-                this._needFireEvents++;
-            }
-        }
-        this.scheduleSnapOrPick = false;
-        this.schedulePickEntity = false;
-        this.schedulePickSurface = false;
-    }
-    fireEvents() {
-        if (this._needFireEvents === 0) {
-            return;
-        }
-        if (this.hoveredSnappedOrSurfaceOff) {
-            this._cameraControl.fire("hoverSnapOrSurfaceOff", {
-                canvasPos: this.pickCursorPos,
-                pointerPos : this.pickCursorPos
-            }, true);
-        }
-        if (this.snappedOrPicked) {
-            if (this.snapPickResult) {
-                const pickResult = new PickResult();
-                pickResult.snappedToVertex = this.snapPickResult.snappedToVertex;
-                pickResult.snappedToEdge = this.snapPickResult.snappedToEdge;
-                pickResult.worldPos = this.snapPickResult.worldPos;
-                pickResult.canvasPos = this.pickCursorPos
-                pickResult.snappedCanvasPos = this.snapPickResult.snappedCanvasPos;
-                this._cameraControl.fire("hoverSnapOrSurface", pickResult, true);
-                this.snapPickResult = null;
-            } else {
-                this._cameraControl.fire("hoverSnapOrSurface", this.pickResult, true);
-            }
-        } else {
-        }
-        if (this.picked && this.pickResult && (this.pickResult.entity || this.pickResult.worldPos)) {
-            if (this.pickResult.entity) {
-                const pickedEntityId = this.pickResult.entity.id;
-                if (this._lastPickedEntityId !== pickedEntityId) {
-                    if (this._lastPickedEntityId !== undefined) {
-                        this._cameraControl.fire("hoverOut", {
-                            entity: this._scene.objects[this._lastPickedEntityId]
-                        }, true);
-                    }
-                    this._cameraControl.fire("hoverEnter", this.pickResult, true);
-                    this._lastPickedEntityId = pickedEntityId;
-                }
-            }
-            this._cameraControl.fire("hover", this.pickResult, true);
-            if (this.pickResult.worldPos) {
-                this.pickedSurface = true;
-                this._cameraControl.fire("hoverSurface", this.pickResult, true);
-            }
-        } else {
-            if (this._lastPickedEntityId !== undefined) {
-                this._cameraControl.fire("hoverOut", {
-                    entity: this._scene.objects[this._lastPickedEntityId]
-                }, true);
-                this._lastPickedEntityId = undefined;
-            }
-            this._cameraControl.fire("hoverOff", {
-                canvasPos: this.pickCursorPos
-            }, true);
-        }
-        this.pickResult = null;
-        this._needFireEvents = 0;
-    }
-}
-export {PickController};