@lijuhong1981/cesium.utils 0.0.0-stage → 0.1.1

package/src/revisions/index.js

@@ -0,0 +1,25 @@
+export * from "./BoundingSphere.revise.js";
+export * from "./Camera.revise.js";
+export * from "./Cartesian.revise.js";
+export * from "./Cartographic.revise.js";
+export * from "./Check.revise.js";
+export * from "./Color.revise.js";
+export * from "./DistanceDisplayCondition.revise.js";
+export * from "./Ellipsoid.revise.js";
+export * from "./Geometry.revise.js";
+export * from "./Globe.revise.js";
+export * from "./HeadingPitchRoll.revise.js";
+export * from "./JulianDate.revise.js";
+export * from "./Material.revise.js";
+export * from "./Math.revise.js";
+export * from "./Matrix.revise.js";
+export * from "./Plane.revise.js";
+export * from "./POI.revise.js";
+export * from "./PolylinePipeline.revise.js";
+export * from "./PostProcessStageLibrary.revise.js";
+export * from "./Primitive.revise.js";
+export * from "./Property.revise.js";
+export * from "./Quaternion.revise.js";
+export * from "./Rectangle.revise.js";
+export * from "./SceneTransforms.revise.js";
+export * from "./Spherical.revise.js";

package/src/utils/Scratch.js

@@ -0,0 +1,165 @@
+import { BoundingRectangle, BoundingSphere, Cartesian2, Cartesian3, Cartesian4, Cartographic, Color, DistanceDisplayCondition, HeadingPitchRange, HeadingPitchRoll, Interval, Matrix3, Matrix4, NearFarScalar, PerspectiveFrustum, Plane, Quaternion, Ray, Rectangle } from "cesium";
+import Geographic from "../additions/Geographic.js";
+
+// --Cartesian2--
+const scratchCanvasCoordinates = new Cartesian2(), // Cartesian2 画布坐标缓存
+    scratchCartesian2 = new Cartesian2(), // Cartesian2 二维笛卡尔坐标缓存
+    scratchPixelSize = new Cartesian2(), // Cartesian2 像素尺寸缓存
+    scratchRepeat = new Cartesian2(1, 1), // Cartesian2 纹理重复次数缓存（默认 1,1）
+    scratchScale2 = new Cartesian2(1, 1), // Cartesian2 二维缩放缓存（默认 1,1）
+    scratchWindowPosition = new Cartesian2(); // Cartesian2 窗口坐标缓存
+
+// --Cartesian3--
+const scratchCartesian3 = new Cartesian3(), // Cartesian3 三维笛卡尔坐标缓存
+    scratchDepthPosition = new Cartesian3(), // Cartesian3 深度位置缓存
+    scratchEllipsoidPosition = new Cartesian3(), // Cartesian3 椭球位置缓存
+    scratchEuler = new Cartesian3(), // Cartesian3 欧拉角缓存
+    scratchGlobePosition = new Cartesian3(), // Cartesian3 地球表面位置缓存
+    scratchPositionWC = new Cartesian3(), // Cartesian3 世界坐标位置缓存
+    scratchScale3 = new Cartesian3(1, 1, 1), // Cartesian3 三维缩放缓存（默认 1,1,1）
+    scratchTranslate = new Cartesian3(), // Cartesian3 平移量缓存
+    scratchTranslation = new Cartesian3(), // Cartesian3 平移量缓存
+    scratchCenter = new Cartesian3(), // Cartesian3 中心点缓存
+    scratchDirection = new Cartesian3(), // Cartesian3 方向向量缓存
+    scratchForward = new Cartesian3(), // Cartesian3 前方向向量缓存
+    scratchNormal = new Cartesian3(), // Cartesian3 法线向量缓存
+    scratchUp = new Cartesian3(), // Cartesian3 上方向向量缓存
+    scratchUpCartesian3 = new Cartesian3(), // Cartesian3 上方向向量缓存
+    scratchDownCartesian3 = new Cartesian3(), // Cartesian3 下方向向量缓存
+    scratchLeftCartesian3 = new Cartesian3(), // Cartesian3 左方向向量缓存
+    scratchLeftDirection = new Cartesian3(), // Cartesian3 左方向向量缓存
+    scratchLeftNormal = new Cartesian3(), // Cartesian3 左法线向量缓存
+    scratchRightCartesian3 = new Cartesian3(), // Cartesian3 右方向向量缓存
+    scratchRightDirection = new Cartesian3(), // Cartesian3 右方向向量缓存
+    scratchRightNormal = new Cartesian3(); // Cartesian3 右法线向量缓存
+
+// --Cartesian4--
+const scratchCartesian4 = new Cartesian4(), // Cartesian4 四维笛卡尔坐标缓存
+    scratchNDC = new Cartesian4(); // Cartesian4 归一化设备坐标缓存
+
+// --Cartographic--
+const scratchCartographic = new Cartographic(), // Cartographic 制图坐标（经度、纬度、高度）缓存
+    scratchLeftCartographic = new Cartographic(), // Cartographic 左侧制图坐标缓存
+    scratchRightCartographic = new Cartographic(), // Cartographic 右侧制图坐标缓存
+    scratchStartCartographic = new Cartographic(), // Cartographic 起点制图坐标缓存
+    scratchEndCartographic = new Cartographic(); // Cartographic 终点制图坐标缓存
+
+// --Matrix3--
+const scratchMatrix3 = new Matrix3(), // Matrix3 三维矩阵缓存
+    scratchRotationMatrix = new Matrix3(); // Matrix3 旋转矩阵缓存
+
+// --Matrix4--
+const scratchMatrix4 = new Matrix4(), // Matrix4 四维矩阵缓存
+    scratchTransform = new Matrix4(), // Matrix4 变换矩阵缓存
+    scratchViewMatrix = new Matrix4(); // Matrix4 视图矩阵缓存
+
+// --Others--
+const scratchBoundingRectangle = new BoundingRectangle(), // BoundingRectangle 包围矩形缓存
+    scratchBoundingSphere = new BoundingSphere(), // BoundingSphere 包围球缓存
+    scratchColor = new Color(), // Color 颜色缓存
+    scratchDistanceDisplayCondition = new DistanceDisplayCondition(), // DistanceDisplayCondition 距离显示条件缓存
+    scratchGeographic = new Geographic(), // Geographic 地理坐标缓存
+    scratchHeadingPitchRange = new HeadingPitchRange(), // HeadingPitchRange 航向俯仰距离缓存
+    scratchHeadingPitchRoll = new HeadingPitchRoll(), // HeadingPitchRoll 航向俯仰翻滚缓存
+    scratchInterval = new Interval(), // Interval 区间缓存
+    scratchTiltRestriction = new Interval(), // Interval 倾斜限制区间缓存
+    scratchNearFarScalar = new NearFarScalar(), // NearFarScalar 近远标量缓存
+    scratchPerspective = new PerspectiveFrustum(), // PerspectiveFrustum 透视视锥体缓存
+    scratchPlane = new Plane(Cartesian3.UNIT_Z, 0), // Plane 平面缓存（法线为 UNIT_Z）
+    scratchOrientation = new Quaternion(), // Quaternion 姿态四元数缓存
+    scratchQuaternion = new Quaternion(), // Quaternion 四元数缓存
+    scratchRay = new Ray(), // Ray 射线缓存
+    scratchRectangle = new Rectangle(); // Rectangle 矩形缓存
+
+let _scratchCamera;
+
+/**
+ * Cesium 常用临时对象的统一 scratch 缓存集合。
+ * 集中存放各类可复用的临时对象（Cartesian2/3/4、Cartographic、Matrix3/4、Color 等），
+ * 供内部计算复用以减少运行时对象创建与垃圾回收开销。
+ * 使用约定：仅在同步计算过程中临时占用，不要长期持有其引用。
+ */
+const Scratch = {
+    // --Cartesian2--
+    scratchCartesian2,
+    scratchPixelSize,
+    scratchScale2,
+    scratchCanvasCoordinates,
+    scratchWindowPosition,
+    scratchRepeat,
+    // --Cartesian3--
+    scratchCartesian3,
+    scratchCenter,
+    scratchLeftCartesian3,
+    scratchRightCartesian3,
+    scratchUpCartesian3,
+    scratchDownCartesian3,
+    scratchPositionWC,
+    scratchTranslation,
+    scratchTranslate,
+    scratchEuler,
+    scratchDirection,
+    scratchLeftDirection,
+    scratchRightDirection,
+    scratchUp,
+    scratchNormal,
+    scratchLeftNormal,
+    scratchRightNormal,
+    scratchForward,
+    scratchScale3,
+    scratchEllipsoidPosition,
+    scratchGlobePosition,
+    scratchDepthPosition,
+    // --Cartesian4--
+    scratchCartesian4,
+    scratchNDC,
+    // --Cartographic--
+    scratchCartographic,
+    scratchLeftCartographic,
+    scratchRightCartographic,
+    scratchStartCartographic,
+    scratchEndCartographic,
+    // --Matrix3--
+    scratchMatrix3,
+    scratchRotationMatrix,
+    // --Matrix4--
+    scratchMatrix4,
+    scratchTransform,
+    scratchViewMatrix,
+    // --Others--
+    scratchBoundingRectangle,
+    scratchBoundingSphere,
+    scratchColor,
+    scratchDistanceDisplayCondition,
+    scratchGeographic,
+    scratchHeadingPitchRange,
+    scratchHeadingPitchRoll,
+    scratchNearFarScalar,
+    scratchQuaternion,
+    scratchRay,
+    scratchInterval,
+    scratchTiltRestriction,
+    scratchPlane,
+    scratchRectangle,
+    scratchOrientation,
+    scratchPerspective,
+};
+
+Object.defineProperties(Scratch, {
+    // Camera 相机实例的临时缓存（通过 get/set 访问）
+    scratchCamera: {
+        set: function (value) {
+            _scratchCamera = value;
+        },
+        get: function () {
+            return _scratchCamera;
+        }
+    }
+});
+
+export default Scratch;
+export {
+    Scratch,
+    // ----
+    scratchBoundingRectangle, scratchBoundingSphere, scratchCanvasCoordinates, scratchCartesian2, scratchCartesian3, scratchCartesian4, scratchCartographic, scratchCenter, scratchColor, scratchDepthPosition, scratchDirection, scratchDistanceDisplayCondition, scratchDownCartesian3, scratchEllipsoidPosition, scratchEndCartographic, scratchEuler, scratchForward, scratchGeographic, scratchGlobePosition, scratchHeadingPitchRange, scratchHeadingPitchRoll, scratchInterval, scratchTiltRestriction, scratchLeftCartesian3, scratchLeftCartographic, scratchLeftDirection, scratchLeftNormal, scratchMatrix3, scratchMatrix4, scratchNDC, scratchNearFarScalar, scratchNormal, scratchOrientation, scratchPerspective, scratchPixelSize, scratchPlane, scratchPositionWC, scratchQuaternion, scratchRay, scratchRectangle, scratchRepeat, scratchRightCartesian3, scratchRightCartographic, scratchRightDirection, scratchRightNormal, scratchRotationMatrix, scratchScale2, scratchScale3, scratchStartCartographic, scratchTransform, scratchTranslate, scratchTranslation, scratchUp, scratchUpCartesian3, scratchViewMatrix, scratchWindowPosition
+};

package/src/utils/computeCirclePositions.js

@@ -0,0 +1,48 @@
+import { Cartesian3, Math as CesiumMath, Check, defined, EllipseGeometryLibrary } from "cesium";
+
+/**
+ * 在椭球面上按给定中心、半径与分段数计算圆（环）上的点集。
+ * @param {object} options 参数对象
+ * @param {Cartesian3} options.center 圆心（世界坐标，决定圆所在的椭球面位置）
+ * @param {number} options.radius 圆半径，单位米，需大于 0
+ * @param {number} [options.rotation=0] 圆的旋转角，单位弧度
+ * @param {number} [options.rotationDegrees] 圆的旋转角，单位度；提供时覆盖 rotation
+ * @param {number} [options.numberOfSegments=64] 圆周分段数，需为不小于 3 的整数
+ * @returns {Cartesian3[]} 圆周上的点集
+ */
+function computeCirclePositions(options) {
+    const center = options.center;
+    Check.typeOf.object('center', center);
+    const radius = options.radius;
+    Check.typeOf.number.greaterThan('radius', radius, 0);
+    let rotation = options.rotation ?? 0;
+    if (defined(options.rotationDegrees))
+        rotation = CesiumMath.toRadians(options.rotationDegrees);
+    const numberOfSegments = options.numberOfSegments ?? 64;
+    Check.typeOf.integer.greaterThanOrEquals('numberOfSegments', numberOfSegments, 3);
+
+    const rSqr = radius * radius;
+
+    const mag = Cartesian3.magnitude(center);
+
+    const unitPos = Cartesian3.normalize(center, new Cartesian3());
+    const eastVec = Cartesian3.cross(Cartesian3.UNIT_Z, center, new Cartesian3());
+    Cartesian3.normalize(eastVec, eastVec);
+    const northVec = Cartesian3.cross(unitPos, eastVec, new Cartesian3());
+
+    const deltaTheta = CesiumMath.TWO_PI / numberOfSegments;
+
+    let theta = 0;
+    const result = [];
+    for (let i = 0; i < numberOfSegments; i++) {
+        const position = EllipseGeometryLibrary.pointOnEllipsoid(theta, rotation, northVec, eastVec, rSqr, rSqr, rSqr, mag, unitPos, new Cartesian3());
+        result.push(position);
+
+        theta += deltaTheta;
+    }
+
+    return result;
+};
+
+export default computeCirclePositions;
+export { computeCirclePositions };

package/src/utils/computeCircleRadius.js

@@ -0,0 +1,19 @@
+import { Cartesian3 } from "cesium";
+
+/**
+ * 计算一组圆周点到首点（圆心）的最大距离，即圆的半径。
+ * @param {Cartesian3[]} positions 圆周上的点集，首个元素视为圆心
+ * @returns {number} 圆的半径，单位米
+ */
+function computeCircleRadius(positions) {
+    let result = 0;
+    for (let i = 1; i < positions.length; i++) {
+        let radius = Cartesian3.distance(positions[0], positions[i]);
+        if (radius > result)
+            result = radius;
+    }
+    return result;
+};
+
+export default computeCircleRadius;
+export { computeCircleRadius };

package/src/utils/computeModelMatrix.js

@@ -0,0 +1,109 @@
+import { Cartesian3, Check, Matrix4, Quaternion, Transforms } from "cesium";
+import parseAttitudeToQuaternion from "../parses/parseAttitudeToQuaternion.js";
+import parseEulerToQuaternion from "../parses/parseEulerToQuaternion.js";
+import parseGeographicToCartesian from "../parses/parseGeographicToCartesian.js";
+import parseRotationToQuaternion from "../parses/parseRotationToQuaternion.js";
+import parseToCartesian3 from "../parses/parseToCartesian3.js";
+import Scratch from "../utils/Scratch.js";
+
+/**
+ * 根据多种来源选项计算模型矩阵（世界坐标到局部坐标的变换矩阵）。
+ * 支持通过原点/经纬度/原点矩阵、变换前后矩阵以及平移、旋转/姿态/欧拉角、缩放等组合生成。
+ * @param {object} options 参数对象
+ * @param {Matrix4|Cartesian3|object} [options.origin] 原点，可为 Matrix4 或可解析为 Cartesian3 的位置
+ * @param {Ellipsoid} [options.ellipsoid] 参考椭球体
+ * @param {Matrix4} [options.originMatrix] 原点矩阵，也支持 fixedFrame/fixedFrameMatrix/localFrame/localFrameMatrix 别名
+ * @param {object} [options.geographic] 地理坐标原点
+ * @param {Cartesian3|object} [options.position] 位置原点，也支持 originPosition/center 别名
+ * @param {Matrix4} [options.beforeTransform] 前置变换矩阵，也支持 beforeTransformtion/beforeTransformMatrix 别名
+ * @param {Matrix4} [options.transform] 变换矩阵，也支持 transformation/transformMatrix/localTransform/localTransformMatrix 别名
+ * @param {Cartesian3} [options.translation] 平移量
+ * @param {Quaternion|object} [options.rotation] 旋转四元数
+ * @param {object} [options.attitude] 姿态
+ * @param {object} [options.euler] 欧拉角，也支持 eulerRotation 别名
+ * @param {Cartesian3} [options.scale] 缩放
+ * @param {Matrix4} [options.afterTransform] 后置变换矩阵，也支持 afterTransformtion/afterTransformMatrix 别名
+ * @param {Matrix4} [result] 用于存储结果的矩阵，未提供则新建
+ * @returns {Matrix4} 计算得到的模型矩阵
+ */
+function computeModelMatrix(options, result) {
+    Check.typeOf.object('options', options);
+
+    if (result === undefined)
+        result = Matrix4.IDENTITY.clone(new Matrix4());
+    else
+        result = Matrix4.IDENTITY.clone(result);
+
+    if (options.origin) {
+        if (options.origin instanceof Matrix4)
+            Matrix4.clone(options.origin, result);
+        else {
+            const origin = parseToCartesian3(options.origin, Scratch.scratchCartesian3, 0.0);
+            if (!Cartesian3.equals(Cartesian3.ZERO, origin))
+                Transforms.eastNorthUpToFixedFrame(origin, options.ellipsoid, result);
+        }
+    } else if (options.originMatrix || options.fixedFrame || options.fixedFrameMatrix || options.localFrame || options.localFrameMatrix) {
+        const originMatrix = options.originMatrix || options.fixedFrame || options.fixedFrameMatrix || options.localFrame || options.localFrameMatrix;
+        Check.instanceOf('originMatrix', originMatrix, Matrix4);
+        Matrix4.clone(originMatrix, result);
+    } else {
+        let origin;
+        if (options.geographic)
+            origin = parseGeographicToCartesian(options.geographic, Scratch.scratchCartesian3, options.ellipsoid);
+        else if (options.position || options.originPosition || options.center) {
+            origin = options.position || options.originPosition || options.center;
+            origin = parseToCartesian3(origin, Scratch.scratchCartesian3, 0.0);
+        }
+        if (origin && !Cartesian3.equals(Cartesian3.ZERO, origin))
+            Transforms.eastNorthUpToFixedFrame(origin, options.ellipsoid, result);
+    }
+
+    if (options.beforeTransform || options.beforeTransformtion || options.beforeTransformMatrix) {
+        const beforeTransform = options.beforeTransform || options.beforeTransformtion || options.beforeTransformMatrix;
+        Check.instanceOf('beforeTransform', beforeTransform, Matrix4);
+        if (!Matrix4.equals(beforeTransform, Matrix4.IDENTITY))
+            Matrix4.multiplyTransformation(result, beforeTransform, result);
+    }
+
+    if (options.transform || options.transformation || options.transformMatrix || options.localTransform || options.localTransformMatrix) {
+        const transform = options.transform || options.transformation || options.transformMatrix || options.localTransform || options.localTransformMatrix;
+        Check.instanceOf('transform', transform, Matrix4);
+        if (!Matrix4.equals(transform, Matrix4.IDENTITY))
+            Matrix4.multiplyTransformation(result, transform, result);
+    } else {
+        const transform = Matrix4.IDENTITY.clone(Scratch.scratchTransform);
+
+        const translation = Cartesian3.ZERO.clone(Scratch.scratchTranslation);
+        if (options.translation)
+            parseToCartesian3(options.translation, translation, 0.0);
+
+        const quaternion = Quaternion.IDENTITY.clone(Scratch.scratchQuaternion);
+        if (options.rotation)
+            parseRotationToQuaternion(options.rotation, quaternion);
+        else if (options.attitude)
+            parseAttitudeToQuaternion(options.attitude, quaternion);
+        else if (options.euler || options.eulerRotation)
+            parseEulerToQuaternion(options.euler || options.eulerRotation, quaternion);
+
+        const scale = Cartesian3.ONE.clone(Scratch.scratchScale3);
+        if (options.scale)
+            parseToCartesian3(options.scale, scale, 1.0);
+
+        Matrix4.fromTranslationQuaternionRotationScale(translation, quaternion, scale, transform);
+
+        if (!Matrix4.equals(transform, Matrix4.IDENTITY))
+            Matrix4.multiplyTransformation(result, transform, result);
+    }
+
+    if (options.afterTransform || options.afterTransformtion || options.afterTransformMatrix) {
+        const afterTransform = options.afterTransform || options.afterTransformtion || options.afterTransformMatrix;
+        Check.instanceOf('afterTransform', afterTransform, Matrix4);
+        if (!Matrix4.equals(afterTransform, Matrix4.IDENTITY))
+            Matrix4.multiplyTransformation(result, afterTransform, result);
+    }
+
+    return result;
+};
+
+export default computeModelMatrix;
+export { computeModelMatrix };

package/src/utils/computeStTransform.js

@@ -0,0 +1,57 @@
+import { Matrix3 } from "cesium";
+
+/**
+ * 由偏移、重复、旋转与中心参数构建纹理坐标（st）变换矩阵。
+ * @param {object} [stOffset={x:0,y:0}] 纹理坐标偏移
+ * @param {object} [stRepeat={x:1,y:1}] 纹理坐标重复（缩放）
+ * @param {number} [stRotation=0] 纹理坐标旋转角，单位弧度
+ * @param {object} [stCenter={x:0.5,y:0.5}] 纹理坐标旋转中心
+ * @param {Matrix3} [result] 用于存储结果的矩阵，未提供则新建
+ * @returns {Matrix3} 纹理坐标变换矩阵
+ */
+function computeStTransform(stOffset = {
+    x: 0,
+    y: 0
+}, stRepeat = {
+    x: 1,
+    y: 1
+}, stRotation = 0, stCenter = {
+    x: 0.5,
+    y: 0.5,
+}, result = new Matrix3()) {
+    const tx = stOffset.x,
+        ty = stOffset.y,
+        sx = stRepeat.x,
+        sy = stRepeat.y,
+        cx = stCenter.x,
+        cy = stCenter.y,
+        c = Math.cos(stRotation),
+        s = Math.sin(stRotation);
+    //sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
+    //- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
+    //0, 0, 1
+    const n11 = sx * c,
+        n12 = sx * s,
+        n13 = -sx * (c * cx + s * cy) + cx - tx,
+        n21 = -sy * s,
+        n22 = sy * c,
+        n23 = -sy * (-s * cx + c * cy) + cy - ty,
+        n31 = 0,
+        n32 = 0,
+        n33 = 1;
+
+    result[0] = n11;
+    result[1] = n21;
+    result[2] = n31;
+    result[3] = n12;
+    result[4] = n22;
+    result[5] = n32;
+    result[6] = n13;
+    result[7] = n23;
+    result[8] = n33;
+
+    return result;
+};
+
+export default computeStTransform;
+export { computeStTransform };

package/src/utils/createGeometry.js

@@ -0,0 +1,114 @@
+import { BoundingSphere, Check, ComponentDatatype, DeveloperError, Geometry, GeometryAttribute, PrimitiveType } from 'cesium';
+
+/**
+ * 根据 TypedArray 的类型推断对应的 Cesium 组件数据类型（ComponentDatatype）。
+ * @param {ArrayBufferView} array 顶点属性数组
+ * @returns {ComponentDatatype} 对应的组件数据类型，无法识别时返回 SHORT
+ */
+function getAttributeComponentType(array) {
+    var attributeComponentType = ComponentDatatype.SHORT;
+    if (array instanceof Int8Array) {
+        attributeComponentType = ComponentDatatype.BYTE;
+    } else if (array instanceof Uint8Array || array instanceof Uint8ClampedArray) {
+        attributeComponentType = ComponentDatatype.UNSIGNED_BYTE;
+    } else if (array instanceof Int16Array) {
+        attributeComponentType = ComponentDatatype.SHORT;
+    } else if (array instanceof Uint16Array) {
+        attributeComponentType = ComponentDatatype.UNSIGNED_SHORT;
+    } else if (array instanceof Int32Array) {
+        attributeComponentType = ComponentDatatype.INT;
+    } else if (array instanceof Uint32Array) {
+        attributeComponentType = ComponentDatatype.UNSIGNED_INT;
+    } else if (array instanceof Float32Array) {
+        attributeComponentType = ComponentDatatype.FLOAT;
+    } else if (array instanceof Float64Array) {
+        attributeComponentType = ComponentDatatype.DOUBLE;
+    }
+    return attributeComponentType;
+}
+
+/**
+ * 将 three.js 的 BufferGeometry 转换为 Cesium 的 Geometry。
+ * @param {object} geometry three.js BufferGeometry 对象
+ * @returns {Geometry} 转换后的 Cesium 几何对象
+ */
+function threeGeometryToCesiumGeometry(geometry) {
+    Check.defined('geometry', geometry);
+
+    let attributes = {};
+    if (!geometry.attributes.normal && typeof geometry.computeVertexNormals === 'function') {
+        geometry.computeVertexNormals();
+    }
+
+    let positions;
+    for (let attrName in geometry.attributes) {
+        if (geometry.attributes.hasOwnProperty(attrName)) {
+            let attr = geometry.getAttribute(attrName);
+            if (attr && attr.array.length > 0) {
+                if (attrName === 'position') {
+                    positions = new Float64Array(attr.array);
+                    attributes[attrName] = new GeometryAttribute({
+                        componentDatatype: ComponentDatatype.DOUBLE,
+                        componentsPerAttribute: attr.itemSize,
+                        values: positions,
+                        normalize: attr.normalized
+                    });
+                } else {
+                    if (attrName === 'uv')
+                        attrName = 'st';
+                    attributes[attrName] = new GeometryAttribute({
+                        componentDatatype: getAttributeComponentType(attr.array),
+                        componentsPerAttribute: attr.itemSize,
+                        values: attr.array,
+                        normalize: attr.normalized
+                    });
+                }
+            }
+        }
+    }
+
+    let indices = [];
+    if (geometry.index)
+        indices = geometry.index.array;
+    else if (geometry.groups && geometry.groups.length > 0) {
+        geometry.groups.forEach(function (group) {
+            for (let i = 0; i < group.count; i++) {
+                indices.push(i + group.start);
+            }
+        })
+        indices = new Int32Array(indices);
+    } else {
+        const length = geometry.attributes.position.count;
+        for (let i = 0; i < length; i++) {
+            indices.push(i);
+        }
+        indices = new Int32Array(indices);
+    }
+
+    return new Geometry({
+        attributes: attributes,
+        indices: indices,
+        primitiveType: PrimitiveType.TRIANGLES,
+        boundingSphere: BoundingSphere.fromVertices(positions)
+    });
+};
+
+/**
+ * 将多种几何类型统一转换为 Cesium 的 Geometry 对象。
+ * 支持已为 Geometry 的对象、three.js BufferGeometry，以及构造函数带 createGeometry 静态方法的几何对象。
+ * @param {Geometry|object} geometry 待转换的几何对象
+ * @returns {Geometry} Cesium 几何对象
+ */
+function createGeometry(geometry) {
+    Check.defined('geometry', geometry);
+    if (geometry instanceof Geometry)
+        return geometry;
+    if (geometry.isBufferGeometry)
+        return threeGeometryToCesiumGeometry(geometry);
+    if (typeof geometry.constructor.createGeometry === 'function')
+        return geometry.constructor.createGeometry(geometry);
+    throw new DeveloperError('Unable to identify geometry.');
+};
+
+export default createGeometry;
+export { createGeometry };

package/src/utils/createPointCloudGeometry.js

@@ -0,0 +1,79 @@
+import isTypedArray from "@lijuhong1981/jscheck/src/isTypedArray.js";
+import { BoundingSphere, Cartesian3, Check, Color, ComponentDatatype, DeveloperError, GeometryAttribute, GeometryAttributes, PrimitiveType } from "cesium";
+
+/**
+ * 根据位置与可选颜色数据创建 Cesium 点云几何体（PrimitiveType.POINTS）。
+ * @param {object} [options={}] 参数对象
+ * @param {ArrayBuffer|Array|ArrayBufferView} options.positions 位置数据，可为 Cartesian3 数组、扁平数值数组或 TypedArray
+ * @param {ArrayBuffer|Array|ArrayBufferView} [options.colors] 颜色数据，缺省时全部使用深灰色
+ * @returns {Geometry} 点云几何体
+ */
+function createPointCloudGeometry(options = {}) {
+    Check.defined('positions', options.positions);
+    const positions = options.positions;
+    let positionsArray;
+    if (positions instanceof ArrayBuffer) {
+        positionsArray = new Float64Array(positions);
+    } else if (Array.isArray(positions))
+        if (typeof positions[0] === 'number')
+            positionsArray = positions;
+        else
+            positionsArray = Cartesian3.packArray(positions);
+    else if (isTypedArray(positions))
+        positionsArray = positions;
+    else {
+        throw new DeveloperError('positions must be Cartesian`s Array or TypedArray object.');
+    }
+    const positionsLength = positionsArray.length / 3;
+
+    let colors, colorsArray;
+    if (options.colors) {
+        colors = options.colors;
+    } else {
+        colors = new Array();
+        for (let i = 0; i < positionsLength; i++) {
+            colors[i] = Color.DARKGRAY.clone();
+        }
+    }
+    if (colors instanceof ArrayBuffer) {
+        colorsArray = new Uint8Array(colors);
+    } else if (Array.isArray(colors)) {
+        if (typeof colors[0] === 'number')
+            colorsArray = colors;
+        else
+            colorsArray = Color.packArrayToBytes(colors);
+    } else if (isTypedArray(colors))
+        colorsArray = colors;
+    else {
+        throw new DeveloperError('colors must be Color`s Array or TypedArray object.');
+    }
+    const colorsLength = colorsArray.length / 4;
+
+    if (positionsLength !== colorsLength) {
+        throw new DeveloperError('the positionsLength must be equal to colorsLength.');
+    }
+
+    const attributes = new GeometryAttributes();
+
+    attributes.position = new GeometryAttribute({
+        componentDatatype: ComponentDatatype.DOUBLE,
+        componentsPerAttribute: 3,
+        values: new Float64Array(positionsArray),
+    });
+
+    attributes.color = new GeometryAttribute({
+        componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
+        componentsPerAttribute: 4,
+        values: new Uint8Array(colorsArray),
+        normalize: true,
+    });
+
+    return new Geometry({
+        attributes: attributes,
+        primitiveType: PrimitiveType.POINTS,
+        boundingSphere: BoundingSphere.fromVertices(positionsArray),
+    });
+};
+
+export default createPointCloudGeometry;
+export { createPointCloudGeometry };

package/src/utils/getGeometryInstanceAttributes.js

@@ -0,0 +1,43 @@
+import { BooleanGeometryInstanceAttribute, Cartesian3GeometryInstanceAttribute, FloatGeometryInstanceAttribute } from "../additions/GeometryInstanceAttributes.js";
+import { Cartesian3, ColorGeometryInstanceAttribute, defined, DistanceDisplayConditionGeometryInstanceAttribute, ShowGeometryInstanceAttribute } from "cesium";
+
+/**
+ * 根据各项参数构建几何实例属性集合（GeometryInstanceAttributes）。
+ * @param {boolean} show 是否显示
+ * @param {Color} color 材质颜色
+ * @param {DistanceDisplayCondition} distanceDisplayCondition 距离显示条件
+ * @param {Matrix3} stTransform 纹理坐标变换矩阵，按列拆分为三个 Cartesian3 分别存储
+ * @param {number} pointSize 点大小
+ * @param {boolean} perVertexColors 是否使用逐顶点颜色
+ * @param {Color} instanceColor 实例颜色
+ * @returns {object} 几何实例属性集合
+ */
+function getGeometryInstanceAttributes(show, color, distanceDisplayCondition, stTransform, pointSize, perVertexColors, instanceColor) {
+    const attributes = {};
+    if (defined(show))
+        attributes.show = new ShowGeometryInstanceAttribute(show);
+    if (defined(color))
+        attributes.color = ColorGeometryInstanceAttribute.fromColor(color);
+    if (defined(distanceDisplayCondition))
+        attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(distanceDisplayCondition);
+    if (defined(stTransform)) {
+        //stTransform是一个Matrix3对象，但是GeometryInstanceAttribute最多只支持到Cartesian4对象，所以这里将Matrix3按列拆分成3个Cartesian3对象分别传入，然后在shader中再合成为mat3数据
+        const scratchCartesian3 = new Cartesian3();
+        const column0 = stTransform.getColumn(0, scratchCartesian3);
+        attributes.stTransformColumn0 = Cartesian3GeometryInstanceAttribute.fromCartesian3(column0);
+        const column1 = stTransform.getColumn(1, scratchCartesian3);
+        attributes.stTransformColumn1 = Cartesian3GeometryInstanceAttribute.fromCartesian3(column1);
+        const column2 = stTransform.getColumn(2, scratchCartesian3);
+        attributes.stTransformColumn2 = Cartesian3GeometryInstanceAttribute.fromCartesian3(column2);
+    }
+    if (defined(pointSize))
+        attributes.pointSize = FloatGeometryInstanceAttribute.fromFloat(pointSize);
+    if (defined(perVertexColors))
+        attributes.perVertexColors = BooleanGeometryInstanceAttribute.fromBoolean(perVertexColors);
+    if (defined(instanceColor))
+        attributes.instanceColor = ColorGeometryInstanceAttribute.fromColor(instanceColor);
+    return attributes;
+};
+
+export default getGeometryInstanceAttributes;
+export { getGeometryInstanceAttributes };