@xtctwins/tctwins-core 1.0.22 → 1.0.23

package/dist/tctwins-core.es.js

@@ -95820,182 +95820,168 @@ class MousePickHandler {
  * @private
  */
 class KeyboardPanRotateDollyHandler {
+	constructor(scene, controllers, configs, states, updates) {
+		this._scene = scene;
+		this._updates = updates;
+		const input = scene.input;
 
-    constructor(scene, controllers, configs, states, updates) {
-
-        this._scene = scene;
-        const input = scene.input;
-
-        const keyDownMap = [];
-
-        const canvas = scene.canvas.canvas;
-
-        let mouseMovedSinceLastKeyboardDolly = true;
-
-        this._onSceneMouseMove = input.on("mousemove", () => {
-            mouseMovedSinceLastKeyboardDolly = true;
-        });
-
-        this._onSceneKeyDown = input.on("keydown", (keyCode) => {
-            if (!(configs.active && configs.pointerEnabled) || (!scene.input.keyboardEnabled)) {
-                return;
-            }
-            if (!states.mouseover) {
-                return;
-            }
-            keyDownMap[keyCode] = true;
-
-            if (keyCode === input.KEY_SHIFT) {
-                canvas.style.cursor = "move";
-            }
-        });
-
-        this._onSceneKeyUp = input.on("keyup", (keyCode) => {
-            if (!(configs.active && configs.pointerEnabled) || (!scene.input.keyboardEnabled)) {
-                return;
-            }
-            keyDownMap[keyCode] = false;
-
-            if (keyCode === input.KEY_SHIFT) {
-                canvas.style.cursor = null;
-            }
-
-            if (controllers.pivotController.getPivoting()) {
-                controllers.pivotController.endPivot();
-            }
-        });
-
-        this._onTick = scene.on("tick", (e) => {
-
-            if (!(configs.active && configs.pointerEnabled) || (!scene.input.keyboardEnabled)) {
-                return;
-            }
-
-            if (!states.mouseover) {
-                return;
-            }
-
-            const cameraControl = controllers.cameraControl;
-            const elapsedSecs = (e.deltaTime / 1000.0);
+		const keyDownMap = [];
 
-            //-------------------------------------------------------------------------------------------------
-            // Keyboard rotation
-            //-------------------------------------------------------------------------------------------------
+		const canvas = scene.canvas.canvas;
 
-            if (!configs.planView) {
+		let mouseMovedSinceLastKeyboardDolly = true;
 
-                const rotateYPos = cameraControl._isKeyDownForAction(cameraControl.ROTATE_Y_POS, keyDownMap);
-                const rotateYNeg = cameraControl._isKeyDownForAction(cameraControl.ROTATE_Y_NEG, keyDownMap);
-                const rotateXPos = cameraControl._isKeyDownForAction(cameraControl.ROTATE_X_POS, keyDownMap);
-                const rotateXNeg = cameraControl._isKeyDownForAction(cameraControl.ROTATE_X_NEG, keyDownMap);
+		this._onSceneMouseMove = input.on("mousemove", () => {
+			mouseMovedSinceLastKeyboardDolly = true;
+		});
 
-                const orbitDelta = elapsedSecs * configs.keyboardRotationRate;
+		this._onSceneKeyDown = input.on("keydown", (keyCode) => {
+			if (!(configs.active && configs.pointerEnabled) || !scene.input.keyboardEnabled) {
+				return;
+			}
+			if (!states.mouseover) {
+				return;
+			}
+			keyDownMap[keyCode] = true;
 
-                if (rotateYPos || rotateYNeg || rotateXPos || rotateXNeg) {
+			if (keyCode === input.KEY_SHIFT) {
+				canvas.style.cursor = "move";
+			}
+		});
 
-                    if ((!configs.firstPerson) && configs.followPointer) {
-                        controllers.pivotController.startPivot();
-                    }
+		this._onSceneKeyUp = input.on("keyup", (keyCode) => {
+			if (!(configs.active && configs.pointerEnabled) || !scene.input.keyboardEnabled) {
+				return;
+			}
+			keyDownMap[keyCode] = false;
 
-                    if (rotateYPos) {
-                        updates.rotateDeltaY += orbitDelta;
+			if (keyCode === input.KEY_SHIFT) {
+				canvas.style.cursor = null;
+			}
 
-                    } else if (rotateYNeg) {
-                        updates.rotateDeltaY -= orbitDelta;
-                    }
+			if (controllers.pivotController.getPivoting()) {
+				controllers.pivotController.endPivot();
+			}
+		});
 
-                    if (rotateXPos) {
-                        updates.rotateDeltaX += orbitDelta;
+		this._onTick = scene.on("tick", (e) => {
+			if (!(configs.active && configs.pointerEnabled) || !scene.input.keyboardEnabled) {
+				return;
+			}
 
-                    } else if (rotateXNeg) {
-                        updates.rotateDeltaX -= orbitDelta;
-                    }
+			if (!states.mouseover) {
+				return;
+			}
 
-                    if ((!configs.firstPerson) && configs.followPointer) {
-                        controllers.pivotController.startPivot();
-                    }
-                }
-            }
+			const cameraControl = controllers.cameraControl;
+			const elapsedSecs = e.deltaTime / 1000.0;
 
-            //-------------------------------------------------------------------------------------------------
-            // Keyboard panning
-            //-------------------------------------------------------------------------------------------------
+			//-------------------------------------------------------------------------------------------------
+			// Keyboard rotation
+			//-------------------------------------------------------------------------------------------------
 
-            if (!keyDownMap[input.KEY_CTRL] && !keyDownMap[input.KEY_ALT]) {
+			if (!configs.planView) {
+				const rotateYPos = cameraControl._isKeyDownForAction(cameraControl.ROTATE_Y_POS, keyDownMap);
+				const rotateYNeg = cameraControl._isKeyDownForAction(cameraControl.ROTATE_Y_NEG, keyDownMap);
+				const rotateXPos = cameraControl._isKeyDownForAction(cameraControl.ROTATE_X_POS, keyDownMap);
+				const rotateXNeg = cameraControl._isKeyDownForAction(cameraControl.ROTATE_X_NEG, keyDownMap);
 
-                const dollyBackwards = cameraControl._isKeyDownForAction(cameraControl.DOLLY_BACKWARDS, keyDownMap);
-                const dollyForwards = cameraControl._isKeyDownForAction(cameraControl.DOLLY_FORWARDS, keyDownMap);
+				const orbitDelta = elapsedSecs * configs.keyboardRotationRate;
 
-                if (dollyBackwards || dollyForwards) {
+				if (rotateYPos || rotateYNeg || rotateXPos || rotateXNeg) {
+					if (!configs.firstPerson && configs.followPointer) {
+						controllers.pivotController.startPivot();
+					}
 
-                    const dollyDelta = elapsedSecs * configs.keyboardDollyRate;
+					if (rotateYPos) {
+						updates.rotateDeltaY += orbitDelta;
+					} else if (rotateYNeg) {
+						updates.rotateDeltaY -= orbitDelta;
+					}
 
-                    if ((!configs.firstPerson) && configs.followPointer) {
-                        controllers.pivotController.startPivot();
-                    }
-                    if (dollyForwards) {
-                        updates.dollyDelta -= dollyDelta;
-                    } else if (dollyBackwards) {
-                        updates.dollyDelta += dollyDelta;
-                    }
+					if (rotateXPos) {
+						updates.rotateDeltaX += orbitDelta;
+					} else if (rotateXNeg) {
+						updates.rotateDeltaX -= orbitDelta;
+					}
 
-                    if (mouseMovedSinceLastKeyboardDolly) {
-                        states.followPointerDirty = true;
-                        mouseMovedSinceLastKeyboardDolly = false;
-                    }
-                }
-            }
+					if (!configs.firstPerson && configs.followPointer) {
+						controllers.pivotController.startPivot();
+					}
+				}
+			}
 
-            const panForwards = cameraControl._isKeyDownForAction(cameraControl.PAN_FORWARDS, keyDownMap);
-            const panBackwards = cameraControl._isKeyDownForAction(cameraControl.PAN_BACKWARDS, keyDownMap);
-            const panLeft = cameraControl._isKeyDownForAction(cameraControl.PAN_LEFT, keyDownMap);
-            const panRight = cameraControl._isKeyDownForAction(cameraControl.PAN_RIGHT, keyDownMap);
-            const panUp = cameraControl._isKeyDownForAction(cameraControl.PAN_UP, keyDownMap);
-            const panDown = cameraControl._isKeyDownForAction(cameraControl.PAN_DOWN, keyDownMap);
+			//-------------------------------------------------------------------------------------------------
+			// Keyboard panning
+			//-------------------------------------------------------------------------------------------------
 
-            const panDelta = (keyDownMap[input.KEY_ALT] ? 0.3 : 1.0) * elapsedSecs * configs.keyboardPanRate; // ALT for slower pan rate
+			if (!keyDownMap[input.KEY_CTRL] && !keyDownMap[input.KEY_ALT]) {
+				const dollyBackwards = cameraControl._isKeyDownForAction(cameraControl.DOLLY_BACKWARDS, keyDownMap);
+				const dollyForwards = cameraControl._isKeyDownForAction(cameraControl.DOLLY_FORWARDS, keyDownMap);
 
-            if (panForwards || panBackwards || panLeft || panRight || panUp || panDown) {
+				if (dollyBackwards || dollyForwards) {
+					const dollyDelta = elapsedSecs * configs.keyboardDollyRate;
 
-                if ((!configs.firstPerson) && configs.followPointer) {
-                    controllers.pivotController.startPivot();
-                }
+					if (!configs.firstPerson && configs.followPointer) {
+						controllers.pivotController.startPivot();
+					}
+					if (dollyForwards) {
+						updates.dollyDelta -= dollyDelta;
+					} else if (dollyBackwards) {
+						updates.dollyDelta += dollyDelta;
+					}
 
-                if (panDown) {
-                    updates.panDeltaY += panDelta;
+					if (mouseMovedSinceLastKeyboardDolly) {
+						states.followPointerDirty = true;
+						mouseMovedSinceLastKeyboardDolly = false;
+					}
+				}
+			}
 
-                } else if (panUp) {
-                    updates.panDeltaY += -panDelta;
-                }
+			const panForwards = cameraControl._isKeyDownForAction(cameraControl.PAN_FORWARDS, keyDownMap);
+			const panBackwards = cameraControl._isKeyDownForAction(cameraControl.PAN_BACKWARDS, keyDownMap);
+			const panLeft = cameraControl._isKeyDownForAction(cameraControl.PAN_LEFT, keyDownMap);
+			const panRight = cameraControl._isKeyDownForAction(cameraControl.PAN_RIGHT, keyDownMap);
+			const panUp = cameraControl._isKeyDownForAction(cameraControl.PAN_UP, keyDownMap);
+			const panDown = cameraControl._isKeyDownForAction(cameraControl.PAN_DOWN, keyDownMap);
 
-                if (panRight) {
-                    updates.panDeltaX += -panDelta;
+			const panDelta = (keyDownMap[input.KEY_ALT] ? 0.3 : 1.0) * elapsedSecs * configs.keyboardPanRate; // ALT for slower pan rate
 
-                } else if (panLeft) {
-                    updates.panDeltaX += panDelta;
-                }
+			if (panForwards || panBackwards || panLeft || panRight || panUp || panDown) {
+				if (!configs.firstPerson && configs.followPointer) {
+					controllers.pivotController.startPivot();
+				}
 
-                if (panBackwards) {
-                    updates.panDeltaZ += panDelta;
+				if (panDown) {
+					updates.panDeltaY += panDelta;
+				} else if (panUp) {
+					updates.panDeltaY += -panDelta;
+				}
 
-                } else if (panForwards) {
-                    updates.panDeltaZ += -panDelta;
-                }
-            }
-        });
-    }
+				if (panRight) {
+					updates.panDeltaX += -panDelta;
+				} else if (panLeft) {
+					updates.panDeltaX += panDelta;
+				}
 
-    reset() {
-    }
+				if (panBackwards) {
+					updates.panDeltaZ += panDelta;
+				} else if (panForwards) {
+					updates.panDeltaZ += -panDelta;
+				}
+			}
+		});
+	}
 
-    destroy() {
+	reset() {}
 
-        this._scene.off(this._onTick);
+	destroy() {
+		this._scene.off(this._onTick);
 
-        this._scene.input.off(this._onSceneMouseMove);
-        this._scene.input.off(this._onSceneKeyDown);
-        this._scene.input.off(this._onSceneKeyUp);
-    }
+		this._scene.input.off(this._onSceneMouseMove);
+		this._scene.input.off(this._onSceneKeyDown);
+		this._scene.input.off(this._onSceneKeyUp);
+	}
 }
 
 const SCALE_DOLLY_EACH_FRAME = 1; // Recalculate dolly speed for eye->target distance on each Nth frame
@@ -97639,6 +97625,95 @@ class CameraControl extends Component {
 		this.pointerEnabled = true;
 		this.keyboardDollyRate = cfg.keyboardDollyRate;
 		this.mouseWheelDollyRate = cfg.mouseWheelDollyRate;
+		this._moveRate = 1;
+		this.scene.on("tick", () => {
+			// if (!(this._configs.active && this._configs.pointerEnabled)) return;
+			// if (!this._states.mouseover) return;
+			if (!(this._goLeft || this._goRight || this._goUp || this._goDown || this._goForward || this._goBackward)) {
+				// this._inputDirectionCommand = false;
+				return;
+			}
+			if (this._goRight) {
+				this._updates.panDeltaX += -0.1 * this._moveRate;
+			} else if (this._goLeft) {
+				this._updates.panDeltaX += 0.1 * this._moveRate;
+			}
+
+			if (this._goUp) {
+				this._updates.panDeltaY += 0.1 * this._moveRate;
+			} else if (this._goDown) {
+				this._updates.panDeltaY += -0.1 * this._moveRate;
+			}
+
+			if (this._goForward) {
+				this._updates.panDeltaZ += -0.1 * this._moveRate;
+			} else if (this._goBackward) {
+				this._updates.panDeltaZ += +0.1 * this._moveRate;
+			}
+			this._inputDirectionCommand = true;
+		});
+	}
+	/**
+	 * 停止漫游
+	 */
+	setdirectionChangeCancel() {
+		this._goLeft = false;
+		this._goRight = false;
+		this._goUp = false;
+		this._goDown = false;
+		this._goForward = false;
+		this._goBackward = false;
+	}
+
+	/**
+	 * 设置漫游移动速率
+	 *  @param {number} rate
+	 */
+	set moveRate(rate) {
+		this._moveRate = rate;
+	}
+
+	/**
+	 * 漫游向右
+	 * @param {boolean} go
+	 */
+	set goRight(go) {
+		this._goRight = go;
+	}
+	/**
+	 * 漫游向左
+	 * @param {boolean} go
+	 */
+	set goLeft(go) {
+		this._goLeft = go;
+	}
+	/**
+	 * 漫游向上
+	 * @param {boolean} go
+	 */
+	set goUp(go) {
+		this._goUp = go;
+	}
+	/**
+	 * 漫游向下
+	 * @param {boolean} go
+	 */
+	set goDown(go) {
+		this._goDown = go;
+	}
+	/**
+	 * 漫游向前
+	 * @param {boolean} go
+	 */
+	set goForward(go) {
+		this._goForward = go;
+	}
+	/**
+	 * 漫游向后
+	 * @param {boolean} go
+	 */
+	set goBackward(go) {
+		this._goBackward = go;
 	}
 
 	updatePivotElement() {
@@ -117492,14 +117567,14 @@ class NavCubePlugin extends Plugin {
 		this.setIsProjectNorth(cfg.isProjectNorth);
 		this.setProjectNorthOffsetAngle(cfg.projectNorthOffsetAngle);
 
-		const rotateTrueNorth = (function () {
+		const rotateTrueNorth = (this.rotateTrueNorth = (function () {
 			const trueNorthMatrix = math.mat4();
 			return function (dir, vec, dest) {
 				math.identityMat4(trueNorthMatrix);
 				math.rotationMat4v(dir * self._projectNorthOffsetAngle * math.DEGTORAD, [0, 1, 0], trueNorthMatrix);
 				return math.transformVec3(trueNorthMatrix, vec, dest);
 			};
-		})();
+		})());
 
 		this._synchCamera = (function () {
 			var matrix = math.rotationMat4c(-90 * math.DEGTORAD, 1, 0, 0);
@@ -117727,6 +117802,7 @@ class NavCubePlugin extends Plugin {
 					if (hit) {
 						if (hit.uv) {
 							var areaId = self._cubeTextureCanvas.getArea(hit.uv);
+							console.log(areaId);
 							if (areaId >= 0) {
 								document.body.style.cursor = "pointer";
 								if (lastAreaId >= 0) {
@@ -117748,6 +117824,8 @@ class NavCubePlugin extends Plugin {
 											dir = rotateTrueNorth(+1, dir, tempVec3a$4);
 											up = rotateTrueNorth(+1, up, tempVec3b$1);
 										}
+										console.log(dir);
+										console.log(up);
 										flyTo(dir, up, function () {
 											if (lastAreaId >= 0) {
 												self._cubeTextureCanvas.setAreaHighlighted(lastAreaId, false);
@@ -117827,7 +117905,7 @@ class NavCubePlugin extends Plugin {
 				})
 			);
 
-			var flyTo = (function () {
+			var flyTo = (this.flyTo = (function () {
 				var center = math.vec3();
 				return function (dir, up, ok) {
 					var aabb = self._fitVisible ? viewer.scene.getAABB(viewer.scene.visibleObjectIds) : viewer.scene.aabb;
@@ -117860,7 +117938,7 @@ class NavCubePlugin extends Plugin {
 						);
 					}
 				};
-			})();
+			})());
 		}
 
 		this._onUpdated = viewer.localeService.on("updated", () => {
@@ -117876,6 +117954,28 @@ class NavCubePlugin extends Plugin {
 		this.setSynchProjection(cfg.synchProjection);
 	}
 
+	flyByClick(areaId) {
+		if (areaId >= 0) {
+			this._cubeTextureCanvas.setAreaHighlighted(areaId, true);
+			this._repaint();
+			var dir = this._cubeTextureCanvas.getAreaDir(areaId);
+			if (dir) {
+				var up = this._cubeTextureCanvas.getAreaUp(areaId);
+				if (this._isProjectNorth && this._projectNorthOffsetAngle) {
+					dir = this.rotateTrueNorth(+1, dir, tempVec3a$4);
+					up = this.rotateTrueNorth(+1, up, tempVec3b$1);
+				}
+				this.flyTo(dir, up, function () {
+					document.body.style.cursor = "pointer";
+				});
+			}
+		}
+	}
+
+	get navCubeScene() {
+		return this._navCubeScene;
+	}
+
 	send(name, value) {
 		switch (name) {
 			case "language":