export function set3DTilesPosition(tileset, opts) {
    const tx = opts.tx;
    const ty = opts.ty;
    const tz = opts.tz;
    const rx = opts.rx;
    const ry = opts.ry;
    const rz = opts.rz;
    const scale = opts.scale;

    const lng = opts.lng;
    const lat = opts.lat;
    const height = opts.height || 0;

    return new Promise((resolve, reject) => {
        tileset.readyPromise.then((tileSet) => {
            let cartographic;

            if (lng && lat) {
                cartographic = new Cesium.Cartographic(
                    Cesium.Math.toRadians(lng),
                    Cesium.Math.toRadians(lat),
                    height);
            } else {
                cartographic = Cesium.Cartographic.fromCartesian(
                    tileSet.boundingSphere.center
                );
            }

            const surface = Cesium.Cartesian3.fromRadians(
                cartographic.longitude,
                cartographic.latitude,
                height
            );

            const m = Cesium.Transforms.eastNorthUpToFixedFrame(surface);

            //平移
            const _tx = tx ? tx : 0;
            const _ty = ty ? ty : 0;
            const _tz = tz ? tz : 0;
            const tempTranslation = new Cesium.Cartesian3(_tx, _ty, _tz);
            const offset = Cesium.Matrix4.multiplyByPoint(
                m,
                tempTranslation,
                new Cesium.Cartesian3(0, 0, 0)
            );
            const translation = Cesium.Cartesian3.subtract(
                offset,
                surface,
                new Cesium.Cartesian3()
            );
            tileSet.modelMatrix = Cesium.Matrix4.fromTranslation(translation);

            //旋转及缩放
            if (rx) {
                const mx = Cesium.Matrix3.fromRotationX(Cesium.Math.toRadians(rx));
                const rotate = Cesium.Matrix4.fromRotationTranslation(mx);
                Cesium.Matrix4.multiply(m, rotate, m);
            }

            if (ry) {
                const my = Cesium.Matrix3.fromRotationY(Cesium.Math.toRadians(ry));
                const rotate = Cesium.Matrix4.fromRotationTranslation(my);
                Cesium.Matrix4.multiply(m, rotate, m);
            }

            if (rz) {
                const mz = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(rz));
                const rotate = Cesium.Matrix4.fromRotationTranslation(mz);
                Cesium.Matrix4.multiply(m, rotate, m);
            }

            if (scale) {
                const _scale = Cesium.Matrix4.fromUniformScale(scale);
                Cesium.Matrix4.multiply(m, _scale, m);
            }

            tileSet._root.transform = m;

            resolve(tileSet);
        })
    })
}