@ohuoy/easymap 1.0.0 → 1.0.2

package/lib/@antv/l7-core/lib/services/camera/Camera.d.ts

@@ -0,0 +1,205 @@
+import { mat4, vec3 } from 'gl-matrix';
+export declare enum CAMERA_TYPE {
+    ORBITING = "ORBITING",
+    EXPLORING = "EXPLORING",
+    TRACKING = "TRACKING"
+}
+export declare enum CAMERA_TRACKING_MODE {
+    DEFAULT = "DEFAULT",
+    ROTATIONAL = "ROTATIONAL",
+    TRANSLATIONAL = "TRANSLATIONAL",
+    CINEMATIC = "CINEMATIC"
+}
+/**
+ * 参考「WebGL Insights - 23.Designing Cameras for WebGL Applications」，基于 Responsible Camera 思路设计
+ * 保存相机参数，定义相机动作：
+ * 1. dolly 沿 n 轴移动
+ * 2. pan 沿 u v 轴移动
+ * 3. rotate 以方位角旋转
+ * 4. 移动到 Landmark，具有平滑的动画效果，其间禁止其他用户交互
+ */
+export default class Camera {
+    /**
+     * 相机矩阵
+     */
+    matrix: mat4;
+    /**
+     * u 轴
+     * @see http://learnwebgl.brown37.net/07_cameras/camera_introduction.html#a-camera-definition
+     */
+    right: vec3;
+    /**
+     * v 轴
+     */
+    up: vec3;
+    /**
+     * n 轴
+     */
+    forward: vec3;
+    /**
+     * 相机位置
+     */
+    position: vec3;
+    /**
+     * 视点位置
+     */
+    focalPoint: vec3;
+    /**
+     * 相机位置到视点向量
+     * focalPoint - position
+     */
+    distanceVector: vec3;
+    /**
+     * 相机位置到视点距离
+     * length(focalPoint - position)
+     */
+    distance: number;
+    /**
+     * @see https://en.wikipedia.org/wiki/Azimuth
+     */
+    azimuth: number;
+    elevation: number;
+    roll: number;
+    relAzimuth: number;
+    relElevation: number;
+    relRoll: number;
+    /**
+     * 沿 n 轴移动时，保证移动速度从快到慢
+     */
+    dollyingStep: number;
+    /**
+     * invert the horizontal coordinate system HCS
+     */
+    rotateWorld: boolean;
+    /**
+     * 投影矩阵参数
+     */
+    /**
+     * field of view [0-360]
+     * @see http://en.wikipedia.org/wiki/Angle_of_view
+     */
+    private fov;
+    private near;
+    private far;
+    private aspect;
+    /**
+     * 投影矩阵
+     */
+    private perspective;
+    private following;
+    private type;
+    private trackingMode;
+    constructor(type: CAMERA_TYPE);
+    setType(type: CAMERA_TYPE, trackingMode: CAMERA_TRACKING_MODE | undefined): void;
+    setTrackingMode(trackingMode: CAMERA_TRACKING_MODE): void;
+    /**
+     * If flag is true, it reverses the azimuth and elevation angles.
+     * Subsequent calls to rotate, setAzimuth, setElevation,
+     * changeAzimuth or changeElevation will cause the inverted effect.
+     * setRoll or changeRoll is not affected by this method.
+     *
+     * This inversion is useful when one wants to simulate that the world
+     * is moving, instead of the camera.
+     *
+     * By default the camera angles are not reversed.
+     * @param {Boolean} flag the boolean flag to reverse the angles.
+     */
+    setWorldRotation(flag: boolean): void;
+    /**
+     * 计算 MV 矩阵，为相机矩阵的逆矩阵
+     */
+    getViewTransform(): mat4 | null;
+    /**
+     * 设置相机矩阵
+     */
+    setMatrix(matrix: mat4): void;
+    setPerspective(near: number, far: number, angle: number, aspect: number): void;
+    updatePerspective(): void;
+    /**
+     * 设置相机位置
+     */
+    setPosition(x: number, y: number, z: number): this;
+    /**
+     * 设置视点位置
+     */
+    setFocalPoint(x: number | vec3, y?: number, z?: number): this;
+    /**
+     * 固定当前视点，按指定距离放置相机
+     */
+    setDistance(d: number): this | undefined;
+    /**
+     * Changes the initial azimuth of the camera
+     */
+    changeAzimuth(az: number): this;
+    /**
+     * Changes the initial elevation of the camera
+     */
+    changeElevation(el: number): this;
+    /**
+     * Changes the initial roll of the camera
+     */
+    changeRoll(rl: number): this;
+    /**
+     * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+     * @param {Number} el the azimuth in degrees
+     */
+    setAzimuth(az: number): this;
+    getAzimuth(): number;
+    /**
+     * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+     * @param {Number} el the elevation in degrees
+     */
+    setElevation(el: number): this;
+    /**
+     * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+     * @param {Number} angle the roll angle
+     */
+    setRoll(angle: number): this;
+    /**
+     * Changes the azimuth and elevation with respect to the current camera axes
+     * @param {Number} azimuth the relative azimuth
+     * @param {Number} elevation the relative elevation
+     * @param {Number} roll the relative roll
+     */
+    rotate(azimuth: number, elevation: number, roll: number): this | undefined;
+    /**
+     * 沿水平(right) & 垂直(up)平移相机
+     */
+    pan(tx: number, ty: number): this;
+    /**
+     * 沿 n 轴移动，当距离视点远时移动速度较快，离视点越近速度越慢
+     */
+    dolly(value: number): this;
+    /**
+     * 根据相机矩阵重新计算各种相机参数
+     */
+    private _update;
+    /**
+     * 计算相机矩阵
+     */
+    private computeMatrix;
+    /**
+     * Sets the camera position in the camera matrix
+     */
+    private _setPosition;
+    /**
+     * Recalculates axes based on the current matrix
+     */
+    private _getAxes;
+    /**
+     * Recalculates euler angles based on the current state
+     */
+    private _getAngles;
+    /**
+     * 重新计算相机位置，只有 ORBITING 模式相机位置才会发生变化
+     */
+    private _getPosition;
+    /**
+     * 重新计算视点，只有 TRACKING 模式视点才会发生变化
+     */
+    private _getFocalPoint;
+    /**
+     * 重新计算视距
+     */
+    private _getDistance;
+}

package/lib/@antv/l7-core/lib/services/camera/Camera.js

@@ -0,0 +1,498 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CAMERA_TYPE = exports.CAMERA_TRACKING_MODE = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _glMatrix = require("gl-matrix");
+var _math = require("../../utils/math");
+// import Landmark from './Landmark';
+let CAMERA_TYPE = exports.CAMERA_TYPE = /*#__PURE__*/function (CAMERA_TYPE) {
+  CAMERA_TYPE["ORBITING"] = "ORBITING";
+  CAMERA_TYPE["EXPLORING"] = "EXPLORING";
+  CAMERA_TYPE["TRACKING"] = "TRACKING";
+  return CAMERA_TYPE;
+}({});
+let CAMERA_TRACKING_MODE = exports.CAMERA_TRACKING_MODE = /*#__PURE__*/function (CAMERA_TRACKING_MODE) {
+  CAMERA_TRACKING_MODE["DEFAULT"] = "DEFAULT";
+  CAMERA_TRACKING_MODE["ROTATIONAL"] = "ROTATIONAL";
+  CAMERA_TRACKING_MODE["TRANSLATIONAL"] = "TRANSLATIONAL";
+  CAMERA_TRACKING_MODE["CINEMATIC"] = "CINEMATIC";
+  return CAMERA_TRACKING_MODE;
+}({});
+const DEG_2_RAD = Math.PI / 180;
+const RAD_2_DEG = 180 / Math.PI;
+
+/**
+ * 参考「WebGL Insights - 23.Designing Cameras for WebGL Applications」，基于 Responsible Camera 思路设计
+ * 保存相机参数，定义相机动作：
+ * 1. dolly 沿 n 轴移动
+ * 2. pan 沿 u v 轴移动
+ * 3. rotate 以方位角旋转
+ * 4. 移动到 Landmark，具有平滑的动画效果，其间禁止其他用户交互
+ */
+class Camera {
+  constructor(type) {
+    /**
+     * 相机矩阵
+     */
+    (0, _defineProperty2.default)(this, "matrix", _glMatrix.mat4.create());
+    /**
+     * u 轴
+     * @see http://learnwebgl.brown37.net/07_cameras/camera_introduction.html#a-camera-definition
+     */
+    (0, _defineProperty2.default)(this, "right", _glMatrix.vec3.fromValues(1, 0, 0));
+    /**
+     * v 轴
+     */
+    (0, _defineProperty2.default)(this, "up", _glMatrix.vec3.fromValues(0, 1, 0));
+    /**
+     * n 轴
+     */
+    (0, _defineProperty2.default)(this, "forward", _glMatrix.vec3.fromValues(0, 0, 1));
+    /**
+     * 相机位置
+     */
+    (0, _defineProperty2.default)(this, "position", _glMatrix.vec3.fromValues(0, 0, 1));
+    /**
+     * 视点位置
+     */
+    (0, _defineProperty2.default)(this, "focalPoint", _glMatrix.vec3.fromValues(0, 0, 0));
+    /**
+     * 相机位置到视点向量
+     * focalPoint - position
+     */
+    (0, _defineProperty2.default)(this, "distanceVector", _glMatrix.vec3.fromValues(0, 0, 0));
+    /**
+     * 相机位置到视点距离
+     * length(focalPoint - position)
+     */
+    (0, _defineProperty2.default)(this, "distance", 1);
+    /**
+     * @see https://en.wikipedia.org/wiki/Azimuth
+     */
+    (0, _defineProperty2.default)(this, "azimuth", 0);
+    (0, _defineProperty2.default)(this, "elevation", 0);
+    (0, _defineProperty2.default)(this, "roll", 0);
+    (0, _defineProperty2.default)(this, "relAzimuth", 0);
+    (0, _defineProperty2.default)(this, "relElevation", 0);
+    (0, _defineProperty2.default)(this, "relRoll", 0);
+    /**
+     * 沿 n 轴移动时，保证移动速度从快到慢
+     */
+    (0, _defineProperty2.default)(this, "dollyingStep", 0);
+    /**
+     * invert the horizontal coordinate system HCS
+     */
+    (0, _defineProperty2.default)(this, "rotateWorld", false);
+    /**
+     * 投影矩阵参数
+     */
+    /**
+     * field of view [0-360]
+     * @see http://en.wikipedia.org/wiki/Angle_of_view
+     */
+    (0, _defineProperty2.default)(this, "fov", 30);
+    (0, _defineProperty2.default)(this, "near", 0.1);
+    (0, _defineProperty2.default)(this, "far", 10000);
+    (0, _defineProperty2.default)(this, "aspect", 1);
+    /**
+     * 投影矩阵
+     */
+    (0, _defineProperty2.default)(this, "perspective", _glMatrix.mat4.create());
+    (0, _defineProperty2.default)(this, "following", undefined);
+    (0, _defineProperty2.default)(this, "type", CAMERA_TYPE.EXPLORING);
+    (0, _defineProperty2.default)(this, "trackingMode", CAMERA_TRACKING_MODE.DEFAULT);
+    this.setType(type, undefined);
+  }
+  setType(type, trackingMode) {
+    this.type = type;
+    if (this.type === CAMERA_TYPE.EXPLORING) {
+      this.setWorldRotation(true);
+    } else {
+      this.setWorldRotation(false);
+    }
+    this._getAngles();
+    if (this.type === CAMERA_TYPE.TRACKING && trackingMode !== undefined) {
+      this.setTrackingMode(trackingMode);
+    }
+  }
+  setTrackingMode(trackingMode) {
+    if (this.type !== CAMERA_TYPE.TRACKING) {
+      throw new Error('Impossible to set a tracking mode if the camera is not of tracking type');
+    }
+    this.trackingMode = trackingMode;
+  }
+
+  /**
+   * If flag is true, it reverses the azimuth and elevation angles.
+   * Subsequent calls to rotate, setAzimuth, setElevation,
+   * changeAzimuth or changeElevation will cause the inverted effect.
+   * setRoll or changeRoll is not affected by this method.
+   *
+   * This inversion is useful when one wants to simulate that the world
+   * is moving, instead of the camera.
+   *
+   * By default the camera angles are not reversed.
+   * @param {Boolean} flag the boolean flag to reverse the angles.
+   */
+  setWorldRotation(flag) {
+    this.rotateWorld = flag;
+    this._getAngles();
+  }
+
+  /**
+   * 计算 MV 矩阵，为相机矩阵的逆矩阵
+   */
+  getViewTransform() {
+    return _glMatrix.mat4.invert(_glMatrix.mat4.create(), this.matrix);
+  }
+
+  /**
+   * 设置相机矩阵
+   */
+  setMatrix(matrix) {
+    this.matrix = matrix;
+    this._update();
+  }
+  setPerspective(near, far, angle, aspect) {
+    this.fov = angle;
+    this.near = near;
+    this.far = far;
+    this.aspect = aspect;
+    this.updatePerspective();
+  }
+  updatePerspective() {
+    _glMatrix.mat4.perspective(this.perspective, this.fov * DEG_2_RAD, this.aspect, this.near, this.far);
+  }
+
+  /**
+   * 设置相机位置
+   */
+  setPosition(x, y, z) {
+    this._setPosition(x, y, z);
+    this.setFocalPoint(this.focalPoint);
+    return this;
+  }
+
+  /**
+   * 设置视点位置
+   */
+  setFocalPoint(x, y, z) {
+    let up = _glMatrix.vec3.fromValues(0, 1, 0);
+    this.focalPoint = (0, _math.createVec3)(x, y, z);
+    if (this.trackingMode === CAMERA_TRACKING_MODE.CINEMATIC) {
+      const d = _glMatrix.vec3.subtract(_glMatrix.vec3.create(), this.focalPoint, this.position);
+      x = d[0];
+      y = d[1];
+      z = d[2];
+      const r = _glMatrix.vec3.length(d);
+      const el = Math.asin(y / r) * RAD_2_DEG;
+      const az = 90 + Math.atan2(z, x) * RAD_2_DEG;
+      const m = _glMatrix.mat4.create();
+      _glMatrix.mat4.rotateY(m, m, az * DEG_2_RAD);
+      _glMatrix.mat4.rotateX(m, m, el * DEG_2_RAD);
+      up = _glMatrix.vec3.transformMat4(_glMatrix.vec3.create(), [0, 1, 0], m);
+    }
+    _glMatrix.mat4.invert(this.matrix, _glMatrix.mat4.lookAt(_glMatrix.mat4.create(), this.position, this.focalPoint, up));
+    this._getAxes();
+    this._getDistance();
+    this._getAngles();
+    return this;
+  }
+
+  /**
+   * 固定当前视点，按指定距离放置相机
+   */
+  setDistance(d) {
+    if (this.distance === d || d < 0) {
+      return;
+    }
+    this.distance = d;
+    this.dollyingStep = this.distance / 100;
+    const pos = _glMatrix.vec3.create();
+    const n = this.forward;
+    const f = this.focalPoint;
+    pos[0] = d * n[0] + f[0];
+    pos[1] = d * n[1] + f[1];
+    pos[2] = d * n[2] + f[2];
+    this._setPosition(pos);
+    return this;
+  }
+
+  /**
+   * Changes the initial azimuth of the camera
+   */
+  changeAzimuth(az) {
+    this.setAzimuth(this.azimuth + az);
+    return this;
+  }
+
+  /**
+   * Changes the initial elevation of the camera
+   */
+  changeElevation(el) {
+    this.setElevation(this.elevation + el);
+    return this;
+  }
+
+  /**
+   * Changes the initial roll of the camera
+   */
+  changeRoll(rl) {
+    this.setRoll(this.roll + rl);
+    return this;
+  }
+
+  /**
+   * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+   * @param {Number} el the azimuth in degrees
+   */
+  setAzimuth(az) {
+    this.azimuth = (0, _math.getAngle)(az);
+    this.computeMatrix();
+    this._getAxes();
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      this._getPosition();
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      this._getFocalPoint();
+    }
+    return this;
+  }
+  getAzimuth() {
+    return this.azimuth;
+  }
+
+  /**
+   * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+   * @param {Number} el the elevation in degrees
+   */
+  setElevation(el) {
+    this.elevation = (0, _math.getAngle)(el);
+    this.computeMatrix();
+    this._getAxes();
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      this._getPosition();
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      this._getFocalPoint();
+    }
+    return this;
+  }
+
+  /**
+   * 设置相机方位角，不同相机模式下需要重新计算相机位置或者是视点位置
+   * @param {Number} angle the roll angle
+   */
+  setRoll(angle) {
+    this.roll = (0, _math.getAngle)(angle);
+    this.computeMatrix();
+    this._getAxes();
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      this._getPosition();
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      this._getFocalPoint();
+    }
+    return this;
+  }
+
+  /**
+   * Changes the azimuth and elevation with respect to the current camera axes
+   * @param {Number} azimuth the relative azimuth
+   * @param {Number} elevation the relative elevation
+   * @param {Number} roll the relative roll
+   */
+  rotate(azimuth, elevation, roll) {
+    if (this.type === CAMERA_TYPE.EXPLORING) {
+      azimuth = (0, _math.getAngle)(azimuth);
+      elevation = (0, _math.getAngle)(elevation);
+      roll = (0, _math.getAngle)(roll);
+      const rotX = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [1, 0, 0], (this.rotateWorld ? 1 : -1) * elevation * DEG_2_RAD);
+      const rotY = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [0, 1, 0], (this.rotateWorld ? 1 : -1) * azimuth * DEG_2_RAD);
+      const rotZ = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [0, 0, 1], roll * DEG_2_RAD);
+      let rotQ = _glMatrix.quat.multiply(_glMatrix.quat.create(), rotY, rotX);
+      rotQ = _glMatrix.quat.multiply(_glMatrix.quat.create(), rotQ, rotZ);
+      const rotMatrix = _glMatrix.mat4.fromQuat(_glMatrix.mat4.create(), rotQ);
+      _glMatrix.mat4.translate(this.matrix, this.matrix, [0, 0, -this.distance]);
+      _glMatrix.mat4.multiply(this.matrix, this.matrix, rotMatrix);
+      _glMatrix.mat4.translate(this.matrix, this.matrix, [0, 0, this.distance]);
+    } else {
+      if (Math.abs(this.elevation + elevation) > 90) {
+        return;
+      }
+      this.relElevation = (0, _math.getAngle)(elevation);
+      this.relAzimuth = (0, _math.getAngle)(azimuth);
+      this.relRoll = (0, _math.getAngle)(roll);
+      this.elevation += this.relElevation;
+      this.azimuth += this.relAzimuth;
+      this.roll += this.relRoll;
+      this.computeMatrix();
+    }
+    this._getAxes();
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      this._getPosition();
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      this._getFocalPoint();
+    }
+    this._update();
+    return this;
+  }
+
+  /**
+   * 沿水平(right) & 垂直(up)平移相机
+   */
+  pan(tx, ty) {
+    const coords = (0, _math.createVec3)(tx, ty, 0);
+    const pos = _glMatrix.vec3.clone(this.position);
+    _glMatrix.vec3.add(pos, pos, _glMatrix.vec3.scale(_glMatrix.vec3.create(), this.right, coords[0]));
+    _glMatrix.vec3.add(pos, pos, _glMatrix.vec3.scale(_glMatrix.vec3.create(), this.up, coords[1]));
+    this._setPosition(pos);
+    return this;
+  }
+
+  /**
+   * 沿 n 轴移动，当距离视点远时移动速度较快，离视点越近速度越慢
+   */
+  dolly(value) {
+    const n = this.forward;
+    const pos = _glMatrix.vec3.clone(this.position);
+    const step = value * this.dollyingStep;
+    pos[0] += step * n[0];
+    pos[1] += step * n[1];
+    pos[2] += step * n[2];
+    this._setPosition(pos);
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      // 重新计算视点距离
+      this._getDistance();
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      // 保持视距，移动视点位置
+      _glMatrix.vec3.add(this.focalPoint, pos, this.distanceVector);
+    }
+    return this;
+  }
+
+  // public createLandmark(name: string): Landmark {
+  //   return new Landmark(name, this);
+  // }
+
+  /**
+   * 根据相机矩阵重新计算各种相机参数
+   */
+  _update() {
+    this._getAxes();
+    this._getPosition();
+    this._getDistance();
+    this._getAngles();
+  }
+
+  /**
+   * 计算相机矩阵
+   */
+  computeMatrix() {
+    // 使用四元数描述 3D 旋转
+    // @see https://xiaoiver.github.io/coding/2018/12/28/Camera-%E8%AE%BE%E8%AE%A1-%E4%B8%80.html
+    const rotZ = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [0, 0, 1], this.roll * DEG_2_RAD);
+    _glMatrix.mat4.identity(this.matrix);
+
+    // only consider HCS for EXPLORING and ORBITING cameras
+    const rotX = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [1, 0, 0], (this.rotateWorld || this.type === CAMERA_TYPE.TRACKING ? 1 : -1) * this.elevation * DEG_2_RAD);
+    const rotY = _glMatrix.quat.setAxisAngle(_glMatrix.quat.create(), [0, 1, 0], (this.rotateWorld ? 1 : -1) * this.azimuth * DEG_2_RAD);
+    let rotQ = _glMatrix.quat.multiply(_glMatrix.quat.create(), rotY, rotX);
+    rotQ = _glMatrix.quat.multiply(_glMatrix.quat.create(), rotQ, rotZ);
+    const rotMatrix = _glMatrix.mat4.fromQuat(_glMatrix.mat4.create(), rotQ);
+    if (this.type === CAMERA_TYPE.ORBITING || this.type === CAMERA_TYPE.EXPLORING) {
+      _glMatrix.mat4.translate(this.matrix, this.matrix, this.focalPoint);
+      _glMatrix.mat4.multiply(this.matrix, this.matrix, rotMatrix);
+      _glMatrix.mat4.translate(this.matrix, this.matrix, [0, 0, this.distance]);
+    } else if (this.type === CAMERA_TYPE.TRACKING) {
+      _glMatrix.mat4.translate(this.matrix, this.matrix, this.position);
+      _glMatrix.mat4.multiply(this.matrix, this.matrix, rotMatrix);
+    }
+  }
+
+  /**
+   * Sets the camera position in the camera matrix
+   */
+  _setPosition(x, y, z) {
+    this.position = (0, _math.createVec3)(x, y, z);
+    const m = this.matrix;
+    m[12] = this.position[0];
+    m[13] = this.position[1];
+    m[14] = this.position[2];
+    m[15] = 1;
+  }
+
+  /**
+   * Recalculates axes based on the current matrix
+   */
+  _getAxes() {
+    _glMatrix.vec3.copy(this.right, (0, _math.createVec3)(_glMatrix.vec4.transformMat4(_glMatrix.vec4.create(), [1, 0, 0, 0], this.matrix)));
+    _glMatrix.vec3.copy(this.up, (0, _math.createVec3)(_glMatrix.vec4.transformMat4(_glMatrix.vec4.create(), [0, 1, 0, 0], this.matrix)));
+    _glMatrix.vec3.copy(this.forward, (0, _math.createVec3)(_glMatrix.vec4.transformMat4(_glMatrix.vec4.create(), [0, 0, 1, 0], this.matrix)));
+    _glMatrix.vec3.normalize(this.right, this.right);
+    _glMatrix.vec3.normalize(this.up, this.up);
+    _glMatrix.vec3.normalize(this.forward, this.forward);
+  }
+
+  /**
+   * Recalculates euler angles based on the current state
+   */
+  _getAngles() {
+    // Recalculates angles
+    const x = this.distanceVector[0];
+    const y = this.distanceVector[1];
+    const z = this.distanceVector[2];
+    const r = _glMatrix.vec3.length(this.distanceVector);
+
+    // FAST FAIL: If there is no distance we cannot compute angles
+    if (r === 0) {
+      this.elevation = 0;
+      this.azimuth = 0;
+      return;
+    }
+    if (this.type === CAMERA_TYPE.TRACKING) {
+      this.elevation = Math.asin(y / r) * RAD_2_DEG;
+      this.azimuth = Math.atan2(-x, -z) * RAD_2_DEG;
+    } else {
+      if (this.rotateWorld) {
+        this.elevation = Math.asin(y / r) * RAD_2_DEG;
+        this.azimuth = Math.atan2(-x, -z) * RAD_2_DEG;
+      } else {
+        this.elevation = -Math.asin(y / r) * RAD_2_DEG;
+        this.azimuth = -Math.atan2(-x, -z) * RAD_2_DEG;
+      }
+    }
+  }
+
+  /**
+   * 重新计算相机位置，只有 ORBITING 模式相机位置才会发生变化
+   */
+  _getPosition() {
+    _glMatrix.vec3.copy(this.position, (0, _math.createVec3)(_glMatrix.vec4.transformMat4(_glMatrix.vec4.create(), [0, 0, 0, 1], this.matrix)));
+
+    // 相机位置变化，需要重新计算视距
+    this._getDistance();
+  }
+
+  /**
+   * 重新计算视点，只有 TRACKING 模式视点才会发生变化
+   */
+  _getFocalPoint() {
+    _glMatrix.vec3.transformMat3(this.distanceVector, [0, 0, -this.distance], _glMatrix.mat3.fromMat4(_glMatrix.mat3.create(), this.matrix));
+    _glMatrix.vec3.add(this.focalPoint, this.position, this.distanceVector);
+
+    // 视点变化，需要重新计算视距
+    this._getDistance();
+  }
+
+  /**
+   * 重新计算视距
+   */
+  _getDistance() {
+    this.distanceVector = _glMatrix.vec3.subtract(_glMatrix.vec3.create(), this.focalPoint, this.position);
+    this.distance = _glMatrix.vec3.length(this.distanceVector);
+    this.dollyingStep = this.distance / 100;
+  }
+}
+exports.default = Camera;