@inweb/viewer-visualize 26.9.4 → 26.9.6

package/dist/viewer-visualize.js

@@ -1258,9 +1258,9 @@
         }
     }
 
-    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) {
@@ -1371,10 +1371,10 @@
                 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);
@@ -1411,6 +1411,27 @@
                 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());
@@ -1424,6 +1445,206 @@
             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;
@@ -2248,6 +2469,7 @@
     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;