@lijuhong1981/cesium.utils 0.0.0-stage → 0.1.1

package/src/revisions/HeadingPitchRoll.revise.js

@@ -0,0 +1,328 @@
+import { Cartesian3, Math as CesiumMath, Check, HeadingPitchRoll, Quaternion } from "cesium";
+import Scratch from "../utils/Scratch.js";
+
+/**
+ * 扩展 Cesium 的 HeadingPitchRoll 类，补充偏航角别名、角度转换，
+ * 与四元数/欧拉角互转、取反以及打包解包等方法。
+ * @class HeadingPitchRoll
+ * @see {@link https://cesium.com/learn/cesiumjs/ref-doc/HeadingPitchRoll.html}
+*/
+
+Object.defineProperties(HeadingPitchRoll.prototype, {
+    /**
+     * heading 的别名，获取/设置偏航角（弧度制）。
+     * @type {number}
+     * @memberof HeadingPitchRoll
+    */
+    yaw: {
+        set: function (value) {
+            this.heading = value;
+        },
+        get: function () {
+            return this.heading;
+        }
+    },
+    /**
+     * 获取航向角（角度制，单位度）。
+     * @type {number}
+     * @memberof HeadingPitchRoll
+    */
+    headingDegrees: {
+        get: function () {
+            return CesiumMath.toDegrees(this.heading);
+        }
+    },
+    /**
+     * 获取偏航角（角度制，单位度），等同于 headingDegrees。
+     * @type {number}
+     * @memberof HeadingPitchRoll
+    */
+    yawDegrees: {
+        get: function () {
+            return this.headingDegrees;
+        }
+    },
+    /**
+     * 获取俯仰角（角度制，单位度）。
+     * @type {number}
+     * @memberof HeadingPitchRoll
+    */
+    pitchDegrees: {
+        get: function () {
+            return CesiumMath.toDegrees(this.pitch);
+        }
+    },
+    /**
+     * 获取横滚角（角度制，单位度）。
+     * @type {number}
+     * @memberof HeadingPitchRoll
+    */
+    rollDegrees: {
+        get: function () {
+            return CesiumMath.toDegrees(this.roll);
+        }
+    },
+});
+
+/**
+ * 由航向、俯仰、横滚角（弧度制）创建 HeadingPitchRoll。
+ * @param {number} heading 航向角（弧度）。
+ * @param {number} pitch 俯仰角（弧度）。
+ * @param {number} roll 横滚角（弧度）。
+ * @param {HeadingPitchRoll} [result=new HeadingPitchRoll()] 存放结果的对象。
+ * @returns {HeadingPitchRoll} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.fromRadians = function (heading, pitch, roll, result = new HeadingPitchRoll()) {
+    Check.typeOf.number('heading', heading);
+    Check.typeOf.number('pitch', pitch);
+    Check.typeOf.number('roll', roll);
+
+    result.heading = heading;
+    result.pitch = pitch;
+    result.roll = roll;
+    return result;
+};
+
+/**
+ * 由旋转矩阵创建 HeadingPitchRoll。
+ * @param {Matrix3} rotationMatrix 旋转矩阵。
+ * @param {HeadingPitchRoll} [result] 存放结果的对象。
+ * @returns {HeadingPitchRoll} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.fromRotationMatrix = function (rotationMatrix, result) {
+    const quaternion = Quaternion.fromRotationMatrix(rotationMatrix, Scratch.scratchQuaternion);
+    return HeadingPitchRoll.fromQuaternion(quaternion, result);
+};
+
+/**
+ * 将 HeadingPitchRoll 转换为四元数。
+ * @param {HeadingPitchRoll} hpr 待转换的 HeadingPitchRoll。
+ * @param {Quaternion} [result] 存放结果的对象。
+ * @returns {Quaternion} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.toQuaternion = function (hpr, result) {
+    return Quaternion.fromHeadingPitchRoll(hpr, result);
+};
+
+/**
+ * 将当前 HeadingPitchRoll 转换为四元数。
+ * @param {Quaternion} [result] 存放结果的对象。
+ * @returns {Quaternion} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.prototype.toQuaternion = function (result) {
+    return HeadingPitchRoll.toQuaternion(this, result);
+};
+
+/**
+ * 将 HeadingPitchRoll 转换为角度制对象（包含 heading/pitch/roll/yaw，单位度）。
+ * @param {HeadingPitchRoll} hpr 待转换的 HeadingPitchRoll。
+ * @param {object} [result={}] 存放结果的对象。
+ * @returns {object} 修改后的 result 或新建的对象。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.toDegrees = function (hpr, result = {}) {
+    Check.defined('headingPitchRoll', hpr);
+
+    result.heading = CesiumMath.toDegrees(hpr.heading);
+    result.pitch = CesiumMath.toDegrees(hpr.pitch);
+    result.roll = CesiumMath.toDegrees(hpr.roll);
+    result.yaw = result.heading;
+    return result;
+};
+
+/**
+ * 将当前 HeadingPitchRoll 转换为角度制对象（包含 heading/pitch/roll/yaw，单位度）。
+ * @param {object} [result] 存放结果的对象。
+ * @returns {object} 修改后的 result 或新建的对象。
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.prototype.toDegrees = function (result) {
+    return HeadingPitchRoll.toDegrees(this, result);
+};
+
+/**
+ * 将 HeadingPitchRoll 转换为欧拉角（Cartesian3，弧度制）。
+ * @param {HeadingPitchRoll} hpr 待转换的 HeadingPitchRoll。
+ * @param {Cartesian3} [result] 存放结果的对象。
+ * @returns {Cartesian3} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.toEuler = function (hpr, result) {
+    return Cartesian3.fromElements(hpr.roll, -hpr.pitch, -hpr.heading, result);
+};
+
+/**
+ * 将当前 HeadingPitchRoll 转换为欧拉角（Cartesian3，弧度制）。
+ * @param {Cartesian3} [result] 存放结果的对象。
+ * @returns {Cartesian3} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.prototype.toEuler = function (result) {
+    return HeadingPitchRoll.toEuler(this, result);
+};
+
+/**
+ * 将 HeadingPitchRoll 转换为欧拉角（Cartesian3，角度制）。
+ * @param {HeadingPitchRoll} hpr 待转换的 HeadingPitchRoll。
+ * @param {Cartesian3} [result] 存放结果的对象。
+ * @returns {Cartesian3} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.toEulerDegrees = function (hpr, result) {
+    const euler = HeadingPitchRoll.toEuler(hpr, result);
+    euler.x = CesiumMath.toDegrees(euler.x);
+    euler.y = CesiumMath.toDegrees(euler.y);
+    euler.z = CesiumMath.toDegrees(euler.z);
+    return euler;
+};
+
+/**
+ * 将当前 HeadingPitchRoll 转换为欧拉角（Cartesian3，角度制）。
+ * @param {Cartesian3} [result] 存放结果的对象。
+ * @returns {Cartesian3} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.prototype.toEulerDegrees = function (result) {
+    return HeadingPitchRoll.toEulerDegrees(this, result);
+};
+
+/**
+ * 计算 HeadingPitchRoll 的逆（航向、俯仰、横滚各角取反）。
+ * @param {HeadingPitchRoll} hpr 待取反的 HeadingPitchRoll。
+ * @param {HeadingPitchRoll} [result=new HeadingPitchRoll()] 存放结果的对象。
+ * @returns {HeadingPitchRoll} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.inverse = function (hpr, result = new HeadingPitchRoll()) {
+    Check.defined('headingPitchRoll', hpr);
+
+    result.heading = -hpr.heading;
+    result.pitch = -hpr.pitch;
+    result.roll = -hpr.roll;
+    return result;
+};
+
+/**
+ * 计算当前 HeadingPitchRoll 的逆（各角取反）。
+ * @param {HeadingPitchRoll} [result] 存放结果的对象。
+ * @returns {HeadingPitchRoll} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.prototype.inverse = function (result) {
+    return HeadingPitchRoll.inverse(this, result);
+};
+
+/**
+ * 打包该对象到数组时占用的元素个数。
+ * @type {number}
+ * @constant
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.packedLength = 3;
+
+/**
+ * 将 HeadingPitchRoll 打包到数组中。
+ * @param {HeadingPitchRoll} value 待打包的 HeadingPitchRoll。
+ * @param {Array} [array=[]] 输出结果的数组。
+ * @param {number} [startingIndex=0] 数组开始索引。
+ * @returns {Array} 返回修改后的 array 数组。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.pack = function (value, array = [], startingIndex = 0) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.defined("value", value);
+    //>>includeEnd('debug');
+
+    array[startingIndex++] = value.heading;
+    array[startingIndex++] = value.pitch;
+    array[startingIndex] = value.roll;
+    return array;
+};
+
+/**
+ * 将数组解包为 HeadingPitchRoll。
+ * @param {Array} array 输入的数组。
+ * @param {number} [startingIndex=0] 数组开始索引。
+ * @param {HeadingPitchRoll} [result=new HeadingPitchRoll()] 存放结果的对象。
+ * @returns {HeadingPitchRoll} 修改后的 result 或新建的实例。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.unpack = function (array, startingIndex = 0, result = new HeadingPitchRoll()) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.array("array", array);
+    //>>includeEnd('debug');
+
+    result.heading = array[startingIndex++];
+    result.pitch = array[startingIndex++];
+    result.roll = array[startingIndex];
+    return result;
+};
+
+/**
+ * 将 HeadingPitchRoll 数组打包到数组中。
+ * @param {Array<HeadingPitchRoll>} hprs HeadingPitchRoll 数组。
+ * @param {Array} [result=[]] 输出结果的数组。
+ * @returns {Array} 返回修改后的 result 数组。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.packArray = function (hprs, result = []) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.array("hprs", hprs);
+    //>>includeEnd('debug');
+
+    let startingIndex = 0;
+    for (let i = 0; i < hprs.length; i++) {
+        HeadingPitchRoll.pack(hprs[i], result, startingIndex);
+        startingIndex += HeadingPitchRoll.packedLength;
+    }
+    return result;
+};
+
+/**
+ * 将数组解包为 HeadingPitchRoll 数组。
+ * @param {Array} array 输入的数组。
+ * @param {Array} [result=[]] 输出结果的数组。
+ * @returns {Array<HeadingPitchRoll>} 返回修改后的 result 数组。
+ * @memberof HeadingPitchRoll
+ * @static
+*/
+HeadingPitchRoll.unpackArray = function (array, result = []) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.array("array", array);
+    //>>includeEnd('debug');
+
+    result.length = array.length / HeadingPitchRoll.packedLength;
+
+    let startingIndex = 0;
+    for (let i = 0; i < result.length; i++) {
+        result[i] = HeadingPitchRoll.unpack(array, startingIndex);
+        startingIndex += HeadingPitchRoll.packedLength;
+    }
+    return result;
+};
+
+/**
+ * 值为 (0.0, 0.0, 0.0) 的不可变 HeadingPitchRoll 实例。
+ * @type {HeadingPitchRoll}
+ * @constant
+ * @memberof HeadingPitchRoll
+*/
+HeadingPitchRoll.ZERO = Object.freeze(new HeadingPitchRoll(0.0, 0.0, 0.0));
+
+export default HeadingPitchRoll;
+export { HeadingPitchRoll };
+

package/src/revisions/JulianDate.revise.js

@@ -0,0 +1,28 @@
+import { JulianDate } from "cesium";
+
+/**
+ * 扩展 Cesium 的 JulianDate 类，补充转换为 JavaScript Date 与公历日期的方法。
+ * @class JulianDate
+ * @see {@link https://cesium.com/learn/cesiumjs/ref-doc/JulianDate.html}
+*/
+
+/**
+ * 将当前 JulianDate 转换为 JavaScript Date 对象。
+ * @returns {Date} 对应的 JavaScript Date 对象。
+ * @memberof JulianDate
+*/
+JulianDate.prototype.toDate = function () {
+    return JulianDate.toDate(this);
+};
+
+/**
+ * 将当前 JulianDate 转换为公历日期对象。
+ * @returns {GregorianDate} 对应的公历日期对象。
+ * @memberof JulianDate
+*/
+JulianDate.prototype.toGregorianDate = function () {
+    return JulianDate.toGregorianDate(this);
+};
+
+export default JulianDate;
+export { JulianDate };

package/src/revisions/Material.revise.js

@@ -0,0 +1,308 @@
+// import setOptions from '@lijuhong1981/jslib/src/setParameters.js';
+// import WaterMaterial from '../materials/WaterMaterial.js';
+import { Check, Color, Event, Material, MaterialProperty, Matrix3, Matrix4 } from 'cesium';
+
+/**
+ * 扩展 Cesium 的 Material 类，补充 BasicImage、ConverageArea、PolylineTrail、ImageTransform
+ * 等自定义材质类型。
+ * @class Material
+ * @see {@link https://cesium.com/learn/cesiumjs/ref-doc/Material.html}
+*/
+/**
+ * 扩展 Cesium 的 MaterialProperty 类，补充按材质类型或材质实例创建属性对象的方法。
+ * @class MaterialProperty
+ * @see {@link https://cesium.com/learn/cesiumjs/ref-doc/MaterialProperty.html}
+*/
+
+// Material.prototype.setOptions = function (options) {
+//     setOptions(this, options);
+// };
+
+// Material.defaultWaterMaterial = WaterMaterial.default;
+
+/**
+ * MaterialProperty 的常量实现：按指定的材质类型与 uniform 直接返回材质参数。
+ * @class MaterialPropertyImpl
+ * @private
+*/
+class MaterialPropertyImpl {
+    constructor(type, uniforms = {}, isConstent = true) {
+        Check.defined('type', type);
+        this._type = type;
+        this._uniforms = uniforms;
+        this._isConstant = isConstent;
+        this._definitionChanged = new Event();
+    }
+
+    get isConstant() {
+        return this._isConstant;
+    }
+
+    get definitionChanged() {
+        return this._definitionChanged;
+    }
+
+    getType(time) {
+        return this._type;
+    }
+
+    getValue(time, uniforms) {
+        for (const key in this._uniforms) {
+            if (Object.hasOwnProperty.call(this._uniforms, key)) {
+                uniforms[key] = this._uniforms[key];
+            }
+        }
+        return uniforms;
+    }
+
+    equals(other) {
+        return (this._type === other._type && this._uniforms === other._uniforms);
+    }
+};
+
+/**
+ * 按材质类型与 uniform 创建 MaterialProperty。
+ * @param {string} type 材质类型。
+ * @param {object} [uniforms={}] 材质参数（uniform）。
+ * @param {boolean} [isConstent=true] 是否为常量材质。
+ * @returns {MaterialProperty} 创建的 MaterialProperty 实例。
+ * @memberof MaterialProperty
+ * @static
+*/
+MaterialProperty.fromType = function (type, uniforms, isConstent) {
+    return new MaterialPropertyImpl(type, uniforms, isConstent);
+};
+
+/**
+ * MaterialProperty 的实例实现：基于已有的 Material 对象返回材质参数。
+ * @class MaterialInstanceProperty
+ * @private
+*/
+class MaterialInstanceProperty {
+    constructor(material, uniforms = {}, isConstent = true) {
+        Check.defined('material', material);
+        this._material = material;
+        this._uniforms = uniforms;
+        this._isConstant = isConstent;
+        this._definitionChanged = new Event();
+    }
+
+    get material() {
+        return this._material;
+    }
+
+    get isConstant() {
+        return this._isConstant;
+    }
+
+    get definitionChanged() {
+        return this._definitionChanged;
+    }
+
+    getType(time) {
+        return this._material.type;
+    }
+
+    getValue(time, uniforms) {
+        for (const key in this._uniforms) {
+            if (Object.hasOwnProperty.call(this._uniforms, key)) {
+                uniforms[key] = this._uniforms[key];
+            }
+        }
+        return uniforms;
+    }
+
+    equals(other) {
+        return this._material === other._material;
+    }
+}
+
+/**
+ * 按已有 Material 实例与 uniform 创建 MaterialProperty。
+ * @param {Material} material 材质实例。
+ * @param {object} [uniforms={}] 材质参数（uniform）。
+ * @param {boolean} [isConstent=true] 是否为常量材质。
+ * @returns {MaterialProperty} 创建的 MaterialProperty 实例。
+ * @memberof MaterialProperty
+ * @static
+*/
+MaterialProperty.fromMaterial = function (material, uniforms, isConstent) {
+    return new MaterialInstanceProperty(material, uniforms, isConstent);
+};
+
+const BasicImageType = 'BasicImage';
+
+/**
+ * BasicImage 材质类型标识（基于 uv 贴图与颜色渲染）。
+ * @type {string}
+ * @constant
+ * @memberof Material
+*/
+Material.BasicImageType = BasicImageType;
+//添加BasicImageType材质
+Material._materialCache.addMaterial(BasicImageType, {
+    //基于Cesium fabric语法构建材质
+    fabric: {
+        type: BasicImageType, //材质类型
+        uniforms: { //接受的参数
+            image: Material.DefaultImageId, //普通uv贴图
+            color: new Color(), //颜色
+            // translucent: true, //是否透明
+        },
+        source: "czm_material czm_getMaterial(czm_materialInput materialInput)\n" + //固定写法，重载czm_getMaterial函数
+            "{\n" +
+            "   czm_material material = czm_getDefaultMaterial(materialInput);\n" + //获取默认材质
+            "   vec2 st = materialInput.st;\n" + //获取uv
+            "   vec4 imageColor = texture(image, st);\n" + //从uv贴图中获取imageColor
+            "   material.diffuse = imageColor.rgb * color.rgb;\n" + //与外部传入color相乘得到最终渲染color，material.diffuse为最终渲染至屏幕上的color
+            // "   if (translucent)\n" +
+            "       material.alpha = imageColor.a * color.a;\n" + //translucent开启，则alpha值也相乘
+            // "   else\n" +
+            // "       material.alpha = imageColor.a;\n" + //translucent未开启
+            "   return material;\n" +
+            "}",
+    },
+    translucent: function (material) {
+        return material.uniforms.color.alpha < 1.0;
+    }
+});
+
+//定义ConverageAreaType
+const ConverageAreaType = 'ConverageArea';
+
+/**
+ * ConverageArea 材质类型标识（用于覆盖区域裁剪的材质）。
+ * @type {string}
+ * @constant
+ * @memberof Material
+*/
+Material.ConverageAreaType = ConverageAreaType;
+//添加Material材质
+Material._materialCache.addMaterial(ConverageAreaType, {
+    //基于Cesium fabric语法构建材质
+    fabric: {
+        type: ConverageAreaType, //材质类型
+        uniforms: { //接受的参数
+            outsideOfConverageArea: false,
+            converageAreaPlanes: Material.DefaultImageId,
+            converageAreaPlanesMatrix: Matrix4.IDENTITY.clone(),
+        },
+        source: "uniform bool outsideOfConverageArea;\n" +
+            "uniform highp sampler2D converageAreaPlanes;\n" +
+            "uniform mat4 converageAreaPlanesMatrix;\n" +
+            '\n' +
+            "czm_material czm_getMaterial(czm_materialInput materialInput)\n" +
+            "{\n" +
+            "   czm_material material = czm_getDefaultMaterial(materialInput);\n" +
+            "   bool isConverage = isConverageArea(gl_FragCoord, converageAreaPlanes, converageAreaPlanesMatrix);\n" +
+            "   isConverage = (outsideOfConverageArea ? !isConverage : isConverage);\n" +
+            "   if (!isConverage)\n" +
+            "   {\n" +
+            "       material.alpha = 0.0;\n" +
+            "       return material;\n" +
+            "   }\n" +
+            "   return material;\n" +
+            "}\n",
+    },
+    translucent: false,
+});
+
+const PolylineTrailType = 'PolylineTrail';
+
+/**
+ * PolylineTrail 材质类型标识（用于线尾迹效果的材质）。
+ * @type {string}
+ * @constant
+ * @memberof Material
+*/
+Material.PolylineTrailType = PolylineTrailType;
+
+Material._materialCache.addMaterial(PolylineTrailType, {
+    //基于Cesium fabric语法构建材质
+    fabric: {
+        type: PolylineTrailType, //材质类型
+        uniforms: { //接受的参数
+            color: new Color(1.0, 1.0, 1.0, 1.0), //颜色
+            trailLength: 1.0,
+            trailColor: new Color(1.0, 1.0, 1.0, 1.0),
+            trailImage: Material.DefaultImageId,
+            enableGlow: false,
+            glowPower: 0.25,
+            offset: 0,
+            reverse: false,
+            // translucent: true, //是否透明
+        },
+        source: "czm_material czm_getMaterial(czm_materialInput materialInput)\n" + //固定写法，重载czm_getMaterial函数
+            "{\n" +
+            "   czm_material material = czm_getDefaultMaterial(materialInput);\n" + //获取默认材质
+            "   material.diffuse = color.rgb;\n" +
+            "   material.alpha = color.a;\n" +
+            "   vec2 st = materialInput.st;\n" + //获取uv
+            "   float s = fract(st.s - offset);\n" +
+            "   if (s <= trailLength) {\n" +
+            "       st.s = s / trailLength;\n" +
+            "       if (reverse) st.s = 1.0 - st.s;\n" +
+            "       vec4 imageColor = texture(trailImage, st);\n" + //从uv贴图中获取imageColor
+            "       material.diffuse = imageColor.rgb * trailColor.rgb;\n" +
+            "       material.alpha = imageColor.a * trailColor.a;\n" +
+            "   }\n" +
+            "   if (enableGlow) {\n" +
+            "       float glow = glowPower / abs(st.t - 0.5) - (glowPower / 0.5);\n" + //计算glow
+            "       vec4 glowColor;\n" +
+            "       glowColor.rgb = max(vec3(glow - 1.0 + material.diffuse), material.diffuse);\n" +
+            "       glowColor.a = clamp(0.0, 1.0, glow) * material.alpha;\n" +
+            "       glowColor = czm_gammaCorrect(glowColor);\n" +
+            "       material.emission = glowColor.rgb;\n" +
+            "       material.alpha = glowColor.a;\n" +
+            "   }\n" +
+            "   return material;\n" +
+            "}",
+    },
+    translucent: function (material) {
+        const uniforms = material.uniforms;
+        return uniforms.color.alpha < 1.0 || uniforms.trailColor.alpha < 1.0;
+    }
+});
+
+//定义ImageTransformType
+const ImageTransformType = 'ImageTransform';
+
+/**
+ * ImageTransform 材质类型标识（基于贴图变换矩阵的材质）。
+ * @type {string}
+ * @constant
+ * @memberof Material
+*/
+Material.ImageTransformType = ImageTransformType;
+//添加ImageTransformType材质
+Material._materialCache.addMaterial(ImageTransformType, {
+    //基于Cesium fabric语法构建材质
+    fabric: {
+        type: ImageTransformType, //材质类型
+        uniforms: { //接受的参数
+            image: Material.DefaultImageId, //普通uv贴图
+            stTransform: Matrix3.IDENTITY.clone(), //贴图变换矩阵
+            color: new Color(), //颜色
+            // translucent: true, //是否透明
+        },
+        source: "czm_material czm_getMaterial(czm_materialInput materialInput)\n" + //固定写法，重载czm_getMaterial函数
+            "{\n" +
+            "   czm_material material = czm_getDefaultMaterial(materialInput);\n" + //获取默认材质
+            "   vec2 st = materialInput.st;\n" + //获取uv
+            "   st = fract((stTransform * vec3(st, 1.0)).xy);\n" + //计算变换后uv
+            "   vec4 imageColor = texture(image, st);\n" + //从uv贴图中获取imageColor
+            "   material.diffuse = imageColor.rgb * color.rgb;\n" + //与外部传入color相乘得到最终渲染color，material.diffuse为最终渲染至屏幕上的color
+            // "   if (translucent)\n" +
+            "       material.alpha = imageColor.a * color.a;\n" + //translucent开启，则alpha值也相乘
+            // "   else\n" +
+            // "       material.alpha = imageColor.a;\n" + //translucent未开启
+            "   return material;\n" +
+            "}",
+    },
+    translucent: function (material) {
+        return material.uniforms.color.alpha < 1.0;
+    }
+});
+
+export default Material;
+export { Material, MaterialProperty };