@inweb/viewer-visualize 26.9.4 → 26.9.6

package/dist/viewer-visualize.module.js

@@ -772,9 +772,9 @@ class MeasureLineDragger extends OdBaseDragger {
     }
 }
 
-const FocalLengthConst = 42.0;
-const calcFocalLength = (lensLength, fieldWidth, fieldHeight) => {
-    return (lensLength / FocalLengthConst) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+const FocalLengthConst$1 = 42.0;
+const calcFocalLength$1 = (lensLength, fieldWidth, fieldHeight) => {
+    return (lensLength / FocalLengthConst$1) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
 };
 class OdaWalkDragger extends OdBaseDragger {
     constructor(subject) {
@@ -885,10 +885,10 @@ class OdaWalkDragger extends OdBaseDragger {
             for (const keyCode of this.keyPressMap) {
                 switch (keyCode) {
                     case "KeyW":
-                        this.cameraWalker.moveForward(currentDelta);
+                        this.moveForward(currentDelta);
                         break;
                     case "KeyS":
-                        this.cameraWalker.moveBackward(currentDelta);
+                        this.moveBackward(currentDelta);
                         break;
                     case "KeyA":
                         this.cameraWalker.moveLeft(currentDelta);
@@ -925,6 +925,27 @@ class OdaWalkDragger extends OdBaseDragger {
             this.subject.emitEvent({ type: "changecamera" });
         }
     }
+    moveForward(currentDelta) {
+        const { Vector3d } = this.m_module;
+        const camera = this.cameraWalker.camera().openObjectAsCamera();
+        const target = Vector3d.createFromArray(camera.target());
+        const dir = Vector3d.createFromArray(camera.direction());
+        const up = Vector3d.createFromArray(camera.upVector());
+        const pos = Vector3d.createFromArray(camera.position());
+        let move = Vector3d.createFromArray([dir.x, dir.y, 0]);
+        if (Math.abs(dir.x) > 0.001 && Math.abs(dir.y) > 0.001) {
+            move.setToProduct(move.normalize(), currentDelta);
+        }
+        else {
+            move = Vector3d.createFromArray([0, currentDelta, 0]);
+        }
+        let newPos = pos.add(move);
+        let newTarget = target.add(move);
+        camera.setupCamera(newPos.toArray(), newTarget.toArray(), up.toArray());
+    }
+    moveBackward(currentDelta) {
+        this.moveForward(-currentDelta);
+    }
     turnLeft(angle) {
         const pCamera = this.cameraWalker.camera().openObjectAsCamera();
         const dir = this.toVector(pCamera.direction());
@@ -938,6 +959,206 @@ class OdaWalkDragger extends OdBaseDragger {
         pCamera.setupCameraByDirection(pos, dir.toArray(), up.toArray());
         pCamera.delete();
     }
+    setupCamera(view) {
+        const pCamera = this.cameraId.openObjectAsCamera();
+        const target = view.viewTarget;
+        pCamera.setDisplayGlyph(false);
+        pCamera.setDisplayTarget(false);
+        pCamera.setAutoAdjust(true);
+        pCamera.setupCamera(view.viewPosition, target, view.upVector);
+        pCamera.setNearClip(false, 1.0);
+        pCamera.setFarClip(false, 0);
+        pCamera.setViewParameters(view.viewFieldWidth, view.viewFieldHeight, true);
+        const focalL = calcFocalLength$1(view.lensLength, view.viewFieldWidth, view.viewFieldHeight);
+        const pTarget = this.toPoint(view.viewTarget);
+        const viewDir = this.toPoint(view.viewPosition);
+        const viewDirSub = viewDir.sub(pTarget);
+        const viewDirVec = viewDirSub.asVector();
+        const viewDirVecNormal = viewDirVec.normalize();
+        const geViewDir = this.toGeVector(viewDirVecNormal);
+        const newGeViewDir = [geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL];
+        const pTarget2 = this.toPoint(view.viewTarget);
+        const newGeViewDirPt = this.toPoint(newGeViewDir);
+        const newPos = pTarget2.add(newGeViewDirPt);
+        pCamera.setupCamera(this.toGePoint(newPos), view.viewTarget, view.upVector);
+        this.deleteAll([pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos]);
+        pCamera.assignView(view);
+        pCamera.delete();
+    }
+    getMaxDimension(view) {
+        const [xmax, ymax, zmax] = view.sceneExtents.max();
+        const [xmin, ymin, zmin] = view.sceneExtents.min();
+        const volume = [xmax - xmin, ymax - ymin, zmax - zmin];
+        return Math.max(...volume);
+    }
+}
+
+const FocalLengthConst = 42.0;
+const calcFocalLength = (lensLength, fieldWidth, fieldHeight) => {
+    return (lensLength / FocalLengthConst) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+};
+class OdaFlyDragger extends OdBaseDragger {
+    constructor(subject) {
+        super(subject);
+        this.viewer = undefined;
+        this.multiplier = 5;
+        this.speed = 1;
+        this.keyPressMap = new Set();
+        this.keydown = this.keydown.bind(this);
+        this.keyup = this.keyup.bind(this);
+        this.lastFrameTS = 0;
+        this.animationId = undefined;
+        this.processMovement = this.processMovement.bind(this);
+        this.deltaAngle = Math.PI / 3600;
+        this.autoSelect = true;
+    }
+    initialize() {
+        super.initialize();
+        this.viewer = this.getViewer();
+        window.addEventListener("keydown", this.keydown, false);
+        window.addEventListener("keyup", this.keyup, false);
+        this.oldWCSEnableValue = this.viewer.getEnableWCS();
+        this.viewer.setEnableWCS(false);
+        const view = this.viewer.activeView;
+        const maxDimension = this.getMaxDimension(view);
+        this.speed = maxDimension / 30000;
+        this.subject.emitEvent({ type: "flystart" });
+        this.viewParams = this.getViewParams();
+        this.setViewParams(this.viewParams);
+        const model = this.viewer.getActiveModel();
+        this.cameraId = model.appendCamera("Camera0");
+        this.setupCamera(view);
+        model.delete();
+        this.cameraFlyer = new this.m_module.OdTvCameraWalker();
+        this.cameraFlyer.setCamera(this.cameraId);
+        this.subject.update();
+        this.enableZoomWheelPreviousValue = this.subject.options.enableZoomWheel;
+        this.subject.options.enableZoomWheel = false;
+    }
+    dispose() {
+        var _a;
+        this.oldWCSEnableValue =
+            this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
+        this.viewer.setEnableWCS(this.oldWCSEnableValue);
+        super.dispose();
+        this.keyPressMap.clear();
+        window.removeEventListener("keydown", this.keydown);
+        window.removeEventListener("keyup", this.keyup);
+        if (this.animationId) {
+            window.cancelAnimationFrame(this.animationId);
+            this.animationId = undefined;
+        }
+        if (this.cameraId) {
+            const model = this.viewer.getActiveModel();
+            model.removeEntity(this.cameraId);
+            model.delete();
+            (_a = this.cameraFlyer) === null || _a === void 0 ? void 0 : _a.delete();
+        }
+        if (this.viewParams) {
+            this.setViewParams(this.viewParams);
+            const avp = this.viewer.activeView;
+            avp.delete();
+        }
+        this.subject.update(true);
+        this.subject.options.enableZoomWheel = this.enableZoomWheelPreviousValue;
+    }
+    keydown(ev) {
+        switch (ev.code) {
+            case "NumpadSubtract":
+            case "Minus":
+                if (this.multiplier > 1) {
+                    this.multiplier = this.multiplier - 1;
+                    this.subject.emitEvent({ type: "flyspeedchange", data: this.multiplier });
+                }
+                break;
+            case "NumpadAdd":
+            case "Equal":
+                if (this.multiplier < 10) {
+                    this.multiplier = this.multiplier + 1;
+                    this.subject.emitEvent({ type: "flyspeedchange", data: this.multiplier });
+                }
+                break;
+            case "KeyW":
+            case "KeyA":
+            case "KeyS":
+            case "KeyD":
+            case "KeyQ":
+            case "KeyE":
+                this.keyPressMap.add(ev.code);
+                if (!this.animationId)
+                    this.processMovement(0);
+                break;
+        }
+    }
+    keyup(ev) {
+        this.keyPressMap.delete(ev.code);
+        if (this.keyPressMap.size < 1 && this.animationId) {
+            window.cancelAnimationFrame(this.animationId);
+            this.animationId = undefined;
+            this.lastFrameTS = 0;
+        }
+    }
+    processMovement(timestamp) {
+        this.animationId = requestAnimationFrame(this.processMovement);
+        if (this.lastFrameTS !== 0) {
+            const deltaTS = timestamp - this.lastFrameTS;
+            const currentDelta = this.multiplier * deltaTS * this.speed;
+            for (const keyCode of this.keyPressMap) {
+                switch (keyCode) {
+                    case "KeyW":
+                        this.cameraFlyer.moveForward(currentDelta);
+                        break;
+                    case "KeyS":
+                        this.cameraFlyer.moveBackward(currentDelta);
+                        break;
+                    case "KeyA":
+                        this.cameraFlyer.moveLeft(currentDelta);
+                        break;
+                    case "KeyD":
+                        this.cameraFlyer.moveRight(currentDelta);
+                        break;
+                    case "KeyQ":
+                        this.cameraFlyer.moveUp(currentDelta);
+                        break;
+                    case "KeyE":
+                        this.cameraFlyer.moveDown(currentDelta);
+                        break;
+                }
+            }
+            this.subject.update();
+            this.subject.emitEvent({ type: "changecamera" });
+        }
+        this.lastFrameTS = timestamp;
+    }
+    start(x, y) {
+        this.dragPosition = { x, y };
+    }
+    drag(x, y) {
+        if (this.cameraId && this.isDragging) {
+            const dltX = x - this.dragPosition.x;
+            const dltY = y - this.dragPosition.y;
+            this.dragPosition = { x, y };
+            if (dltX !== 0.0)
+                this.turnLeft(-dltX * this.deltaAngle);
+            if (dltY !== 0.0)
+                this.cameraFlyer.turnDown(dltY * this.deltaAngle);
+            this.subject.update();
+            this.subject.emitEvent({ type: "changecamera" });
+        }
+    }
+    turnLeft(angle) {
+        const pCamera = this.cameraFlyer.camera().openObjectAsCamera();
+        const dir = this.toVector(pCamera.direction());
+        const up = this.toVector(pCamera.upVector());
+        const pos = pCamera.position();
+        const rotMatrix = this.createMatrix3d();
+        const zAxisVector = [0, 0, 1];
+        rotMatrix.setToRotation(angle, zAxisVector, pos);
+        dir.transformBy(rotMatrix);
+        up.transformBy(rotMatrix);
+        pCamera.setupCameraByDirection(pos, dir.toArray(), up.toArray());
+        pCamera.delete();
+    }
     setupCamera(view) {
         const pCamera = this.cameraId.openObjectAsCamera();
         const target = view.viewTarget;
@@ -1762,6 +1983,7 @@ draggers.registerDragger("CuttingPlaneXAxis", (viewer) => new OdCuttingPlaneXAxi
 draggers.registerDragger("CuttingPlaneYAxis", (viewer) => new OdCuttingPlaneYAxisDragger(viewer));
 draggers.registerDragger("CuttingPlaneZAxis", (viewer) => new OdCuttingPlaneZAxisDragger(viewer));
 draggers.registerDragger("Walk", (viewer) => new OdaWalkDragger(viewer));
+draggers.registerDragger("Fly", (viewer) => new OdaFlyDragger(viewer));
 
 const composeMatrixFromTransform = (transform, modelCenter, visLib) => {
     const { translate, scale, rotation } = transform;