// 无需动画渐变的姿态改变
jumpTo(options: CameraOptions, eventData?: Object) {
    // 处理四种相机属性，更新transform对象
    const tr = this.transform;
    // 修改标记
    let zoomChanged = false,
        ...
    // 直接修改transform属性，其它三种属性同理
    if ('zoom' in options && tr.zoom !== +options.zoom) {
        zoomChanged = true;
        tr.zoom = +options.zoom;
    }
    this.fire(new Event('movestart', eventData))
        .fire(new Event('move', eventData));
    // 触发属性改变时机事件，由于无渐变因此同时触发。其它三种属性同理
    if (zoomChanged) {
        this.fire(new Event('zoomstart', eventData))
            .fire(new Event('zoom', eventData))
            .fire(new Event('zoomend', eventData));
    }
}

// 带有动画渐变的姿态改变
easeTo() {
    const tr = this.transform,
    // 获取当前各属性的初始值
    startZoom = this.getZoom(),
    zoom = 'zoom' in options ? +options.zoom : startZoom,
    // 触发属性开始变化事件
    this._prepareEase(eventData, options.noMoveStart, currently);
    // 执行封装的类rAF方法，在回调方法中进行姿态属性的插值，其中k为利用now计算的时间差除以设置中经过的时间duration得到的步进值t
    this._ease((k) => {
        // 对各属性进行插值，步进值k根据经过的时段比例计算
        if (this._zooming) {
            tr.zoom = interpolate(startZoom, zoom, k);
        }
        ...
    }, (interruptingEaseId?: string) => {
        // 触发属性结束变化事件
        this._afterEase(eventData, interruptingEaseId);
    }, options）
    // 封装对于渐变属性的事件触发
    this._prepareEase(eventData, options.noMoveStart, currently);
}

// 带有巡航效果的姿态改变
flyTo() {
    /**
     * 该方法的核心是flight path的计算，代码中参考了一片论文中的方法来计算最优路径
     * Van Wijk, Jarke J.; Nuij, Wim A. A. “Smooth and efficient zooming and panning.” INFOVIS
     *   ’03. pp. 15–22. <https://www.win.tue.nl/~vanwijk/zoompan.pdf#page=5>.
     * 简单的说就是该方法实现了在视图切换时的一种平滑路径，在uw空间中计算
    */
    // 整条巡航路线的长度
    let S = (r(1) - r0) / rho;
    // 返回地平面的可见范围
    let w: (_: number) => number = function (s) {
        return (cosh(r0) / cosh(r0 + rho * s));
    };
    // 返回巡航路线与地平面的距离
    let u: (_: number) => number = function (s) {
        return w0 * ((cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2) / u1;
    };
    // S、w与u参与属性插值
    this._ease((k) => {
        const s = k * S;
        const scale = 1 / w(s);
        tr.zoom = k === 1 ? zoom : startZoom + tr.scaleZoom(scale);
        if (this._rotating) {
            tr.bearing = interpolate(startBearing, bearing, k);
        }
        ...
        const newCenter = k === 1 ? center : tr.unproject(from.add(delta.mult(u(s))).mult(scale));
        tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
    }, () => this._afterEase(eventData), options);
}

set pitch(pitch: number) {
    const p = clamp(pitch, this.minPitch, this.maxPitch) / 180 * Math.PI;
    if (this._pitch === p) return;
    this._unmodified = false;
    this._pitch = p;
    this._calcMatrices();
}
set center(center: LngLat) {
    if (center.lat === this._center.lat && center.lng === this._center.lng) return;
    this._unmodified = false;
    this._center = center;
    this._constrain();
    this._calcMatrices();
}

_calcMatrices() {
    /*
     * 计算投影矩阵
     */
    // 计算相机的近裁面与远裁面距离
    const furthestDistance = Math.cos(Math.PI / 2 - this._pitch) * topHalfSurfaceDistance + this.cameraToCenterDistance;
    const farZ = furthestDistance * 1.01;
    const nearZ = this.height / 50;
    // 本地坐标系到GL坐标系的变换矩阵
    let m = new Float64Array(16);
    mat4.perspective(m, this._fov, this.width / this.height, nearZ, farZ);
    m[8] = -offset.x * 2 / this.width;
    m[9] = offset.y * 2 / this.height;
    mat4.scale(m, m, [1, -1, 1]);
    mat4.translate(m, m, [0, 0, -this.cameraToCenterDistance]);
    mat4.rotateX(m, m, this._pitch);
    mat4.rotateZ(m, m, this.angle);
    mat4.translate(m, m, [-x, -y, 0]);
    /*
     * 计算3D墨卡托变换矩阵，用于将点从墨卡托坐标系([0, 0] nw, [1, 1] se)转换到GL坐标系
     */
    this.mercatorMatrix = mat4.scale([], m, [this.worldSize, this.worldSize, this.worldSize]);
    // 处理z轴变量并保存投影矩阵及其逆阵
    mat4.scale(m, m, [1, 1, mercatorZfromAltitude(1, this.center.lat) * this.worldSize, 1]);
    this.projMatrix = m;
    this.invProjMatrix = mat4.invert([], this.projMatrix);
    // 计算轴向投影矩阵，为渲染光栅瓦片所准备
    const xShift = (this.width % 2) / 2, yShift = (this.height % 2) / 2,
        angleCos = Math.cos(this.angle), angleSin = Math.sin(this.angle),
        dx = x - Math.round(x) + angleCos * xShift + angleSin * yShift,
        dy = y - Math.round(y) + angleCos * yShift + angleSin * xShift;
    const alignedM = new Float64Array(m);
    mat4.translate(alignedM, alignedM, [ dx > 0.5 ? dx - 1 : dx, dy > 0.5 ? dy - 1 : dy, 0 ]);
    this.alignedProjMatrix = alignedM;
    // 标签平面在GL中的初始mv矩阵，无姿态变换，亦作为symbol的默认mv矩阵
    m = mat4.create();
    mat4.scale(m, m, [this.width / 2, -this.height / 2, 1]);
    mat4.translate(m, m, [1, -1, 0]);
    this.labelPlaneMatrix = m;
    // 本地坐标系到屏幕坐标系的变换矩阵及其逆阵，即mvp矩阵，用于墨卡托与屏幕坐标互转等方法
    this.pixelMatrix = mat4.multiply(new Float64Array(16), this.labelPlaneMatrix, this.projMatrix);
    m = mat4.invert(new Float64Array(16), this.pixelMatrix);
    if (!m) throw new Error("failed to invert matrix");
    this.pixelMatrixInverse = m;
}