@galacean/effects-specification 0.0.1

package/dist/fallback.js

@@ -0,0 +1,1664 @@
+/*!
+ * Name: @galacean/effects-specification
+ * Description: Galacean Effects JSON Specification
+ * Author: Ant Group CO., Ltd.
+ * Version: v0.0.1
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*********************************************/
+/*               元素属性参数类型               */
+/*********************************************/
+/**
+ * 渲染等级
+ */
+var RenderLevel;
+(function (RenderLevel) {
+    RenderLevel["S"] = "S";
+    RenderLevel["APlus"] = "A+";
+    RenderLevel["A"] = "A";
+    RenderLevel["BPlus"] = "B+";
+    RenderLevel["B"] = "B";
+})(RenderLevel || (RenderLevel = {}));
+/**
+ * 混合模式
+ */
+var BlendingMode;
+(function (BlendingMode) {
+    /**
+     * 普通混合模式
+     */
+    BlendingMode[BlendingMode["ALPHA"] = 0] = "ALPHA";
+    /**
+     * 叠加混合模式
+     */
+    BlendingMode[BlendingMode["ADD"] = 1] = "ADD";
+    /**
+     * 相乘混合模式
+     */
+    BlendingMode[BlendingMode["MULTIPLY"] = 2] = "MULTIPLY";
+    /**
+     * 亮度混合模式
+     */
+    BlendingMode[BlendingMode["BRIGHTNESS"] = 3] = "BRIGHTNESS";
+    /**
+     * 减色混合模式
+     */
+    BlendingMode[BlendingMode["SUBTRACTION"] = 4] = "SUBTRACTION";
+    /**
+     * 强光混合模式
+     */
+    BlendingMode[BlendingMode["STRONG_LIGHT"] = 5] = "STRONG_LIGHT";
+    /**
+     * 弱光混合模式
+     */
+    BlendingMode[BlendingMode["WEAK_LIGHT"] = 6] = "WEAK_LIGHT";
+    /**
+     * 亮度叠加混合模式
+     */
+    BlendingMode[BlendingMode["SUPERPOSITION"] = 7] = "SUPERPOSITION";
+})(BlendingMode || (BlendingMode = {}));
+/**
+ * 单双面模式
+ */
+var SideMode;
+(function (SideMode) {
+    /**
+     * 双面模式
+     */
+    SideMode[SideMode["DOUBLE"] = 1032] = "DOUBLE";
+    /**
+     * 正面模式
+     */
+    SideMode[SideMode["FRONT"] = 1028] = "FRONT";
+    /**
+     * 背面模式
+     */
+    SideMode[SideMode["BACK"] = 1029] = "BACK";
+})(SideMode || (SideMode = {}));
+/**
+ * 蒙版模式
+ */
+var MaskMode;
+(function (MaskMode) {
+    /**
+     * 无蒙版
+     */
+    MaskMode[MaskMode["NONE"] = 0] = "NONE";
+    /**
+     * 蒙版
+     */
+    MaskMode[MaskMode["MASK"] = 1] = "MASK";
+    /**
+     * 被遮挡
+     */
+    MaskMode[MaskMode["OBSCURED"] = 2] = "OBSCURED";
+    /**
+     * 被反向遮挡
+     */
+    MaskMode[MaskMode["REVERSE_OBSCURED"] = 3] = "REVERSE_OBSCURED";
+})(MaskMode || (MaskMode = {}));
+/**
+ * 发射器形状
+ */
+var ShapeType;
+(function (ShapeType) {
+    /**
+     * 没有类型
+     */
+    ShapeType[ShapeType["NONE"] = 0] = "NONE";
+    /**
+     * 圆球
+     */
+    ShapeType[ShapeType["SPHERE"] = 1] = "SPHERE";
+    /**
+     * 圆锥
+     */
+    ShapeType[ShapeType["CONE"] = 2] = "CONE";
+    /**
+     * 半球
+     */
+    ShapeType[ShapeType["HEMISPHERE"] = 3] = "HEMISPHERE";
+    /**
+     * 圆
+     */
+    ShapeType[ShapeType["CIRCLE"] = 4] = "CIRCLE";
+    /**
+     * 圆环
+     */
+    ShapeType[ShapeType["DONUT"] = 5] = "DONUT";
+    /**
+     * 矩形
+     */
+    ShapeType[ShapeType["RECTANGLE"] = 6] = "RECTANGLE";
+    /**
+     * 矩形框
+     */
+    ShapeType[ShapeType["RECTANGLE_EDGE"] = 7] = "RECTANGLE_EDGE";
+    /**
+     * 直线
+     */
+    ShapeType[ShapeType["EDGE"] = 8] = "EDGE";
+    /**
+     * 贴图
+     */
+    ShapeType[ShapeType["TEXTURE"] = 9] = "TEXTURE";
+})(ShapeType || (ShapeType = {}));
+/**
+ * 插件类型
+ */
+var PluginType;
+(function (PluginType) {
+    /**
+     * 陀螺仪
+     */
+    PluginType[PluginType["GYROSCOPE"] = 0] = "GYROSCOPE";
+    /**
+     * Spine
+     */
+    PluginType[PluginType["SPINE"] = 1] = "SPINE";
+})(PluginType || (PluginType = {}));
+/**
+ * 交互类型
+ */
+var InteractType;
+(function (InteractType) {
+    /**
+     * 点击
+     */
+    InteractType[InteractType["CLICK"] = 0] = "CLICK";
+    /**
+     * 消息
+     * 前端收到 onMessageItem 回调
+     */
+    InteractType[InteractType["MESSAGE"] = 1] = "MESSAGE";
+    /**
+     * 拖拽
+     */
+    InteractType[InteractType["DRAG"] = 2] = "DRAG";
+})(InteractType || (InteractType = {}));
+/**
+ * 交互行为
+ */
+var InteractBehavior;
+(function (InteractBehavior) {
+    /**
+     * 无
+     */
+    InteractBehavior[InteractBehavior["NONE"] = 0] = "NONE";
+    /**
+     * 通知
+     */
+    InteractBehavior[InteractBehavior["NOTIFY"] = 1] = "NOTIFY";
+    /**
+     * 重置播放器
+     */
+    InteractBehavior[InteractBehavior["RESUME_PLAYER"] = 2] = "RESUME_PLAYER";
+    /**
+     * 清除元素
+     */
+    InteractBehavior[InteractBehavior["REMOVE"] = 3] = "REMOVE";
+    /**
+     * 暂停播放器
+     */
+    InteractBehavior[InteractBehavior["PAUSE"] = 4] = "PAUSE";
+})(InteractBehavior || (InteractBehavior = {}));
+/**
+ * 元素类型
+ */
+var ItemType;
+(function (ItemType) {
+    /**
+     * 错误元素
+     */
+    ItemType["base"] = "0";
+    /**
+     * 图层元素
+     */
+    ItemType["sprite"] = "1";
+    /**
+     * 粒子元素
+     */
+    ItemType["particle"] = "2";
+    /**
+     * 空节点元素
+     */
+    ItemType["null"] = "3";
+    /**
+     * 交互元素
+     */
+    ItemType["interact"] = "4";
+    /**
+     * 插件元素
+     */
+    ItemType["plugin"] = "5";
+    /**
+     * 相机元素
+     */
+    ItemType["camera"] = "6";
+    /**
+     * 预合成元素
+     */
+    ItemType["composition"] = "7";
+    /**
+     * 滤镜图层
+     */
+    ItemType["filter"] = "8";
+    /**
+     * Spine 元素
+     */
+    ItemType["spine"] = "spine";
+    /**
+     * Mesh 元素
+     */
+    ItemType["mesh"] = "mesh";
+    /**
+     * 节点树元素
+     */
+    ItemType["tree"] = "tree";
+    /**
+     * 文本元素
+     */
+    ItemType["text"] = "text";
+    /**
+     * 灯光元素
+     */
+    ItemType["light"] = "light";
+    /**
+     * 天空盒元素
+     */
+    ItemType["skybox"] = "skybox";
+})(ItemType || (ItemType = {}));
+/**
+ * 渲染模式
+ */
+var RenderMode;
+(function (RenderMode) {
+    /**
+     * 广告牌模式
+     */
+    RenderMode[RenderMode["BILLBOARD"] = 0] = "BILLBOARD";
+    /**
+     * 网格模式
+     */
+    RenderMode[RenderMode["MESH"] = 1] = "MESH";
+    /**
+     * 垂直广告牌模式
+     */
+    RenderMode[RenderMode["VERTICAL_BILLBOARD"] = 2] = "VERTICAL_BILLBOARD";
+    /**
+     * 水平广告牌模式
+     */
+    RenderMode[RenderMode["HORIZONTAL_BILLBOARD"] = 3] = "HORIZONTAL_BILLBOARD";
+})(RenderMode || (RenderMode = {}));
+/**
+ * 变换中心
+ */
+var ParticleOrigin;
+(function (ParticleOrigin) {
+    /**
+     * 水平和垂直中点
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER"] = 0] = "PARTICLE_ORIGIN_CENTER";
+    /**
+     * 水平左侧 垂直顶部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_TOP"] = 1] = "PARTICLE_ORIGIN_LEFT_TOP";
+    /**
+     * 水平左侧 垂直中间
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_CENTER"] = 2] = "PARTICLE_ORIGIN_LEFT_CENTER";
+    /**
+     * 水平左侧 垂直底部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_BOTTOM"] = 3] = "PARTICLE_ORIGIN_LEFT_BOTTOM";
+    /**
+     * 水平中间 垂直顶部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER_TOP"] = 4] = "PARTICLE_ORIGIN_CENTER_TOP";
+    /**
+     * 水平中间 垂直底部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER_BOTTOM"] = 5] = "PARTICLE_ORIGIN_CENTER_BOTTOM";
+    /**
+     * 水平右侧 垂直顶部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_TOP"] = 6] = "PARTICLE_ORIGIN_RIGHT_TOP";
+    /**
+     * 水平右侧 垂直中间
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_CENTER"] = 7] = "PARTICLE_ORIGIN_RIGHT_CENTER";
+    /**
+     * 水平右侧 垂直底部
+     */
+    ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_BOTTOM"] = 8] = "PARTICLE_ORIGIN_RIGHT_BOTTOM";
+})(ParticleOrigin || (ParticleOrigin = {}));
+
+var END_BEHAVIOR_DESTROY = 0;
+var END_BEHAVIOR_PAUSE = 1;
+var END_BEHAVIOR_FORWARD = 2;
+var END_BEHAVIOR_PAUSE_AND_DESTROY = 3;
+var END_BEHAVIOR_FREEZE = 4;
+var END_BEHAVIOR_RESTART = 5;
+var END_BEHAVIOR_DESTROY_CHILDREN = 6;
+var CAMERA_CLIP_MODE_VERTICAL = 1;
+var CAMERA_CLIP_MODE_NORMAL = 0;
+
+var CameraClipMode;
+(function (CameraClipMode) {
+    /**
+     * 剪裁上下
+     */
+    CameraClipMode[CameraClipMode["portrait"] = CAMERA_CLIP_MODE_VERTICAL] = "portrait";
+    /**
+     * 剪裁左右
+     */
+    CameraClipMode[CameraClipMode["landscape"] = CAMERA_CLIP_MODE_NORMAL] = "landscape";
+})(CameraClipMode || (CameraClipMode = {}));
+/**
+ * 结束行为
+ */
+var CompositionEndBehavior;
+(function (CompositionEndBehavior) {
+    /**
+     * 销毁
+     */
+    CompositionEndBehavior[CompositionEndBehavior["destroy"] = END_BEHAVIOR_DESTROY] = "destroy";
+    /**
+     * 暂停
+     */
+    CompositionEndBehavior[CompositionEndBehavior["pause"] = END_BEHAVIOR_PAUSE] = "pause";
+    /**
+     * 重播
+     */
+    CompositionEndBehavior[CompositionEndBehavior["restart"] = END_BEHAVIOR_RESTART] = "restart";
+    /**
+     * 无限播放
+     */
+    CompositionEndBehavior[CompositionEndBehavior["forward"] = END_BEHAVIOR_FORWARD] = "forward";
+    /**
+     * 销毁并保留最后一帧
+     */
+    CompositionEndBehavior[CompositionEndBehavior["pause_destroy"] = END_BEHAVIOR_PAUSE_AND_DESTROY] = "pause_destroy";
+})(CompositionEndBehavior || (CompositionEndBehavior = {}));
+
+/*********************************************/
+/*               基本数值属性参数              */
+/*********************************************/
+var ValueType;
+(function (ValueType) {
+    /**
+     * 常数
+     */
+    ValueType[ValueType["CONSTANT"] = 0] = "CONSTANT";
+    /**
+     * 二维常数向量
+     */
+    ValueType[ValueType["CONSTANT_VEC2"] = 1] = "CONSTANT_VEC2";
+    /**
+     * 三维常数向量
+     */
+    ValueType[ValueType["CONSTANT_VEC3"] = 2] = "CONSTANT_VEC3";
+    /**
+     * 四维常数向量
+     */
+    ValueType[ValueType["CONSTANT_VEC4"] = 3] = "CONSTANT_VEC4";
+    /**
+     * 随机数
+     */
+    ValueType[ValueType["RANDOM"] = 4] = "RANDOM";
+    /**
+     * 直线
+     */
+    ValueType[ValueType["LINE"] = 5] = "LINE";
+    /**
+     * 曲线
+     */
+    ValueType[ValueType["CURVE"] = 6] = "CURVE";
+    /**
+     * 贝塞尔路径
+     */
+    ValueType[ValueType["BEZIER_PATH"] = 7] = "BEZIER_PATH";
+    /**
+     * 颜色
+     */
+    ValueType[ValueType["RGBA_COLOR"] = 8] = "RGBA_COLOR";
+    /**
+     * 渐变色
+     */
+    ValueType[ValueType["GRADIENT_COLOR"] = 9] = "GRADIENT_COLOR";
+    /**
+     * 蒙版形状点集
+     */
+    ValueType[ValueType["SHAPE_POINTS"] = 10] = "SHAPE_POINTS";
+    /**
+     * 蒙版形状切分
+     */
+    ValueType[ValueType["SHAPE_SPLITS"] = 11] = "SHAPE_SPLITS";
+    /**
+     *直线路径
+     */
+    ValueType[ValueType["LINEAR_PATH"] = 12] = "LINEAR_PATH";
+    /**
+     * 多色
+     */
+    ValueType[ValueType["COLORS"] = 13] = "COLORS";
+    /**
+     * 二进制指针
+     */
+    ValueType[ValueType["BINARY"] = 20] = "BINARY";
+    /**
+     * 贝塞尔曲线
+     */
+    ValueType[ValueType["BEZIER_CURVE"] = 21] = "BEZIER_CURVE";
+    /**
+     * 贝塞尔曲线路径
+     */
+    ValueType[ValueType["BEZIER_CURVE_PATH"] = 22] = "BEZIER_CURVE_PATH";
+})(ValueType || (ValueType = {}));
+/**
+ * 关键帧类型
+ */
+var BezierKeyframeType;
+(function (BezierKeyframeType) {
+    BezierKeyframeType[BezierKeyframeType["AUTO"] = 0] = "AUTO";
+    BezierKeyframeType[BezierKeyframeType["EASE"] = 1] = "EASE";
+    BezierKeyframeType[BezierKeyframeType["EASE_IN"] = 2] = "EASE_IN";
+    BezierKeyframeType[BezierKeyframeType["EASE_OUT"] = 3] = "EASE_OUT";
+    BezierKeyframeType[BezierKeyframeType["LINE"] = 4] = "LINE";
+    BezierKeyframeType[BezierKeyframeType["HOLD"] = 5] = "HOLD";
+    BezierKeyframeType[BezierKeyframeType["LINE_OUT"] = 6] = "LINE_OUT";
+})(BezierKeyframeType || (BezierKeyframeType = {}));
+
+var ItemEndBehavior;
+(function (ItemEndBehavior) {
+    ItemEndBehavior[ItemEndBehavior["destroy"] = END_BEHAVIOR_DESTROY] = "destroy";
+    ItemEndBehavior[ItemEndBehavior["loop"] = END_BEHAVIOR_RESTART] = "loop";
+    ItemEndBehavior[ItemEndBehavior["forward"] = END_BEHAVIOR_FREEZE] = "forward";
+})(ItemEndBehavior || (ItemEndBehavior = {}));
+var ParentItemEndBehavior;
+(function (ParentItemEndBehavior) {
+    ParentItemEndBehavior[ParentItemEndBehavior["destroyChildren"] = END_BEHAVIOR_DESTROY_CHILDREN] = "destroyChildren";
+})(ParentItemEndBehavior || (ParentItemEndBehavior = {}));
+
+/**
+ * 粒子交互行为
+ */
+var ParticleInteractionBehavior;
+(function (ParticleInteractionBehavior) {
+    /**
+     * 无
+     */
+    ParticleInteractionBehavior[ParticleInteractionBehavior["none"] = 0] = "none";
+    /**
+     * 移出粒子
+     */
+    ParticleInteractionBehavior[ParticleInteractionBehavior["removeParticle"] = 1] = "removeParticle";
+})(ParticleInteractionBehavior || (ParticleInteractionBehavior = {}));
+
+var ShapeArcMode;
+(function (ShapeArcMode) {
+    /**
+     * 随机
+     */
+    ShapeArcMode[ShapeArcMode["RANDOM"] = 0] = "RANDOM";
+    /**
+     * 单向循环
+     */
+    ShapeArcMode[ShapeArcMode["UNIDIRECTIONAL_CYCLE"] = 1] = "UNIDIRECTIONAL_CYCLE";
+    /**
+     * 双向循环
+     */
+    ShapeArcMode[ShapeArcMode["BIDIRECTIONAL_CYCLE"] = 2] = "BIDIRECTIONAL_CYCLE";
+    /**
+     * 均匀爆发
+     */
+    ShapeArcMode[ShapeArcMode["UNIFORM_BURST"] = 3] = "UNIFORM_BURST";
+})(ShapeArcMode || (ShapeArcMode = {}));
+
+var ModelBoundingType;
+(function (ModelBoundingType) {
+    ModelBoundingType[ModelBoundingType["box"] = 2] = "box";
+    ModelBoundingType[ModelBoundingType["sphere"] = 3] = "sphere";
+})(ModelBoundingType || (ModelBoundingType = {}));
+
+// 材质类型
+var MaterialType;
+(function (MaterialType) {
+    MaterialType["unlit"] = "unlit";
+    MaterialType["pbr"] = "pbr";
+    // 头发材质，在 pbr 材质基础上扩展
+    MaterialType["hair"] = "hair";
+})(MaterialType || (MaterialType = {}));
+// 混合模式
+var MaterialBlending;
+(function (MaterialBlending) {
+    MaterialBlending[MaterialBlending["opaque"] = 100] = "opaque";
+    MaterialBlending[MaterialBlending["masked"] = 101] = "masked";
+    MaterialBlending[MaterialBlending["translucent"] = 102] = "translucent";
+    MaterialBlending[MaterialBlending["additive"] = 103] = "additive";
+})(MaterialBlending || (MaterialBlending = {}));
+
+/**
+ * 3D渲染模式：将渲染过程中的中间结果输出，主要用于排查渲染效果问题，支持 pbr 和 unlit 材质
+ */
+var RenderMode3D;
+(function (RenderMode3D) {
+    /**
+     * 正常渲染
+     */
+    RenderMode3D["none"] = "none";
+    /**
+     * 纹理坐标
+     */
+    RenderMode3D["uv"] = "uv";
+    /**
+     * 世界坐标法线
+     */
+    RenderMode3D["normal"] = "normal";
+    /**
+     * 基础颜色
+     */
+    RenderMode3D["basecolor"] = "basecolor";
+    /**
+     * 基础颜色 Alpha
+     */
+    RenderMode3D["alpha"] = "alpha";
+    /**
+     * 金属度
+     */
+    RenderMode3D["metallic"] = "metallic";
+    /**
+     * 粗超度
+     */
+    RenderMode3D["roughness"] = "roughness";
+    /**
+     * 环境遮蔽
+     */
+    RenderMode3D["ao"] = "ao";
+    /**
+     * 自发光
+     */
+    RenderMode3D["emissive"] = "emissive";
+})(RenderMode3D || (RenderMode3D = {}));
+
+var TextOverflow;
+(function (TextOverflow) {
+    /**
+     * display 模式下，会显示所有文本，存在文本超过边界框的情况。
+     */
+    TextOverflow[TextOverflow["display"] = 0] = "display";
+    /**
+     * clip 模式下，当文本内容超出边界框时，多余的会被截断。
+     */
+    TextOverflow[TextOverflow["clip"] = 1] = "clip";
+    /**
+     * ellipsis 模式下，会使用（...）来代替超出边界框的内容。
+     */
+    TextOverflow[TextOverflow["ellipsis"] = 2] = "ellipsis";
+})(TextOverflow || (TextOverflow = {}));
+var TextBaseline;
+(function (TextBaseline) {
+    /**
+     * 文本顶对齐。
+     */
+    TextBaseline[TextBaseline["top"] = 0] = "top";
+    /**
+     * 文本垂直居中对齐。
+     */
+    TextBaseline[TextBaseline["middle"] = 1] = "middle";
+    /**
+     * 文本底对齐。
+     */
+    TextBaseline[TextBaseline["bottom"] = 2] = "bottom";
+})(TextBaseline || (TextBaseline = {}));
+var TextAlignment;
+(function (TextAlignment) {
+    /**
+     * text alignment starts from（x,y) to right direction
+     * 从(x,y)开始第一个字符，向右边延伸
+     */
+    TextAlignment[TextAlignment["left"] = 0] = "left";
+    /**
+     * (x,y) is middle position of text, where (left + right)/2 =(x,y)
+     * (x,y) 为文字中间位置，（最左位置 + 最右位置)/2 = (x,y)
+     */
+    TextAlignment[TextAlignment["middle"] = 1] = "middle";
+    /**
+     * text alignment ends with（x,y) from left direction
+     * 从(x,y)结束最后一个字符，向左边延伸
+     */
+    TextAlignment[TextAlignment["right"] = 2] = "right";
+})(TextAlignment || (TextAlignment = {}));
+/**
+ * 文本字重
+ */
+var TextWeight;
+(function (TextWeight) {
+    /**
+     * 正常
+     */
+    TextWeight["normal"] = "normal";
+    /**
+     * 粗体
+     */
+    TextWeight["bold"] = "bold";
+    /**
+     * 瘦体
+     */
+    TextWeight["lighter"] = "lighter";
+})(TextWeight || (TextWeight = {}));
+/**
+ * 文本样式
+ */
+var FontStyle;
+(function (FontStyle) {
+    /**
+     * 正常
+     */
+    FontStyle["normal"] = "normal";
+    /**
+     * 斜体
+     */
+    FontStyle["italic"] = "italic";
+    /**
+     * 倾斜体
+     */
+    FontStyle["oblique"] = "oblique";
+})(FontStyle || (FontStyle = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function arrAdd(arr, item) {
+    if (!arr.includes(item)) {
+        arr.push(item);
+        return true;
+    }
+}
+/**
+ * @deprecated 请直接使用 Array.prototype.forEach 或 for...of
+ * @param object
+ * @param callback
+ * @returns the mutated input object
+ */
+function forEach(object, callback, thisObj) {
+    if (object) {
+        for (var name_1 in object) {
+            if (Object.hasOwnProperty.call(object, name_1)) {
+                callback.call(thisObj, object[name_1], name_1);
+            }
+        }
+    }
+    return object;
+}
+function ensureFixedNumber(a) {
+    if (Number.isFinite(a)) {
+        return [ValueType.CONSTANT, a];
+    }
+    if (a) {
+        if (a[0] === 'lines') {
+            return [ValueType.LINE, a[1]];
+        }
+        if (a[0] === 'curve') {
+            return [ValueType.CURVE, a[1]];
+        }
+        if (a[0] === 'static') {
+            return [ValueType.CONSTANT, a[1]];
+        }
+    }
+}
+function ensureFixedNumberWithRandom(a, p) {
+    if (Array.isArray(a) && a[0] === 'random') {
+        return [ValueType.CONSTANT, a[1][p]];
+    }
+    return ensureFixedNumber(a);
+}
+function ensureRGBAValue(a) {
+    if (a && a[0] === 'color') {
+        return colorToArr(a[1], true);
+    }
+    return [1, 1, 1, 1];
+}
+function ensureColorExpression(a, normalized) {
+    if (a) {
+        if (a[0] === 'colors') {
+            return [ValueType.COLORS, a[1].map(function (color) { return colorToArr(color, normalized); })];
+        }
+        else if (a[0] === 'gradient') {
+            return ensureGradient(a[1], normalized);
+        }
+        else if (a[0] === 'color') {
+            return [ValueType.RGBA_COLOR, colorToArr(a[1], normalized)];
+        }
+    }
+}
+function ensureNumberExpression(a) {
+    if (a && a[0] === 'random') {
+        return [ValueType.RANDOM, a[1]];
+    }
+    return ensureFixedNumber(a);
+}
+function ensureValueGetter(a) {
+    if (Array.isArray(a) && typeof a[0] === 'string') {
+        return ensureNumberExpression(a) || ensureFixedVec3(a) || ensureColorExpression(a) || a;
+    }
+    return a;
+}
+function ensureGradient(a, normalized) {
+    if (a) {
+        var stops_1 = [];
+        Object.getOwnPropertyNames(a).forEach(function (p) {
+            var stop = parsePercent(p);
+            var color = colorToArr(a[p], normalized);
+            stops_1.push([stop, color[0], color[1], color[2], color[3]]);
+        });
+        stops_1 = stops_1.sort(function (a, b) { return a[0] - b[0]; });
+        return [ValueType.GRADIENT_COLOR, stops_1];
+    }
+}
+function colorToArr(hex, normalized) {
+    var ret;
+    if (typeof hex === 'string') {
+        hex = hex.replace(/[\s\t\r\n]/g, '');
+        var m = /rgba?\(([.\d]+),([.\d]+),([.\d]+),?([.\d]+)?\)/.exec(hex);
+        if (m) {
+            var a = +m[4];
+            ret = [+m[1], +m[2], +m[3], isNaN(a) ? 255 : Math.round(a * 255)];
+        }
+        else if (/^#[a-f\d]{3}$/i.test(hex)) {
+            ret = [parseInt(hex[1] + hex[1], 16), parseInt(hex[2] + hex[2], 16), parseInt(hex[3] + hex[3], 16), 255];
+            // eslint-disable-next-line no-cond-assign
+        }
+        else if (m = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)) {
+            ret = [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16), 255] || [0, 0, 0, 255];
+        }
+    }
+    else if (hex instanceof Array) {
+        ret = [hex[0], hex[1], hex[2], isNaN(hex[3]) ? 255 : Math.round(hex[3] * 255)];
+    }
+    if (normalized) {
+        // @ts-expect-error
+        ret = normalizeColor(ret);
+    }
+    // @ts-expect-error
+    return ret;
+}
+function normalizeColor(a) {
+    if (Array.isArray(a)) {
+        return a.map(function (i) { return Number.isFinite(i / 255) ? Number((i / 255).toFixed(6)) : 0; });
+    }
+}
+function parsePercent(c) {
+    var match = /^(-)?([\d+.]+)%$/.exec(c);
+    if (match) {
+        return +match[2] / 100 * (match[1] ? -1 : 1);
+    }
+    return +c;
+}
+function getGradientColor(color, normalized) {
+    if (Array.isArray(color)) {
+        // @ts-expect-error
+        return (color[0] === 'gradient' || color[0] === 'color') && ensureGradient(color[1], normalized);
+    }
+    else {
+        return ensureGradient(color, normalized);
+    }
+}
+function ensureFixedVec3(a) {
+    if (a) {
+        if (a.length === 3) {
+            return [ValueType.CONSTANT_VEC3, a];
+        }
+        if (a[0] === 'path') {
+            return [ValueType.LINEAR_PATH, a[1]];
+        }
+        if (a[0] === 'bezier') {
+            return [ValueType.BEZIER_PATH, a[1]];
+        }
+    }
+}
+function objectValueToNumber(o) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(Object.entries(o)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+            o[key] = Number(value);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return o;
+}
+function deleteEmptyValue(o) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(Object.keys(o)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            if (o[key] === undefined) {
+                delete o[key];
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return o;
+}
+var cos = Math.cos;
+var sin = Math.sin;
+var d2r = Math.PI / 180;
+var r2d = 180 / Math.PI;
+function quatFromXYZRotation(out, x, y, z) {
+    var c1 = cos((x * d2r) / 2);
+    var c2 = cos((y * d2r) / 2);
+    var c3 = cos((z * d2r) / 2);
+    var s1 = sin((x * d2r) / 2);
+    var s2 = sin((y * d2r) / 2);
+    var s3 = sin((z * d2r) / 2);
+    out[0] = s1 * c2 * c3 + c1 * s2 * s3;
+    out[1] = c1 * s2 * c3 - s1 * c2 * s3;
+    out[2] = c1 * c2 * s3 + s1 * s2 * c3;
+    out[3] = c1 * c2 * c3 - s1 * s2 * s3;
+    return out;
+}
+function clamp(v, min, max) {
+    return v > max ? max : (v < min ? min : v);
+}
+function rotationZYXFromQuat(out, quat) {
+    var x = quat[0];
+    var y = quat[1];
+    var z = quat[2];
+    var w = quat[3];
+    var x2 = x + x;
+    var y2 = y + y;
+    var z2 = z + z;
+    var xx = x * x2;
+    var yx = y * x2;
+    var yy = y * y2;
+    var zx = z * x2;
+    var zy = z * y2;
+    var zz = z * z2;
+    var wx = w * x2;
+    var wy = w * y2;
+    var wz = w * z2;
+    var m11 = 1 - yy - zz, m12 = yx - wz;
+    var m21 = yx + wz, m22 = 1 - xx - zz;
+    var m31 = zx - wy, m32 = zy + wx, m33 = 1 - xx - yy;
+    out[1] = Math.asin(clamp(-m31, -1, 1)) * r2d;
+    if (Math.abs(m31) < 0.9999999) {
+        out[0] = Math.atan2(m32, m33) * r2d;
+        out[2] = Math.atan2(m21, m11) * r2d;
+    }
+    else {
+        out[0] = 0;
+        out[2] = Math.atan2(-m12, m22) * r2d;
+    }
+    return out;
+}
+
+function getStandardParticleContent(particle) {
+    var _a;
+    var options = particle.options;
+    var transform = particle.transform;
+    var shape = {
+        type: ShapeType.NONE,
+    };
+    if (particle.shape) {
+        var shapeType = (_a = particle.shape.shape) === null || _a === void 0 ? void 0 : _a.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+        shape = __assign(__assign({}, particle.shape), { type: ShapeType[shapeType] });
+        if (particle.shape.upDirection) {
+            var _b = __read(particle.shape.upDirection, 3), x = _b[0], y = _b[1], z = _b[2];
+            if (x === 0 && y === 0 && z === 0) {
+                delete shape.upDirection;
+            }
+        }
+    }
+    if (options.startTurbulence) {
+        shape.turbulenceX = ensureNumberExpression(options.turbulenceX);
+        shape.turbulenceY = ensureNumberExpression(options.turbulenceY);
+        shape.turbulenceZ = ensureNumberExpression(options.turbulenceZ);
+    }
+    var emission = particle.emission;
+    if (emission.bursts && emission.bursts.length > 0) {
+        emission.bursts = emission.bursts.map(function (b) { return objectValueToNumber(b); });
+    }
+    if (emission.burstOffsets && emission.burstOffsets.length > 0) {
+        emission.burstOffsets = emission.burstOffsets.map(function (b) { return objectValueToNumber(b); });
+    }
+    if (emission.rateOverTime) {
+        emission.rateOverTime = ensureNumberExpression(emission.rateOverTime);
+    }
+    var ret = {
+        renderer: particle.renderer,
+        shape: shape,
+        splits: particle.splits,
+        emission: emission,
+        options: {
+            startLifetime: ensureNumberExpression(options.startLifetime),
+            start3DSize: !!options.start3DSize,
+            startSize: ensureNumberExpression(options.startSize),
+            startSizeX: ensureNumberExpression(options.startSizeX),
+            startSizeY: ensureNumberExpression(options.startSizeY),
+            sizeAspect: ensureNumberExpression(options.sizeAspect),
+            maxCount: options.maxCount,
+            startDelay: ensureNumberExpression(options.startDelay),
+            startColor: ensureColorExpression(options.startColor, true),
+            startRotationZ: ensureNumberExpression(options.startRotation || options.startRotationZ),
+            particleFollowParent: options.particleFollowParent,
+        },
+    };
+    if (options.start3DRotation) {
+        ret.options.startRotationX = ensureNumberExpression(options.startRotationX);
+        ret.options.startRotationY = ensureNumberExpression(options.startRotationY);
+    }
+    if (particle.filter) {
+        var filter_1 = {};
+        forEach(particle.filter, function (val, key) {
+            // @ts-expect-error
+            filter_1[key] = ensureValueGetter(val);
+        });
+        ret.filter = filter_1;
+    }
+    if (transform && transform.path) {
+        ret.emitterTransform = {
+            path: ensureFixedVec3(transform.path),
+        };
+    }
+    var sizeOverLifetime = particle.sizeOverLifetime;
+    if (sizeOverLifetime) {
+        if (sizeOverLifetime.separateAxes) {
+            ret.sizeOverLifetime = {
+                separateAxes: true,
+                x: ensureNumberExpression(sizeOverLifetime.x),
+                y: ensureNumberExpression(sizeOverLifetime.y),
+            };
+        }
+        else {
+            ret.sizeOverLifetime = {
+                size: ensureNumberExpression(sizeOverLifetime.size),
+            };
+        }
+    }
+    var velocityOverLifetime = particle.velocityOverLifetime || {};
+    var sol = velocityOverLifetime.speedOverLifetime;
+    if (sol) {
+        sol = ensureFixedNumber(sol);
+    }
+    else {
+        sol = undefined;
+    }
+    ret.positionOverLifetime = {
+        gravity: options.gravity,
+        gravityOverLifetime: ensureFixedNumber(options.gravityModifier),
+        startSpeed: ensureNumberExpression(options.startSpeed),
+        speedOverLifetime: sol,
+        asMovement: velocityOverLifetime.asMovement,
+        linearX: ensureNumberExpression(velocityOverLifetime.linearX),
+        linearY: ensureNumberExpression(velocityOverLifetime.linearY),
+        linearZ: ensureNumberExpression(velocityOverLifetime.linearZ),
+        asRotation: velocityOverLifetime.asRotation,
+        orbCenter: velocityOverLifetime.orbCenter,
+        orbitalX: ensureNumberExpression(velocityOverLifetime.orbitalX),
+        orbitalY: ensureNumberExpression(velocityOverLifetime.orbitalY),
+        orbitalZ: ensureNumberExpression(velocityOverLifetime.orbitalZ),
+        forceTarget: velocityOverLifetime.forceTarget,
+        target: velocityOverLifetime.target,
+        forceCurve: ensureFixedNumber(velocityOverLifetime.forceCurve),
+    };
+    deleteEmptyValue(ret.positionOverLifetime);
+    var rotationOverLifetime = particle.rotationOverLifetime;
+    if (rotationOverLifetime) {
+        ret.rotationOverLifetime = {
+            separateAxes: rotationOverLifetime.separateAxes,
+            asRotation: rotationOverLifetime.asRotation,
+            z: ensureNumberExpression(rotationOverLifetime.separateAxes ? rotationOverLifetime.z : rotationOverLifetime.angularVelocity),
+        };
+        if (rotationOverLifetime.separateAxes) {
+            ret.rotationOverLifetime.y = ensureFixedNumber(rotationOverLifetime.y);
+            ret.rotationOverLifetime.x = ensureFixedNumber(rotationOverLifetime.x);
+        }
+    }
+    var colorOverLifetime = particle.colorOverLifetime;
+    if (colorOverLifetime) {
+        var col = ret.colorOverLifetime = {
+            opacity: ensureFixedNumber(colorOverLifetime.opacity),
+        };
+        if (colorOverLifetime.color) {
+            col.color = getGradientColor(colorOverLifetime.color);
+        }
+    }
+    var textureSheetAnimation = particle.textureSheetAnimation;
+    if (textureSheetAnimation) {
+        ret.textureSheetAnimation = {
+            row: textureSheetAnimation.row,
+            col: textureSheetAnimation.col,
+            total: textureSheetAnimation.total,
+            animate: textureSheetAnimation.animate,
+            cycles: ensureFixedNumber(textureSheetAnimation.cycles),
+            animationDelay: ensureFixedNumberWithRandom(textureSheetAnimation.animationDelay, 0),
+            animationDuration: ensureFixedNumberWithRandom(textureSheetAnimation.animationDuration, 0),
+        };
+    }
+    var trials = particle.trails;
+    if (trials) {
+        ret.trails = {
+            lifetime: ensureNumberExpression(trials.lifetime),
+            dieWithParticles: trials.dieWithParticles,
+            maxPointPerTrail: trials.maxPointPerTrail,
+            minimumVertexDistance: trials.minimumVertexDistance,
+            widthOverTrail: ensureFixedNumber(trials.widthOverTrail),
+            colorOverTrail: trials.colorOverTrail && getGradientColor(trials.colorOverTrail, false),
+            blending: trials.blending,
+            colorOverLifetime: trials.colorOverLifetime && getGradientColor(trials.colorOverLifetime, false),
+            inheritParticleColor: trials.inheritParticleColor,
+            occlusion: trials.occlusion,
+            transparentOcclusion: trials.transparentOcclusion,
+            orderOffset: trials.orderOffset,
+            sizeAffectsLifetime: trials.sizeAffectsLifetime,
+            sizeAffectsWidth: trials.sizeAffectsWidth,
+            texture: trials.texture,
+            parentAffectsPosition: trials.parentAffectsPosition,
+            opacityOverLifetime: ensureNumberExpression(trials.opacityOverLifetime),
+        };
+    }
+    ret.trails && deleteEmptyValue(ret.trails);
+    var interaction = particle.interaction;
+    if (interaction) {
+        ret.interaction = {
+            behavior: interaction.behavior,
+            radius: interaction.radius,
+            multiple: interaction.multiple,
+        };
+    }
+    return ret;
+}
+
+function getStandardNullContent(sprite, transform) {
+    var _a;
+    var opt = sprite.options;
+    var velocityOverLifetime = sprite.velocityOverLifetime || {};
+    var positionOverLifetime = {
+        path: ensureFixedVec3((_a = sprite.transform) === null || _a === void 0 ? void 0 : _a.path),
+        gravity: opt.gravity,
+        gravityOverLifetime: ensureFixedNumber(opt.gravityModifier),
+        direction: opt.direction,
+        startSpeed: opt.startSpeed,
+        asMovement: velocityOverLifetime.asMovement,
+        linearX: ensureFixedNumber(velocityOverLifetime.linearX),
+        linearY: ensureFixedNumber(velocityOverLifetime.linearY),
+        linearZ: ensureFixedNumber(velocityOverLifetime.linearZ),
+        asRotation: velocityOverLifetime.asRotation,
+        orbCenter: velocityOverLifetime.orbCenter,
+        orbitalX: ensureFixedNumber(velocityOverLifetime.orbitalX),
+        orbitalY: ensureFixedNumber(velocityOverLifetime.orbitalY),
+        orbitalZ: ensureFixedNumber(velocityOverLifetime.orbitalZ),
+        speedOverLifetime: ensureFixedNumber(velocityOverLifetime.speedOverLifetime),
+    };
+    deleteEmptyValue(positionOverLifetime);
+    var ret = {
+        options: {
+            startColor: ensureRGBAValue(opt.startColor),
+        },
+        positionOverLifetime: positionOverLifetime,
+    };
+    if (opt.startSize) {
+        transform.scale = [opt.startSize, opt.startSize / (opt.sizeAspect || 1), 1];
+    }
+    if (opt.startRotation) {
+        if (!transform.rotation) {
+            transform.rotation = [0, 0, opt.startRotation];
+        }
+        else {
+            transform.rotation[2] += opt.startRotation;
+        }
+    }
+    var rotationOverLifetime = sprite.rotationOverLifetime;
+    if (rotationOverLifetime) {
+        var rot = ret.rotationOverLifetime = {
+            separateAxes: rotationOverLifetime.separateAxes,
+            asRotation: rotationOverLifetime.asRotation,
+        };
+        if (rot.separateAxes) {
+            rot.x = ensureFixedNumber(rotationOverLifetime.x);
+            rot.y = ensureFixedNumber(rotationOverLifetime.y);
+            rot.z = ensureFixedNumber(rotationOverLifetime.z);
+        }
+        else {
+            rot.z = ensureFixedNumber(rotationOverLifetime.angularVelocity);
+        }
+    }
+    var colorOverLifetime = sprite.colorOverLifetime;
+    if (colorOverLifetime) {
+        var col = ret.colorOverLifetime = {
+            opacity: ensureFixedNumber(colorOverLifetime.opacity),
+        };
+        if (colorOverLifetime.color) {
+            col.color = getGradientColor(colorOverLifetime.color);
+        }
+    }
+    var sizeOverLifetime = sprite.sizeOverLifetime;
+    if (sizeOverLifetime) {
+        ret.sizeOverLifetime = {
+            separateAxes: sizeOverLifetime.separateAxes,
+            size: ensureFixedNumber(sizeOverLifetime.size),
+            x: ensureFixedNumber(sizeOverLifetime.x),
+            y: ensureFixedNumber(sizeOverLifetime.y),
+            z: ensureFixedNumber(sizeOverLifetime.z),
+        };
+    }
+    return ret;
+}
+function getStandardSpriteContent(sprite, transform) {
+    var ret = getStandardNullContent(sprite, transform);
+    var texAni = sprite.textureSheetAnimation;
+    if (texAni) {
+        ret.textureSheetAnimation = {
+            row: texAni.row,
+            col: texAni.col,
+            total: texAni.total || undefined,
+            animate: texAni.animate,
+        };
+    }
+    ret.renderer = sprite.renderer;
+    if (sprite.splits) {
+        ret.splits = sprite.splits;
+    }
+    if (sprite.interaction) {
+        ret.interaction = sprite.interaction;
+    }
+    return ret;
+}
+
+function getStandardInteractContent(ui) {
+    var options = ui.options;
+    var option;
+    switch (options.type) {
+        case 'click': {
+            option = {
+                type: InteractType.CLICK,
+                showPreview: options.showPreview,
+                previewColor: options.previewColor && ensureRGBAValue(options.previewColor),
+                behavior: options.behavior || InteractBehavior.NOTIFY,
+            };
+            break;
+        }
+        case 'drag': {
+            option = {
+                type: InteractType.DRAG,
+                enableInEditor: !!options.enableInEditor,
+                dxRange: options.dxRange,
+                dyRange: options.dyRange,
+                target: options.target,
+            };
+            break;
+        }
+        case 'message': {
+            option = {
+                type: InteractType.MESSAGE,
+            };
+            break;
+        }
+    }
+    var ret = {
+        // @ts-expect-error
+        options: option,
+    };
+    return ret;
+}
+
+function getStandardCameraContent(model) {
+    var _a, _b;
+    var opt = model.options;
+    var ret = {
+        options: {
+            fov: opt.fov,
+            far: opt.far,
+            near: opt.near,
+            clipMode: opt.clipMode,
+        },
+    };
+    var velocityOverLifetime = model.velocityOverLifetime;
+    if (velocityOverLifetime || ((_a = model.transform) === null || _a === void 0 ? void 0 : _a.path)) {
+        var positionOverLifetime = {
+            path: ensureFixedVec3((_b = model.transform) === null || _b === void 0 ? void 0 : _b.path),
+            linearX: ensureFixedNumber(velocityOverLifetime === null || velocityOverLifetime === void 0 ? void 0 : velocityOverLifetime.translateX),
+            linearY: ensureFixedNumber(velocityOverLifetime === null || velocityOverLifetime === void 0 ? void 0 : velocityOverLifetime.translateY),
+            linearZ: ensureFixedNumber(velocityOverLifetime === null || velocityOverLifetime === void 0 ? void 0 : velocityOverLifetime.translateZ),
+        };
+        deleteEmptyValue(positionOverLifetime);
+        ret.positionOverLifetime = positionOverLifetime;
+    }
+    var rol = model.rotationOverLifetime;
+    if (rol) {
+        var rotationOverLifetime = {
+            separateAxes: rol.separateAxes,
+            x: ensureFixedNumber(rol === null || rol === void 0 ? void 0 : rol.rotateX),
+            y: ensureFixedNumber(rol === null || rol === void 0 ? void 0 : rol.rotateY),
+            z: rol.separateAxes ? ensureFixedNumber(rol === null || rol === void 0 ? void 0 : rol.rotateZ) : ensureFixedNumber(rol.rotation),
+        };
+        deleteEmptyValue(rotationOverLifetime);
+        ret.rotationOverLifetime = rotationOverLifetime;
+    }
+    return ret;
+}
+
+var convertParams = [
+    'strength',
+    'bloomAddon',
+    'colorAddon',
+    'period',
+    'waveMovement',
+    'colorThreshold',
+    'xOpacity',
+    'yOpacity',
+    'feather',
+];
+var pathParams = [
+    'path', 'position',
+];
+function getStandardFilterContent(filter) {
+    var ret = {};
+    forEach(filter, function (val, key) {
+        if (convertParams.includes(key)) {
+            ret[key] = ensureFixedNumber(val);
+        }
+        else if (pathParams.includes(key)) {
+            ret[key] = ensureFixedVec3(val);
+        }
+        else {
+            ret[key] = val;
+        }
+    });
+    return ret;
+}
+
+/**
+ * 2.1 以下版本数据适配（mars-player@2.4.0 及以上版本支持 2.1 以下数据的适配）
+ */
+function version21Migration(json) {
+    json.compositions.forEach(function (composition) {
+        composition.items.forEach(function (item) {
+            if (item.type === ItemType.null) {
+                if (item.endBehavior === ItemEndBehavior.destroy) {
+                    item.endBehavior = ItemEndBehavior.forward;
+                }
+            }
+        });
+    });
+    json.version = '2.1';
+    return json;
+}
+
+var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
+var standardVersion = /^(\d+)\.(\d+)$/;
+var reverseParticle = false;
+function getStandardJSON(json) {
+    var _a, _b;
+    if (!json || typeof json !== 'object') {
+        throw Error('expect a json object');
+    }
+    if (v0.test(json.version)) {
+        reverseParticle = ((_a = (/^(\d+)/).exec(json.version)) === null || _a === void 0 ? void 0 : _a[0]) === '0';
+        return version21Migration(getStandardJSONFromV0(json));
+    }
+    var mainVersion = (_b = standardVersion.exec(json.version)) === null || _b === void 0 ? void 0 : _b[1];
+    if (mainVersion) {
+        if (Number(mainVersion) < 2) {
+            return version21Migration(json);
+        }
+        return json;
+    }
+    throw Error('invalid json version ' + json.version);
+}
+var currentVersion = '1.0';
+function getStandardJSONFromV0(json) {
+    var _a, _b;
+    currentVersion = '1.0';
+    var plugins = json.plugins || [];
+    if ((_a = json.bins) === null || _a === void 0 ? void 0 : _a.length) {
+        currentVersion = '1.3';
+    }
+    var requires = (json.requires || []).slice();
+    var images = json.images.map(function (img, index) { return getStandardImage(img, index, json.imageTags || []); });
+    var textures = json.textures || images.map(function (img, i) { return ({ source: i, flipY: true }); });
+    var ret = {
+        plugins: plugins,
+        shapes: json.shapes || [],
+        type: 'ge',
+        version: currentVersion,
+        playerVersion: (_b = json.playerVersion) !== null && _b !== void 0 ? _b : {
+            web: '',
+            native: '',
+        },
+        compositionId: json.compositionId + '',
+        compositions: json.compositions.map(function (comp) { return getStandardComposition(comp, { plugins: plugins, requires: requires }); }),
+        images: images,
+        imgUsage: json._imgs,
+        binUsage: json.binUsage,
+        spines: json.spines,
+        requires: json.requires,
+        textures: textures,
+        bins: (json.bins || []).slice(),
+    };
+    if (json._textures) {
+        ret._textures = json._textures;
+    }
+    return ret;
+}
+function getStandardImage(image, index, imageTags) {
+    var renderLevel = imageTags[index];
+    var oriY = image.oriY;
+    if (typeof image === 'string') {
+        return {
+            renderLevel: renderLevel,
+            url: image,
+            oriY: oriY,
+        };
+    }
+    else if (image.template) {
+        return {
+            url: image.url,
+            template: image.template,
+            webp: image.webp,
+            renderLevel: renderLevel,
+            oriY: oriY,
+        };
+    }
+    else if (image.compressed) {
+        return {
+            url: image.url,
+            oriY: oriY,
+            compressed: {
+                astc: image.compressed.android,
+                pvrtc: image.compressed.iOS,
+            },
+            webp: image.webp,
+            renderLevel: renderLevel,
+        };
+    }
+    else if (image.url) {
+        return {
+            url: image.url,
+            type: image.type,
+            webp: image.webp,
+            renderLevel: renderLevel,
+            oriY: oriY,
+            loop: image.loop,
+        };
+    }
+    else if (image && image.sourceType) {
+        return image;
+    }
+    throw Error('invalid image type');
+}
+function getStandardComposition(composition, opt) {
+    var _a;
+    if (opt === void 0) { opt = {}; }
+    var ret = {
+        id: composition.id + '',
+        camera: Object.assign({ clipMode: CAMERA_CLIP_MODE_NORMAL }, composition.camera),
+        duration: composition.duration,
+        endBehavior: composition.endBehavior,
+        items: composition.items.map(function (item) { return getStandardItem(item, opt); }),
+        name: composition.name,
+    };
+    var startTime = composition.startTime || composition.st;
+    if (startTime) {
+        ret.startTime = startTime;
+    }
+    var previewSize = (_a = composition.meta) === null || _a === void 0 ? void 0 : _a.previewSize;
+    if (previewSize && previewSize[0] === previewSize[1] && previewSize[0] === 0) {
+        previewSize = undefined;
+    }
+    if (previewSize) {
+        ret.previewSize = previewSize;
+    }
+    return ret;
+}
+var tempQuat = [0, 0, 0, 1];
+var stdAnchor = 0.5;
+function getStandardItem(item, opt) {
+    var _a, _b, _c;
+    if (opt === void 0) { opt = {}; }
+    var type = ItemType.base;
+    var transform;
+    var originContent;
+    var content;
+    var endBehavior = item.endBehavior;
+    var renderLevel;
+    var pluginName;
+    var duration = NaN;
+    var pn;
+    if (item.content) {
+        type = item.type || ItemType.plugin;
+        pn = item.pn;
+        pluginName = item.pluginName;
+        content = item.content;
+        originContent = item.content;
+        if (isNaN(pn) && !pluginName) {
+            pluginName = content.options.type;
+        }
+        if (item.duration) {
+            duration = item.duration;
+        }
+        transform = item.transform || getTransform(originContent.transform);
+        if (type === ItemType.filter) {
+            if (currentVersion < '1.1') {
+                currentVersion = '1.1';
+            }
+            content = getStandardSpriteContent(originContent, transform);
+            // @ts-expect-error
+            content.filter = getStandardFilterContent(originContent.filter);
+        }
+    }
+    else if (item.particle) {
+        type = ItemType.particle;
+        originContent = item.particle;
+        transform = getTransform(originContent.transform, reverseParticle, true);
+        content = getStandardParticleContent(originContent);
+    }
+    else if (item.sprite) {
+        type = ItemType.sprite;
+        originContent = item.sprite;
+        transform = getTransform(originContent.transform, false, true);
+        content = getStandardSpriteContent(originContent, transform);
+    }
+    else if (item.cal) {
+        type = ItemType.null;
+        originContent = item.cal;
+        transform = getTransform(originContent.transform, false, true);
+        content = getStandardNullContent(originContent, transform);
+    }
+    else if (item.ui) {
+        type = ItemType.interact;
+        originContent = item.ui;
+        transform = getTransform(originContent.transform);
+        content = getStandardInteractContent(originContent);
+        transform.scale = [originContent.options.width || 1, originContent.options.height || 1, 1];
+    }
+    else if (item.model) {
+        originContent = item.model;
+        if (item.model.options.type === 1) {
+            type = ItemType.camera;
+            transform = getTransform(originContent.transform);
+            content = getStandardCameraContent(originContent);
+        }
+    }
+    if ((_a = content.renderer) === null || _a === void 0 ? void 0 : _a.anchor) {
+        var anchor = new Float32Array(content.renderer.anchor);
+        if (anchor[0] == stdAnchor && anchor[1] == stdAnchor) {
+            delete content.renderer.anchor;
+        }
+        else if (opt.requires) {
+            arrAdd(opt.requires, 'anchor');
+        }
+    }
+    if (originContent) {
+        var looping = (_b = originContent.options) === null || _b === void 0 ? void 0 : _b.looping;
+        if (looping) {
+            if (Array.isArray(looping)) {
+                endBehavior = looping[1] ? ItemEndBehavior.loop : ItemEndBehavior.destroy;
+            }
+            else {
+                endBehavior = ItemEndBehavior.loop;
+            }
+        }
+        else {
+            endBehavior = endBehavior || ((_c = originContent === null || originContent === void 0 ? void 0 : originContent.options) === null || _c === void 0 ? void 0 : _c.endBehavior) || ItemEndBehavior.destroy;
+        }
+        if (originContent.options.renderLevel) {
+            renderLevel = originContent.options.renderLevel;
+        }
+        if (isNaN(duration)) {
+            duration = originContent.options.duration;
+        }
+    }
+    var ret = {
+        type: type,
+        name: item.name,
+        delay: item.delay,
+        duration: duration,
+        id: item.id + '',
+        // @ts-expect-error
+        transform: transform,
+        endBehavior: endBehavior,
+        // @ts-expect-error
+        renderLevel: renderLevel,
+        content: content,
+    };
+    // @ts-expect-error
+    if (pluginName) {
+        if (opt.plugins) {
+            arrAdd(opt.plugins, pluginName);
+            ret.pn = opt.plugins.indexOf(pluginName);
+        }
+        else {
+            ret.pluginName = pluginName;
+        }
+        // @ts-expect-error
+    }
+    else if (Number.isInteger(pn)) {
+        // @ts-expect-error
+        ret.pn = pn;
+    }
+    if (item.parentId) {
+        ret.parentId = item.parentId + '';
+    }
+    return ret;
+    function getTransform(originTransform, inverseRotation, changeOrder) {
+        if (originTransform) {
+            var transform_1 = {};
+            var rotation = originTransform.rotation;
+            if (rotation) {
+                if (inverseRotation) {
+                    transform_1.rotation = [-rotation[0], -rotation[1], -rotation[2]];
+                }
+                else {
+                    transform_1.rotation = [rotation[0], rotation[1], rotation[2]];
+                }
+                if (changeOrder) {
+                    var q = quatFromXYZRotation(tempQuat, transform_1.rotation[0], transform_1.rotation[1], transform_1.rotation[2]);
+                    transform_1.rotation = rotationZYXFromQuat([], q);
+                }
+            }
+            var position = originTransform.position;
+            if (position) {
+                transform_1.position = originTransform.position;
+            }
+            if (Array.isArray(originTransform.scale)) {
+                transform_1.scale = [originTransform.scale[0] || 1, originTransform.scale[1] || 1, originTransform.scale[2] || 1];
+            }
+            return transform_1;
+        }
+        return {};
+    }
+}
+
+exports.arrAdd = arrAdd;
+exports.colorToArr = colorToArr;
+exports.deleteEmptyValue = deleteEmptyValue;
+exports.ensureColorExpression = ensureColorExpression;
+exports.ensureFixedNumber = ensureFixedNumber;
+exports.ensureFixedNumberWithRandom = ensureFixedNumberWithRandom;
+exports.ensureFixedVec3 = ensureFixedVec3;
+exports.ensureGradient = ensureGradient;
+exports.ensureNumberExpression = ensureNumberExpression;
+exports.ensureRGBAValue = ensureRGBAValue;
+exports.ensureValueGetter = ensureValueGetter;
+exports.forEach = forEach;
+exports.getGradientColor = getGradientColor;
+exports.getStandardComposition = getStandardComposition;
+exports.getStandardImage = getStandardImage;
+exports.getStandardItem = getStandardItem;
+exports.getStandardJSON = getStandardJSON;
+exports.normalizeColor = normalizeColor;
+exports.objectValueToNumber = objectValueToNumber;
+exports.parsePercent = parsePercent;
+exports.quatFromXYZRotation = quatFromXYZRotation;
+exports.rotationZYXFromQuat = rotationZYXFromQuat;
+//# sourceMappingURL=fallback.js.map