@vvfx/shader2ge 0.0.1-beta.0

package/dist/index.js

@@ -0,0 +1,1915 @@
+/*!
+ * Name: @vvfx/shader2ge
+ * Description: Shader to Galacean Effects conversion engine
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 陈茉
+ * Version: v0.0.1-beta.0
+ */
+
+'use strict';
+
+/**
+ * JSON 版本
+ */ var JSONSceneVersion;
+(function(JSONSceneVersion) {
+    JSONSceneVersion["1_0"] = "1.0";
+    JSONSceneVersion["1_1"] = "1.1";
+    JSONSceneVersion["1_2"] = "1.2";
+    JSONSceneVersion["1_3"] = "1.3";
+    JSONSceneVersion["1_5"] = "1.5";
+    JSONSceneVersion["1_8"] = "1.8";
+    JSONSceneVersion["2_0"] = "2.0";
+    JSONSceneVersion["2_1"] = "2.1";
+    JSONSceneVersion["2_2"] = "2.2";
+    JSONSceneVersion["2_3"] = "2.3";
+    JSONSceneVersion["2_4"] = "2.4";
+    JSONSceneVersion["3_0"] = "3.0";
+    JSONSceneVersion["3_1"] = "3.1";
+    JSONSceneVersion["3_2"] = "3.2";
+    JSONSceneVersion["3_3"] = "3.3";
+    JSONSceneVersion["3_4"] = "3.4";
+    JSONSceneVersion["3_5"] = "3.5";
+    JSONSceneVersion["3_6"] = "3.6";
+    JSONSceneVersion["3_7"] = "3.7";
+    JSONSceneVersion["LATEST"] = "3.7";
+})(JSONSceneVersion || (JSONSceneVersion = {}));
+
+/*********************************************/ /*               元素属性参数类型               */ /*********************************************/ /**
+ * 渲染等级
+ */ 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 ObscuredMode;
+(function(ObscuredMode) {
+    /**
+     * 无
+     */ // NONE = 0,
+    // /**
+    //  * 蒙版
+    //  */
+    // MASK = 1,
+    /**
+     * 被遮挡
+     */ ObscuredMode[ObscuredMode["OBSCURED"] = 2] = "OBSCURED";
+    /**
+     * 被反向遮挡
+     */ ObscuredMode[ObscuredMode["REVERSE_OBSCURED"] = 3] = "REVERSE_OBSCURED";
+})(ObscuredMode || (ObscuredMode = {}));
+/**
+ * 发射器形状
+ */ var ParticleEmitterShapeType;
+(function(ParticleEmitterShapeType) {
+    /**
+     * 没有类型
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["NONE"] = 0] = "NONE";
+    /**
+     * 圆球
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["SPHERE"] = 1] = "SPHERE";
+    /**
+     * 圆锥
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["CONE"] = 2] = "CONE";
+    /**
+     * 半球
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["HEMISPHERE"] = 3] = "HEMISPHERE";
+    /**
+     * 圆
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["CIRCLE"] = 4] = "CIRCLE";
+    /**
+     * 圆环
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["DONUT"] = 5] = "DONUT";
+    /**
+     * 矩形
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["RECTANGLE"] = 6] = "RECTANGLE";
+    /**
+     * 矩形框
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["RECTANGLE_EDGE"] = 7] = "RECTANGLE_EDGE";
+    /**
+     * 直线
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["EDGE"] = 8] = "EDGE";
+    /**
+     * 贴图
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["TEXTURE"] = 9] = "TEXTURE";
+})(ParticleEmitterShapeType || (ParticleEmitterShapeType = {}));
+/**
+ * 插件类型
+ */ 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";
+    /**
+     * Spine 元素
+     */ ItemType["spine"] = "spine";
+    /**
+     * Mesh 元素
+     */ ItemType["mesh"] = "mesh";
+    /**
+     * 节点树元素
+     */ ItemType["tree"] = "tree";
+    /**
+     * 文本元素
+     */ ItemType["text"] = "text";
+    /**
+     * 灯光元素
+     */ ItemType["light"] = "light";
+    /**
+     * 天空盒元素
+     */ ItemType["skybox"] = "skybox";
+    /**
+     * 特效元素
+     */ ItemType["effect"] = "effect";
+    /**
+     * 形状元素
+     */ ItemType["shape"] = "shape";
+    /**
+     * 后处理元素
+     */ ItemType["postProcessVolume"] = "postProcessVolume";
+    /**
+     * 节点元素
+     */ ItemType["node"] = "node";
+    /**
+     * 视频元素
+     */ ItemType["video"] = "video";
+    /**
+     * 音频元素
+     */ ItemType["audio"] = "audio";
+    /**
+     * 富文本元素
+     */ ItemType["richtext"] = "richtext";
+})(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 RenderType;
+(function(RenderType) {
+    RenderType["Opaque"] = "Opaque";
+    RenderType["Transparent"] = "Transparent";
+})(RenderType || (RenderType = {}));
+var RenderFace;
+(function(RenderFace) {
+    RenderFace["Both"] = "Both";
+    RenderFace["Back"] = "Back";
+    RenderFace["Front"] = "Front";
+})(RenderFace || (RenderFace = {}));
+
+/**
+ * 销毁
+ */ var END_BEHAVIOR_DESTROY = 0;
+/**
+ * 暂停
+ * @deprecated since 2.0 - use `END_BEHAVIOR_FREEZE` instead
+ */ var END_BEHAVIOR_PAUSE = 1;
+/**
+ * 无限播放
+ */ var END_BEHAVIOR_FORWARD = 2;
+/**
+ * 销毁并保留最后一帧
+ * @deprecated since 2.0
+ */ 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 MESSAGE_ITEM_PHRASE_BEGIN = 2;
+/**
+ * 消息结束
+ */ var MESSAGE_ITEM_PHRASE_END = 1;
+
+var CameraClipMode;
+(function(CameraClipMode) {
+    /**
+     * 剪裁上下
+     */ CameraClipMode[CameraClipMode["portrait"] = 1] = "portrait";
+    /**
+     * 剪裁左右
+     */ CameraClipMode[CameraClipMode["landscape"] = 0] = "landscape";
+})(CameraClipMode || (CameraClipMode = {}));
+
+/*********************************************/ /*               基本数值属性参数              */ /*********************************************/ 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";
+    /**
+     * 曲线（Hermite 曲线）
+     * @deprecated 使用 BEZIER_CURVE 替代，此类型仅用于旧数据迁移兼容
+     */ ValueType[ValueType["CURVE"] = 6] = "CURVE";
+    /**
+     * 贝塞尔路径
+     * @deprecated 使用 BEZIER_CURVE_PATH 替代，此类型仅用于旧数据迁移兼容
+     */ 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["BEZIER_CURVE_QUAT"] = 23] = "BEZIER_CURVE_QUAT";
+    /**
+     * 颜色曲线
+     */ ValueType[ValueType["COLOR_CURVE"] = 24] = "COLOR_CURVE";
+    /**
+     * Vector4 曲线
+     */ ValueType[ValueType["VECTOR4_CURVE"] = 25] = "VECTOR4_CURVE";
+    /**
+     * Vector2 曲线
+     */ ValueType[ValueType["VECTOR2_CURVE"] = 26] = "VECTOR2_CURVE";
+    /**
+     * Vector3 曲线
+     */ ValueType[ValueType["VECTOR3_CURVE"] = 27] = "VECTOR3_CURVE";
+})(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 EndBehavior;
+(function(EndBehavior) {
+    /**
+     * 销毁
+     */ EndBehavior[EndBehavior["destroy"] = 0] = "destroy";
+    /**
+     * 重播
+     */ EndBehavior[EndBehavior["restart"] = 5] = "restart";
+    /**
+     * 无限播放
+     */ EndBehavior[EndBehavior["forward"] = 2] = "forward";
+    /**
+     * 冻结
+     */ EndBehavior[EndBehavior["freeze"] = 4] = "freeze";
+})(EndBehavior || (EndBehavior = {}));
+
+/**
+ * 粒子交互行为
+ */ 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 LightType;
+(function(LightType) {
+    /**
+     * 点光源
+     */ LightType["point"] = "point";
+    /**
+     * 聚光灯
+     */ LightType["spot"] = "spot";
+    /**
+     * 方向光
+     */ LightType["directional"] = "directional";
+    /**
+     * 环境光
+     */ LightType["ambient"] = "ambient";
+})(LightType || (LightType = {}));
+
+var ModelBoundingType;
+(function(ModelBoundingType) {
+    ModelBoundingType[ModelBoundingType["box"] = 2] = "box";
+    ModelBoundingType[ModelBoundingType["sphere"] = 3] = "sphere";
+})(ModelBoundingType || (ModelBoundingType = {}));
+
+var CameraType;
+(function(CameraType) {
+    CameraType["orthographic"] = "orthographic";
+    CameraType["perspective"] = "perspective";
+})(CameraType || (CameraType = {}));
+
+// 材质类型
+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["diffuse"] = "diffuse";
+})(RenderMode3D || (RenderMode3D = {}));
+
+var TextOverflow;
+(function(TextOverflow) {
+    /**
+     * visible 模式下，文本内容超出边界框时，会继续显示内容，不进行裁剪或缩放。
+     */ TextOverflow[TextOverflow["visible"] = 0] = "visible";
+    /**
+     * display 模式下，会显示所有文本，文本字号大小会根据边界框调整。
+     */ TextOverflow[TextOverflow["display"] = 1] = "display";
+    /**
+     * clip 模式下，当文本内容超出边界框时，多余的会被截断。
+     */ TextOverflow[TextOverflow["clip"] = 2] = "clip";
+    /**
+     * ellipsis 模式下，会使用（...）来代替超出边界框的内容。
+     */ TextOverflow[TextOverflow["ellipsis"] = 3] = "ellipsis";
+})(TextOverflow || (TextOverflow = {}));
+var TextSizeMode;
+(function(TextSizeMode) {
+    /**
+     * 自适应宽度
+     */ TextSizeMode[TextSizeMode["autoWidth"] = 0] = "autoWidth";
+    /**
+     * 自适应高度
+     */ TextSizeMode[TextSizeMode["autoHeight"] = 1] = "autoHeight";
+    /**
+     * 固定宽高
+     */ TextSizeMode[TextSizeMode["fixed"] = 2] = "fixed";
+})(TextSizeMode || (TextSizeMode = {}));
+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 TextVerticalAlign;
+(function(TextVerticalAlign) {
+    /**
+     * 文本顶对齐。
+     */ TextVerticalAlign[TextVerticalAlign["top"] = 0] = "top";
+    /**
+     * 文本垂直居中对齐。
+     */ TextVerticalAlign[TextVerticalAlign["middle"] = 1] = "middle";
+    /**
+     * 文本底对齐。
+     */ TextVerticalAlign[TextVerticalAlign["bottom"] = 2] = "bottom";
+})(TextVerticalAlign || (TextVerticalAlign = {}));
+/**
+ * 文本字重
+ */ 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 = {}));
+
+var BuiltinObjectGUID = {
+    WhiteTexture: 'whitetexture00000000000000000000',
+    EmptyTexture: 'emptyTexture00000000000000000000',
+    PBRShader: 'pbr00000000000000000000000000000',
+    UnlitShader: 'unlit000000000000000000000000000'
+};
+
+var FillType;
+(function(FillType) {
+    FillType[FillType["Solid"] = 0] = "Solid";
+    FillType[FillType["GradientLinear"] = 1] = "GradientLinear";
+    FillType[FillType["GradientRadial"] = 2] = "GradientRadial";
+    FillType[FillType["GradientAngular"] = 3] = "GradientAngular";
+    FillType[FillType["Texture"] = 4] = "Texture";
+})(FillType || (FillType = {}));
+var TexturePaintScaleMode;
+(function(TexturePaintScaleMode) {
+    TexturePaintScaleMode[TexturePaintScaleMode["Fill"] = 0] = "Fill";
+    TexturePaintScaleMode[TexturePaintScaleMode["Fit"] = 1] = "Fit";
+    TexturePaintScaleMode[TexturePaintScaleMode["Crop"] = 2] = "Crop";
+    TexturePaintScaleMode[TexturePaintScaleMode["Tile"] = 3] = "Tile";
+})(TexturePaintScaleMode || (TexturePaintScaleMode = {}));
+
+/**
+ * 矢量图形类型
+ */ var ShapePrimitiveType;
+(function(ShapePrimitiveType) {
+    /**
+     * 自定义图形
+     */ ShapePrimitiveType[ShapePrimitiveType["Custom"] = 0] = "Custom";
+    /**
+     * 矩形
+     */ ShapePrimitiveType[ShapePrimitiveType["Rectangle"] = 1] = "Rectangle";
+    /**
+     * 椭圆
+     */ ShapePrimitiveType[ShapePrimitiveType["Ellipse"] = 2] = "Ellipse";
+    /**
+     * 多边形
+     */ ShapePrimitiveType[ShapePrimitiveType["Polygon"] = 3] = "Polygon";
+    /**
+     * 星形
+     */ ShapePrimitiveType[ShapePrimitiveType["Star"] = 4] = "Star";
+})(ShapePrimitiveType || (ShapePrimitiveType = {}));
+
+var LineCap;
+(function(LineCap) {
+    /** 默认值。向线条的每个末端添加平直的边缘 */ LineCap[LineCap["Butt"] = 0] = "Butt";
+    /** 向线条的每个末端添加圆形线帽 */ LineCap[LineCap["Round"] = 1] = "Round";
+    /** 向线条的每个末端添加正方形线帽 */ LineCap[LineCap["Square"] = 2] = "Square";
+})(LineCap || (LineCap = {}));
+var LineJoin;
+(function(LineJoin) {
+    /** 创建圆角 */ LineJoin[LineJoin["Round"] = 0] = "Round";
+    /** 创建斜角 */ LineJoin[LineJoin["Bevel"] = 1] = "Bevel";
+    /** 创建尖角 */ LineJoin[LineJoin["Miter"] = 2] = "Miter";
+})(LineJoin || (LineJoin = {}));
+
+var NodeDataType;
+(function(NodeDataType) {
+    NodeDataType["AnimationClipNodeData"] = "AnimationClipNodeData";
+    NodeDataType["BlendNodeData"] = "BlendNodeData";
+    NodeDataType["ApplyAdditiveNodeData"] = "ApplyAdditiveNodeData";
+    NodeDataType["LayerBlendNodeData"] = "LayerBlendNodeData";
+    NodeDataType["StateMachineNodeData"] = "StateMachineNodeData";
+    NodeDataType["TransitionNodeData"] = "TransitionNodeData";
+    NodeDataType["StateNodeData"] = "StateNodeData";
+    NodeDataType["ConstFloatNodeData"] = "ConstFloatNodeData";
+    NodeDataType["ConstBoolNodeData"] = "ConstBoolNodeData";
+    NodeDataType["ControlParameterBoolNodeData"] = "ControlParameterBoolNodeData";
+    NodeDataType["ControlParameterFloatNodeData"] = "ControlParameterFloatNodeData";
+    NodeDataType["ControlParameterTriggerNodeData"] = "ControlParameterTriggerNodeData";
+    NodeDataType["NotNodeData"] = "NotNodeData";
+    NodeDataType["AndNodeData"] = "AndNodeData";
+    NodeDataType["OrNodeData"] = "OrNodeData";
+    NodeDataType["EqualNodeData"] = "EqualNodeData";
+    NodeDataType["GreaterNodeData"] = "GreaterNodeData";
+    NodeDataType["LessNodeData"] = "LessNodeData";
+})(NodeDataType || (NodeDataType = {}));
+
+/**
+ * 动态换图类型
+ * @since 1.1.0
+ */ var BackgroundType;
+(function(BackgroundType) {
+    BackgroundType["video"] = "video";
+    BackgroundType["image"] = "image";
+})(BackgroundType || (BackgroundType = {}));
+/**
+ * 多媒体资源类型
+ * @since 2.1.0
+ */ var MultimediaType;
+(function(MultimediaType) {
+    MultimediaType["video"] = "video";
+    MultimediaType["audio"] = "audio";
+})(MultimediaType || (MultimediaType = {}));
+var HevcVideoCodec;
+(function(HevcVideoCodec) {
+    HevcVideoCodec["L30"] = "hev1.1.0.L30.B0";
+    HevcVideoCodec["L60"] = "hev1.1.0.L60.B0";
+    HevcVideoCodec["L63"] = "hev1.1.0.L63.B0";
+    HevcVideoCodec["L90"] = "hev1.1.0.L90.B0";
+    HevcVideoCodec["L93"] = "hev1.1.0.L93.B0";
+    HevcVideoCodec["L120"] = "hev1.1.0.L120.B0";
+    HevcVideoCodec["L150"] = "hev1.1.0.L150.B0";
+    HevcVideoCodec["L180"] = "hev1.1.0.L180.B0";
+})(HevcVideoCodec || (HevcVideoCodec = {}));
+
+var DataType;
+(function(DataType) {
+    DataType["VFXItemData"] = "VFXItemData";
+    // Assets
+    DataType["Material"] = "Material";
+    DataType["Shader"] = "Shader";
+    DataType["Geometry"] = "Geometry";
+    DataType["Texture"] = "Texture";
+    DataType["Image"] = "Image";
+    DataType["AnimationClip"] = "AnimationClip";
+    DataType["BinaryAsset"] = "BinaryAsset";
+    // Timeline
+    DataType["TrackAsset"] = "TrackAsset";
+    DataType["TimelineAsset"] = "TimelineAsset";
+    DataType["ObjectBindingTrack"] = "ObjectBindingTrack";
+    DataType["TransformTrack"] = "TransformTrack";
+    DataType["SpriteColorTrack"] = "SpriteColorTrack";
+    DataType["ActivationTrack"] = "ActivationTrack";
+    DataType["SubCompositionTrack"] = "SubCompositionTrack";
+    DataType["FloatPropertyTrack"] = "FloatPropertyTrack";
+    DataType["ColorPropertyTrack"] = "ColorPropertyTrack";
+    DataType["Vector2PropertyTrack"] = "Vector2PropertyTrack";
+    DataType["Vector3PropertyTrack"] = "Vector3PropertyTrack";
+    DataType["Vector4PropertyTrack"] = "Vector4PropertyTrack";
+    DataType["TransformPlayableAsset"] = "TransformPlayableAsset";
+    DataType["SpriteColorPlayableAsset"] = "SpriteColorPlayableAsset";
+    DataType["ActivationPlayableAsset"] = "ActivationPlayableAsset";
+    DataType["SubCompositionPlayableAsset"] = "SubCompositionPlayableAsset";
+    DataType["FloatPropertyPlayableAsset"] = "FloatPropertyPlayableAsset";
+    DataType["ColorPropertyPlayableAsset"] = "ColorPropertyPlayableAsset";
+    DataType["Vector2PropertyPlayableAsset"] = "Vector2PropertyPlayableAsset";
+    DataType["Vector3PropertyPlayableAsset"] = "Vector3PropertyPlayableAsset";
+    DataType["Vector4PropertyPlayableAsset"] = "Vector4PropertyPlayableAsset";
+    // Components
+    DataType["MeshComponent"] = "MeshComponent";
+    DataType["SkyboxComponent"] = "SkyboxComponent";
+    DataType["LightComponent"] = "LightComponent";
+    DataType["CameraComponent"] = "CameraComponent";
+    DataType["ModelPluginComponent"] = "ModelPluginComponent";
+    DataType["TreeComponent"] = "TreeComponent";
+    DataType["AnimationComponent"] = "AnimationComponent";
+    DataType["SpineComponent"] = "SpineComponent";
+    DataType["VideoComponent"] = "VideoComponent";
+    DataType["AudioComponent"] = "AudioComponent";
+    DataType["RichTextComponent"] = "RichTextComponent";
+    DataType["OrientationComponent"] = "OrientationComponent";
+    DataType["ShapeComponent"] = "ShapeComponent";
+    DataType["SpriteComponent"] = "SpriteComponent";
+    DataType["ParticleSystem"] = "ParticleSystem";
+    DataType["InteractComponent"] = "InteractComponent";
+    DataType["CameraController"] = "CameraController";
+    DataType["PostProcessVolume"] = "PostProcessVolume";
+    DataType["EffectComponent"] = "EffectComponent";
+    DataType["TextComponent"] = "TextComponent";
+    DataType["AnimationGraphAsset"] = "AnimationGraphAsset";
+    DataType["CompositionComponent"] = "CompositionComponent";
+    DataType["FFDComponent"] = "FFDComponent";
+    DataType["FrameComponent"] = "FrameComponent";
+    DataType["Animator"] = "Animator";
+    // Non-EffectObject
+    DataType["TimelineClip"] = "TimelineClip";
+})(DataType || (DataType = {}));
+
+var GeometryType;
+(function(GeometryType) {
+    /**
+     * Draw single points.
+     */ GeometryType[GeometryType["POINTS"] = 0] = "POINTS";
+    /**
+     * Draw lines. Each vertex connects to the one after it.
+     */ GeometryType[GeometryType["LINES"] = 1] = "LINES";
+    /**
+     * Draw lines. Each set of two vertices is treated as a separate line segment.
+     */ GeometryType[GeometryType["LINE_LOOP"] = 2] = "LINE_LOOP";
+    /**
+     * Draw a connected group of line segments from the first vertex to the last.
+     */ GeometryType[GeometryType["LINE_STRIP"] = 3] = "LINE_STRIP";
+    /**
+     * Draw triangles. Each set of three vertices creates a separate triangle.
+     */ GeometryType[GeometryType["TRIANGLES"] = 4] = "TRIANGLES";
+    /**
+     * Draw a connected strip of triangles.
+     */ GeometryType[GeometryType["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    /**
+     * Draw a connected group of triangles. Each vertex connects to the previous and the first vertex in the fan.
+     */ GeometryType[GeometryType["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+})(GeometryType || (GeometryType = {}));
+var VertexFormatType;
+(function(VertexFormatType) {
+    VertexFormatType[VertexFormatType["Float16"] = 0] = "Float16";
+    VertexFormatType[VertexFormatType["Float32"] = 1] = "Float32";
+    VertexFormatType[VertexFormatType["Int8"] = 2] = "Int8";
+    VertexFormatType[VertexFormatType["Int16"] = 3] = "Int16";
+    VertexFormatType[VertexFormatType["Int32"] = 4] = "Int32";
+    VertexFormatType[VertexFormatType["UInt8"] = 5] = "UInt8";
+    VertexFormatType[VertexFormatType["UInt16"] = 6] = "UInt16";
+    VertexFormatType[VertexFormatType["UInt32"] = 7] = "UInt32";
+})(VertexFormatType || (VertexFormatType = {}));
+var IndexFormatType;
+(function(IndexFormatType) {
+    IndexFormatType[IndexFormatType["None"] = -1] = "None";
+    IndexFormatType[IndexFormatType["UInt8"] = 0] = "UInt8";
+    IndexFormatType[IndexFormatType["UInt16"] = 1] = "UInt16";
+    IndexFormatType[IndexFormatType["UInt32"] = 2] = "UInt32";
+})(IndexFormatType || (IndexFormatType = {}));
+// BINORMAL[n]	Binormal	float4
+// BLENDINDICES[n]	混合索引	uint
+// BLENDWEIGHT[n]	混合权重	FLOAT
+// COLOR[n]	漫射和反射颜色	float4
+// NORMAL[n]	法向矢量	float4
+// POSITION[n]	对象空间中的顶点位置。	float4
+// POSITIONT	变换的顶点位置。	float4
+// PSIZE[n]	点大小	FLOAT
+// TANGENT[n]	正切	float4
+// TEXCOORD[n]	纹理坐标	float4
+// POSITION_BS[n]	Blend Shape 空间中的顶点位置	float4
+// NORMAL_BS[n]	Blend Shape 空间中的法向矢量	float4
+// TANGENT_BS[n]	Blend Shape 空间中的正切矢量	float4
+var VertexBufferSemantic;
+(function(VertexBufferSemantic) {
+    VertexBufferSemantic["Position"] = "POSITION";
+    VertexBufferSemantic["Uv"] = "TEXCOORD0";
+    VertexBufferSemantic["Uv2"] = "TEXCOORD1";
+    VertexBufferSemantic["Normal"] = "NORMAL";
+    VertexBufferSemantic["Tangent"] = "TANGENT";
+    VertexBufferSemantic["Color"] = "COLOR";
+    VertexBufferSemantic["Joints"] = "JOINTS";
+    VertexBufferSemantic["Weights"] = "WEIGHTS";
+    //
+    VertexBufferSemantic["PositionBS0"] = "POSITION_BS0";
+    VertexBufferSemantic["PositionBS1"] = "POSITION_BS1";
+    VertexBufferSemantic["PositionBS2"] = "POSITION_BS2";
+    VertexBufferSemantic["PositionBS3"] = "POSITION_BS3";
+    VertexBufferSemantic["PositionBS4"] = "POSITION_BS4";
+    VertexBufferSemantic["PositionBS5"] = "POSITION_BS5";
+    VertexBufferSemantic["PositionBS6"] = "POSITION_BS6";
+    VertexBufferSemantic["PositionBS7"] = "POSITION_BS7";
+    VertexBufferSemantic["NormalBS0"] = "NORMAL_BS0";
+    VertexBufferSemantic["NormalBS1"] = "NORMAL_BS1";
+    VertexBufferSemantic["NormalBS2"] = "NORMAL_BS2";
+    VertexBufferSemantic["NormalBS3"] = "NORMAL_BS3";
+    VertexBufferSemantic["TangentBS0"] = "TANGENT_BS0";
+    VertexBufferSemantic["TangentBS1"] = "TANGENT_BS1";
+    VertexBufferSemantic["TangentBS2"] = "TANGENT_BS2";
+    VertexBufferSemantic["TangentBS3"] = "TANGENT_BS3";
+})(VertexBufferSemantic || (VertexBufferSemantic = {}));
+
+var LATEST_VERSION = JSONSceneVersion.LATEST;
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get BackgroundType () { return BackgroundType; },
+    get BezierKeyframeType () { return BezierKeyframeType; },
+    get BlendingMode () { return BlendingMode; },
+    BuiltinObjectGUID: BuiltinObjectGUID,
+    CAMERA_CLIP_MODE_NORMAL: CAMERA_CLIP_MODE_NORMAL,
+    CAMERA_CLIP_MODE_VERTICAL: CAMERA_CLIP_MODE_VERTICAL,
+    get CameraClipMode () { return CameraClipMode; },
+    get CameraType () { return CameraType; },
+    get DataType () { return DataType; },
+    END_BEHAVIOR_DESTROY: END_BEHAVIOR_DESTROY,
+    END_BEHAVIOR_DESTROY_CHILDREN: END_BEHAVIOR_DESTROY_CHILDREN,
+    END_BEHAVIOR_FORWARD: END_BEHAVIOR_FORWARD,
+    END_BEHAVIOR_FREEZE: END_BEHAVIOR_FREEZE,
+    END_BEHAVIOR_PAUSE: END_BEHAVIOR_PAUSE,
+    END_BEHAVIOR_PAUSE_AND_DESTROY: END_BEHAVIOR_PAUSE_AND_DESTROY,
+    END_BEHAVIOR_RESTART: END_BEHAVIOR_RESTART,
+    get EndBehavior () { return EndBehavior; },
+    get FillType () { return FillType; },
+    get FontStyle () { return FontStyle; },
+    get GeometryType () { return GeometryType; },
+    get HevcVideoCodec () { return HevcVideoCodec; },
+    get IndexFormatType () { return IndexFormatType; },
+    get InteractBehavior () { return InteractBehavior; },
+    get InteractType () { return InteractType; },
+    get ItemType () { return ItemType; },
+    get JSONSceneVersion () { return JSONSceneVersion; },
+    LATEST_VERSION: LATEST_VERSION,
+    get LightType () { return LightType; },
+    get LineCap () { return LineCap; },
+    get LineJoin () { return LineJoin; },
+    MESSAGE_ITEM_PHRASE_BEGIN: MESSAGE_ITEM_PHRASE_BEGIN,
+    MESSAGE_ITEM_PHRASE_END: MESSAGE_ITEM_PHRASE_END,
+    get MaterialBlending () { return MaterialBlending; },
+    get MaterialType () { return MaterialType; },
+    get ModelBoundingType () { return ModelBoundingType; },
+    get MultimediaType () { return MultimediaType; },
+    get NodeDataType () { return NodeDataType; },
+    get ObscuredMode () { return ObscuredMode; },
+    get ParticleEmitterShapeType () { return ParticleEmitterShapeType; },
+    get ParticleInteractionBehavior () { return ParticleInteractionBehavior; },
+    get ParticleOrigin () { return ParticleOrigin; },
+    get PluginType () { return PluginType; },
+    get RenderFace () { return RenderFace; },
+    get RenderLevel () { return RenderLevel; },
+    get RenderMode () { return RenderMode; },
+    get RenderMode3D () { return RenderMode3D; },
+    get RenderType () { return RenderType; },
+    get ShapeArcMode () { return ShapeArcMode; },
+    get ShapePrimitiveType () { return ShapePrimitiveType; },
+    get SideMode () { return SideMode; },
+    get TextAlignment () { return TextAlignment; },
+    get TextBaseline () { return TextBaseline; },
+    get TextOverflow () { return TextOverflow; },
+    get TextSizeMode () { return TextSizeMode; },
+    get TextVerticalAlign () { return TextVerticalAlign; },
+    get TextWeight () { return TextWeight; },
+    get TexturePaintScaleMode () { return TexturePaintScaleMode; },
+    get ValueType () { return ValueType; },
+    get VertexBufferSemantic () { return VertexBufferSemantic; },
+    get VertexFormatType () { return VertexFormatType; }
+});
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike) {
+        if (it) o = it;
+        var i = 0;
+        return function() {
+            if (i >= o.length) return {
+                done: true
+            };
+            return {
+                done: false,
+                value: o[i++]
+            };
+        };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var SUPPORTED_TYPES = new Set([
+    'float',
+    'vec2',
+    'vec3',
+    'vec4',
+    'int',
+    'sampler2D'
+]);
+/**
+ * 匹配 uniform 声明，支持行尾 // 注释
+ * 示例：
+ *   uniform float uTime; // 时间
+ *   uniform vec4 uColor;
+ */ var UNIFORM_REGEX = /^\s*uniform\s+(float|vec2|vec3|vec4|int|sampler2D)\s+(\w+)\s*;(?:\s*\/\/\s*(.*))?/gm;
+/**
+ * 从 fragment shader 源码中提取所有 uniform 声明
+ */ function parseUniforms(source) {
+    var results = [];
+    var seen = new Set();
+    var match;
+    // 重置 lastIndex 以防复用
+    UNIFORM_REGEX.lastIndex = 0;
+    while((match = UNIFORM_REGEX.exec(source)) !== null){
+        var typeStr = match[1], name = match[2], comment = match[3];
+        if (!SUPPORTED_TYPES.has(typeStr)) {
+            continue;
+        }
+        // 跳过重复声明
+        if (seen.has(name)) {
+            continue;
+        }
+        seen.add(name);
+        results.push(_extends({
+            name: name,
+            type: typeStr
+        }, (comment == null ? void 0 : comment.trim()) ? {
+            comment: comment.trim()
+        } : {}));
+    }
+    return results;
+}
+
+/**
+ * 固定模板：vertex shader 和全屏 Quad 几何体数据
+ */ /**
+ * 全屏四边形的固定 vertex shader
+ * 传递 Position 和 UV 给 fragment shader
+ */ /**
+ * GE EffectComponent 每帧自动设置 _Time (vec4):
+ *   _Time = vec4(time/20, time, time*2, time*3)
+ * 其中 _Time.y 就是经过的秒数。
+ *
+ * 通过 varying vTime 传递给 fragment shader，
+ * convert 阶段会在用户的 fragment shader 头部注入：
+ *   float uTime = vTime;
+ * 从而让用户直接使用 uTime 驱动动画。
+ */ var DEFAULT_VERTEX_SHADER = "\nprecision highp float;\nattribute vec3 aPos;\nattribute vec2 aUV;\nuniform vec4 _Time;\nvarying vec2 vUV;\nvarying float vTime;\n\nvoid main () {\n  vUV = aUV;\n  vTime = _Time.y;\n  gl_Position = vec4(aPos, 1.0);\n}\n".trim();
+/**
+ * Shadertoy 兼容的 vertex shader
+ *
+ * 在标准 vertex shader 基础上增加：
+ * - uniform vec3 iResolution：视口分辨率，由 previewSize 填充
+ *   直接 pass-through 给 fragment shader（flat varying 不可用于 ES1.0，
+ *   因此在 fragment shader 中声明为 uniform，vertex shader 也需声明）
+ *
+ * 注：iResolution 由 convert 层自动添加到 material 的 vector4s 中
+ */ var SHADERTOY_VERTEX_SHADER = "\nprecision highp float;\nattribute vec3 aPos;\nattribute vec2 aUV;\nuniform vec4 _Time;\nvarying vec2 vUV;\nvarying float vTime;\n\nvoid main () {\n  vUV = aUV;\n  vTime = _Time.y;\n  gl_Position = vec4(aPos, 1.0);\n}\n".trim();
+/**
+ * 示例 fragment shader（渐变色），用于调试和兜底
+ */ var FALLBACK_FRAGMENT_SHADER = "\nprecision highp float;\nvarying vec2 vUV;\nuniform float uTime;\n\nvoid main () {\n  vec3 color = 0.5 + 0.5 * cos(uTime + vUV.xyx + vec3(0.0, 2.0, 4.0));\n  gl_FragColor = vec4(color, 1.0);\n}\n".trim();
+/**
+ * 全屏 Quad 的顶点数据（NDC 空间 -1~1，2个三角形组成矩形）
+ *
+ * 分离布局（GE Runtime 按连续块读取每个 channel）：
+ *   [Position x 4] [UV x 4] [Indices]
+ *
+ * 字节布局：
+ *   Position: 4 vertices * 3 floats * 4 bytes = 48 bytes (offset 0)
+ *   UV:       4 vertices * 2 floats * 4 bytes = 32 bytes (offset 48)
+ *   Indices:  6 indices  * 2 bytes            = 12 bytes (offset 80)
+ */ var QUAD_POSITIONS = new Float32Array([
+    -1,
+    -1,
+    0,
+    1,
+    -1,
+    0,
+    1,
+    1,
+    0,
+    -1,
+    1,
+    0
+]);
+var QUAD_UVS = new Float32Array([
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1
+]);
+var QUAD_INDICES = new Uint16Array([
+    0,
+    1,
+    2,
+    0,
+    2,
+    3
+]);
+/** Position 块字节大小 */ var POSITION_BYTES = QUAD_POSITIONS.byteLength; // 48
+/** UV 块字节偏移（紧跟 Position 之后） */ var UV_OFFSET = POSITION_BYTES; // 48
+/** Index 块字节偏移（紧跟 UV 之后） */ var INDEX_OFFSET = POSITION_BYTES + QUAD_UVS.byteLength; // 80
+/**
+ * 将 Quad 数据编码为纯 base64 字符串（用于 GeometryData.buffer）
+ *
+ * GE Runtime 的 decodeBase64ToArrays 直接对该字符串调用 atob，
+ * 不会处理 data URI 前缀，因此此处只返回纯 base64。
+ *
+ * 内存布局：[Position(48B)] [UV(32B)] [Index(12B)] = 92 bytes
+ */ function encodeQuadBuffer() {
+    var totalBytes = POSITION_BYTES + QUAD_UVS.byteLength + QUAD_INDICES.byteLength;
+    var buffer = new ArrayBuffer(totalBytes);
+    var view = new Uint8Array(buffer);
+    view.set(new Uint8Array(QUAD_POSITIONS.buffer), 0);
+    view.set(new Uint8Array(QUAD_UVS.buffer), UV_OFFSET);
+    view.set(new Uint8Array(QUAD_INDICES.buffer), INDEX_OFFSET);
+    var binaryString = Array.from(view, function(byte) {
+        return String.fromCharCode(byte);
+    }).join('');
+    return btoa(binaryString);
+}
+// ─── 默认纹理资源 ───
+/**
+ * 1×1 白色 PNG（base64 data URI）
+ *
+ * 当 sampler2D uniform 未提供纹理时，使用此默认白色纹理，
+ * 避免 shader 采样到黑色/无效区域。
+ *
+ * 这是一个合法的 1x1 像素 RGBA (255,255,255,255) PNG 文件。
+ */ var DEFAULT_WHITE_TEXTURE_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==';
+/** GL 纹理参数常量 */ var GL_TEXTURE_WRAP_REPEAT = 10497;
+var GL_TEXTURE_WRAP_CLAMP_TO_EDGE = 33071;
+var GL_TEXTURE_FILTER_LINEAR = 9729;
+var GL_TEXTURE_FILTER_NEAREST = 9728;
+var GL_TEXTURE_2D = 3553;
+
+/**
+ * 将 fragment shader 源码解析为中间表示（IR）。
+ *
+ * 该函数与 ConvertOptions 完全无关——所有依赖外部参数的逻辑（uniformOverrides、
+ * previewSize 注入、sampler2D 纹理告警等）由 {@link convert} 接力处理。
+ *
+ * 适用于不需要生成完整 JSONScene、只想检视 shader 结构的场景，例如：
+ * - AI 生成 shader 后预检 warnings 决定是否重试
+ * - UI 中展示 uniform 列表 / 是否 Shadertoy / 静态校验信息
+ * - 测试或调试时单独验证桥接行为
+ *
+ * @param source - 原始 GLSL fragment shader 源码（GE 原生格式或 Shadertoy 格式皆可）
+ * @returns 解析后的中间表示，包含桥接后的最终源码、uniform 列表、是否为 Shadertoy、警告列表
+ */ function parseShader(source) {
+    var warnings = [];
+    var fragment = source.trim();
+    // 空 shader 兜底
+    if (!fragment) {
+        warnings.push('Empty fragment shader provided, using fallback gradient shader.');
+        fragment = FALLBACK_FRAGMENT_SHADER;
+    }
+    // Shadertoy 兼容桥接（必须在基础校验之前，因为桥接会注入 main() 和 gl_FragColor）
+    var isShadertoy = /void\s+mainImage\s*\(\s*out\s+vec4/.test(fragment);
+    if (isShadertoy) {
+        fragment = bridgeShadertoy(fragment);
+    }
+    validateMainAndColorOutput(fragment, warnings);
+    // 解析 uniform（对桥接后的源码解析，以获取正确的 uniform 列表）
+    var uniforms = parseUniforms(fragment);
+    // uTime 自动桥接：将用户的 `uniform float uTime` 替换为从 vertex shader 传入的 varying
+    // GE EffectComponent 每帧自动设置 _Time (vec4)，vertex shader 已将 _Time.y 传为 vTime
+    var hasUTime = uniforms.some(function(u) {
+        return u.name === 'uTime' && u.type === 'float';
+    });
+    if (hasUTime) {
+        fragment = bridgeUTime(fragment);
+        // uTime 已由 GE _Time 驱动，从 uniform 列表中移除，避免写入 material floats
+        var uTimeIndex = uniforms.findIndex(function(u) {
+            return u.name === 'uTime';
+        });
+        if (uTimeIndex !== -1) {
+            uniforms.splice(uTimeIndex, 1);
+        }
+    }
+    return {
+        fragment: fragment,
+        uniforms: uniforms,
+        isShadertoy: isShadertoy,
+        warnings: warnings
+    };
+}
+/**
+ * 将 Shadertoy 格式的 shader 转换为 GE 兼容格式
+ *
+ * 处理内容：
+ * - 注入 precision、varying vUV、varying vTime 声明
+ * - 桥接 iTime → vTime、iResolution → uniform vec4
+ * - iChannel0~3 保留为 sampler2D uniform（由纹理系统处理）
+ * - 将 mainImage(out vec4, in vec2) 包装为 void main()
+ * - fragCoord 通过 vUV * iResolution.xy 推导
+ */ function bridgeShadertoy(source) {
+    // 移除用户可能写的 precision 声明，统一由桥接头注入
+    var body = source.replace(/^\s*precision\s+\w+\s+float\s*;\s*$/gm, '');
+    // 移除已有的 #version 声明（GE 不支持）
+    body = body.replace(/^\s*#version\s+.*$/gm, '');
+    // 移除已有的 iChannel uniform 声明（Shadertoy 用户有时会手动写，但 Shadertoy 运行时会自动注入，
+    // 这里统一由桥接层管理，避免重复声明）
+    body = body.replace(/^\s*uniform\s+sampler2D\s+iChannel[0-3]\s*;(?:\s*\/\/\s*.*)?$/gm, '');
+    // 检测源码中实际引用的 iChannel0~3（无论出现在 texture2D 还是其他表达式）
+    var usedChannels = Array.from(body.matchAll(/\biChannel([0-3])\b/g), function(match) {
+        return "iChannel" + match[1];
+    });
+    var channelSet = new Set(usedChannels);
+    // 构建 header，注入使用的 iChannel uniform 声明
+    var headerLines = [
+        'precision highp float;',
+        'varying vec2 vUV;',
+        'varying float vTime;',
+        'uniform vec4 iResolution; // viewport resolution (pixels, xy used)'
+    ];
+    for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(channelSet).sort()), _step; !(_step = _iterator()).done;){
+        var channel = _step.value;
+        headerLines.push("uniform sampler2D " + channel + ";");
+    }
+    headerLines.push('', '#define iTime vTime');
+    var header = headerLines.join('\n');
+    var footer = [
+        '',
+        'void main() {',
+        '  vec2 fragCoord = vUV * iResolution.xy;',
+        '  vec4 fragColor;',
+        '  mainImage(fragColor, fragCoord);',
+        '  gl_FragColor = fragColor;',
+        '}'
+    ].join('\n');
+    return header + "\n\n" + body + "\n" + footer;
+}
+function validateMainAndColorOutput(fragment, warnings) {
+    if (!/void\s+main\s*\(/.test(fragment)) {
+        warnings.push('Fragment shader does not contain a main() function. It may not render correctly.');
+    }
+    if (!fragment.includes('gl_FragColor') && !/out\s+vec4/.test(fragment)) {
+        warnings.push('Fragment shader does not write to gl_FragColor. It may not produce visible output.');
+    }
+}
+function bridgeUTime(fragment) {
+    return fragment.replace(/uniform\s+float\s+uTime\s*;[^\n]*/, 'varying float vTime;\n#define uTime vTime');
+}
+
+var byteToHex = [];
+for(var i = 0; i < 256; ++i){
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset) {
+    if (offset === void 0) offset = 0;
+    return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+    randomUUID: randomUUID
+};
+
+function _v4(options, buf, offset) {
+    var _ref, _options_random;
+    options = options || {};
+    var rnds = (_ref = (_options_random = options.random) != null ? _options_random : options.rng == null ? void 0 : options.rng.call(options)) != null ? _ref : rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = rnds[6] & 0x0f | 0x40;
+    rnds[8] = rnds[8] & 0x3f | 0x80;
+    return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    return _v4(options);
+}
+
+function generateId() {
+    return v4().replace(/-/g, '');
+}
+/**
+ * 生成全屏 Quad 几何体
+ */ function buildQuadGeometry(geometryId) {
+    return {
+        id: geometryId,
+        name: 'FullscreenQuad',
+        dataType: DataType.Geometry,
+        vertexData: {
+            vertexCount: 4,
+            channels: [
+                {
+                    semantic: 'POSITION',
+                    offset: 0,
+                    format: VertexFormatType.Float32,
+                    dimension: 3
+                },
+                {
+                    semantic: 'TEXCOORD0',
+                    offset: UV_OFFSET,
+                    format: VertexFormatType.Float32,
+                    dimension: 2
+                }
+            ]
+        },
+        indexFormat: IndexFormatType.UInt16,
+        indexOffset: INDEX_OFFSET,
+        subMeshes: [
+            {
+                offset: 0,
+                indexCount: 6,
+                vertexCount: 4
+            }
+        ],
+        mode: GeometryType.TRIANGLES,
+        buffer: encodeQuadBuffer()
+    };
+}
+/**
+ * 构建完整的 GE Timeline 对象图
+ *
+ * 标准结构：TimelineAsset → ObjectBindingTrack → ActivationTrack
+ * clips 内联在 Track 中，不作为独立 miscs 条目
+ */ function buildTimeline(duration, endBehavior) {
+    var miscs = [];
+    // 1. ActivationPlayableAsset
+    var activationPlayableId = generateId();
+    miscs.push({
+        id: activationPlayableId,
+        dataType: DataType.ActivationPlayableAsset
+    });
+    // 2. ActivationTrack（clips 内联）
+    var activationTrackId = generateId();
+    miscs.push({
+        id: activationTrackId,
+        dataType: DataType.ActivationTrack,
+        children: [],
+        clips: [
+            {
+                start: 0,
+                duration: duration,
+                endBehavior: endBehavior,
+                asset: {
+                    id: activationPlayableId
+                }
+            }
+        ]
+    });
+    // 3. ObjectBindingTrack（根绑定轨道）
+    var objectBindingTrackId = generateId();
+    miscs.push({
+        id: objectBindingTrackId,
+        dataType: DataType.ObjectBindingTrack,
+        children: [
+            {
+                id: activationTrackId
+            }
+        ],
+        clips: []
+    });
+    // 4. TimelineAsset
+    var timelineAssetId = generateId();
+    miscs.push({
+        id: timelineAssetId,
+        dataType: DataType.TimelineAsset,
+        tracks: [
+            {
+                id: objectBindingTrackId
+            }
+        ]
+    });
+    return {
+        miscs: miscs,
+        timelineAssetId: timelineAssetId,
+        objectBindingTrackId: objectBindingTrackId
+    };
+}
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+
+/**
+ * 判断一个 UniformValue 是否是纹理输入
+ */ function isTextureInput(value) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null) {
+        return false;
+    }
+    var record = value;
+    return typeof record.url === 'string' && !('x' in record) && !('r' in record);
+}
+/**
+ * 判断一个值是否可视作向量覆盖（vec2/vec3/vec4）
+ */ function isVectorInput(value) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null) {
+        return false;
+    }
+    var record = value;
+    return typeof record.x === 'number' && typeof record.y === 'number';
+}
+/**
+ * 判断一个值是否可视作颜色覆盖
+ */ function isColorInput(value) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null) {
+        return false;
+    }
+    var record = value;
+    return typeof record.r === 'number' && typeof record.g === 'number' && typeof record.b === 'number' && typeof record.a === 'number';
+}
+/**
+ * 合并 uniformOverrides 与 shadertoyChannels。
+ * 显式传入的 uniformOverrides 优先级更高。
+ */ function mergeUniformOverrides(options) {
+    var merged = {};
+    if (options.uniformOverrides) {
+        Object.assign(merged, options.uniformOverrides);
+    }
+    if (options.shadertoyChannels) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(Object.entries(options.shadertoyChannels)), _step; !(_step = _iterator()).done;){
+            var _step_value = _step.value, channel = _step_value[0], textureInput = _step_value[1];
+            if (!(channel in merged)) {
+                merged[channel] = textureInput;
+            }
+        }
+    }
+    return merged;
+}
+/**
+ * 原生 shader 中若显式声明 uResolution(vec4)，则用 previewSize 强制覆盖。
+ */ function shouldInjectNativeResolution(uniforms, previewSize) {
+    return Boolean(previewSize) && uniforms.some(function(u) {
+        return u.name === 'uResolution' && u.type === 'vec4';
+    });
+}
+function toResolutionVector(previewSize) {
+    return {
+        x: previewSize[0],
+        y: previewSize[1],
+        z: 1,
+        w: 0
+    };
+}
+
+function toNumber(value, fallback) {
+    if (fallback === void 0) fallback = 0;
+    return typeof value === 'number' ? value : fallback;
+}
+function toTextureDefine(textureInput) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
+    var imageId = generateId();
+    var textureId = generateId();
+    var image = {
+        id: imageId,
+        url: (_ref = textureInput == null ? void 0 : textureInput.url) != null ? _ref : DEFAULT_WHITE_TEXTURE_URL
+    };
+    var texture = {
+        id: textureId,
+        source: {
+            id: imageId
+        },
+        dataType: DataType.Texture,
+        target: GL_TEXTURE_2D,
+        wrapS: (_ref1 = textureInput == null ? void 0 : textureInput.wrapS) != null ? _ref1 : GL_TEXTURE_WRAP_REPEAT,
+        wrapT: (_ref2 = textureInput == null ? void 0 : textureInput.wrapT) != null ? _ref2 : GL_TEXTURE_WRAP_REPEAT,
+        magFilter: (_ref3 = textureInput == null ? void 0 : textureInput.magFilter) != null ? _ref3 : GL_TEXTURE_FILTER_LINEAR,
+        minFilter: (_ref4 = textureInput == null ? void 0 : textureInput.minFilter) != null ? _ref4 : GL_TEXTURE_FILTER_LINEAR,
+        flipY: (_ref5 = textureInput == null ? void 0 : textureInput.flipY) != null ? _ref5 : true
+    };
+    return {
+        image: image,
+        texture: texture,
+        textureId: textureId
+    };
+}
+function applyVectorDefault(target, uniformName, override, fallbackW) {
+    if (fallbackW === void 0) fallbackW = 0;
+    if (!isVectorInput(override)) {
+        target[uniformName] = {
+            x: 0,
+            y: 0,
+            z: 0,
+            w: fallbackW
+        };
+        return;
+    }
+    target[uniformName] = {
+        x: override.x,
+        y: override.y,
+        z: toNumber(override.z),
+        w: toNumber(override.w, fallbackW)
+    };
+}
+function buildUniformDefaults(uniforms, overrides) {
+    if (overrides === void 0) overrides = {};
+    var floats = {};
+    var vector4s = {};
+    var colors = {};
+    var materialTextures = {};
+    var images = [];
+    var textures = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(uniforms), _step; !(_step = _iterator()).done;){
+        var uniform = _step.value;
+        var override = overrides[uniform.name];
+        switch(uniform.type){
+            case 'float':
+            case 'int':
+                floats[uniform.name] = toNumber(override);
+                break;
+            case 'vec2':
+            case 'vec3':
+                applyVectorDefault(vector4s, uniform.name, override, 0);
+                break;
+            case 'vec4':
+                if (isColorInput(override)) {
+                    colors[uniform.name] = override;
+                } else {
+                    applyVectorDefault(vector4s, uniform.name, override, 1);
+                }
+                break;
+            case 'sampler2D':
+                {
+                    var textureInput = isTextureInput(override) ? override : null;
+                    var _toTextureDefine = toTextureDefine(textureInput), image = _toTextureDefine.image, texture = _toTextureDefine.texture, textureId = _toTextureDefine.textureId;
+                    images.push(image);
+                    textures.push(texture);
+                    materialTextures[uniform.name] = {
+                        texture: {
+                            id: textureId
+                        }
+                    };
+                    break;
+                }
+        }
+    }
+    return {
+        floats: floats,
+        vector4s: vector4s,
+        colors: colors,
+        materialTextures: materialTextures,
+        images: images,
+        textures: textures
+    };
+}
+
+/**
+ * 核心：生成完整的可播放 GE JSONScene
+ */ function generateScene(fragmentShader, uniforms, options, isShadertoy) {
+    if (options === void 0) options = {};
+    if (isShadertoy === void 0) isShadertoy = false;
+    var _options_sceneName = options.sceneName, sceneName = _options_sceneName === void 0 ? 'ShaderScene' : _options_sceneName, _options_duration = options.duration, duration = _options_duration === void 0 ? 5 : _options_duration, _options_endBehavior = options.endBehavior, endBehavior = _options_endBehavior === void 0 ? EndBehavior.restart : _options_endBehavior, _options_previewSize = options.previewSize, previewSize = _options_previewSize === void 0 ? [
+        512,
+        512
+    ] : _options_previewSize, _options_uniformOverrides = options.uniformOverrides, uniformOverrides = _options_uniformOverrides === void 0 ? {} : _options_uniformOverrides;
+    // 生成所有 ID
+    var shaderId = generateId();
+    var materialId = generateId();
+    var geometryId = generateId();
+    var effectComponentId = generateId();
+    var compositionComponentId = generateId();
+    var itemId = generateId();
+    var compositionId = generateId();
+    // 1. Shader（Shadertoy 模式使用带 iResolution 的 vertex shader）
+    var shader = {
+        id: shaderId,
+        name: "" + sceneName + "_Shader",
+        dataType: DataType.Shader,
+        vertex: isShadertoy ? SHADERTOY_VERTEX_SHADER : DEFAULT_VERTEX_SHADER,
+        fragment: fragmentShader
+    };
+    // 2. Material（填充 uniform 默认值 + 纹理引用）
+    var _buildUniformDefaults = buildUniformDefaults(uniforms, uniformOverrides), floats = _buildUniformDefaults.floats, vector4s = _buildUniformDefaults.vector4s, colors = _buildUniformDefaults.colors, materialTextures = _buildUniformDefaults.materialTextures, textureImages = _buildUniformDefaults.images, sceneTextures = _buildUniformDefaults.textures;
+    // Shadertoy 模式：自动注入 iResolution（视口分辨率）
+    if (isShadertoy) {
+        vector4s.iResolution = toResolutionVector(previewSize);
+    }
+    var material = {
+        id: materialId,
+        name: "" + sceneName + "_Material",
+        dataType: DataType.Material,
+        shader: {
+            id: shaderId
+        },
+        stringTags: {
+            RenderType: 'Transparent'
+        },
+        macros: [],
+        ints: {},
+        floats: floats,
+        vector4s: vector4s,
+        colors: colors,
+        textures: materialTextures
+    };
+    // 3. Geometry
+    var geometry = buildQuadGeometry(geometryId);
+    // 4. EffectComponent
+    var effectComponent = {
+        id: effectComponentId,
+        name: "" + sceneName + "_Effect",
+        dataType: DataType.EffectComponent,
+        item: {
+            id: itemId
+        },
+        _priority: 0,
+        materials: [
+            {
+                id: materialId
+            }
+        ],
+        geometry: {
+            id: geometryId
+        }
+    };
+    // 5. VFXItem
+    var item = {
+        id: itemId,
+        name: sceneName,
+        duration: duration,
+        type: ItemType.effect,
+        endBehavior: endBehavior,
+        components: [
+            {
+                id: effectComponentId
+            }
+        ],
+        dataType: DataType.VFXItemData,
+        transform: {
+            position: {
+                x: 0,
+                y: 0,
+                z: 0
+            },
+            eulerHint: {
+                x: 0,
+                y: 0,
+                z: 0
+            },
+            scale: {
+                x: 1,
+                y: 1,
+                z: 1
+            }
+        },
+        // Is deprecated but specification
+        content: null
+    };
+    // 6. Timeline（标准结构：TimelineAsset → ObjectBindingTrack → ActivationTrack）
+    var timeline = buildTimeline(duration, endBehavior);
+    // 7. CompositionComponent（指向 composition，包含 items/timelineAsset/sceneBindings）
+    var compositionComponent = {
+        id: compositionComponentId,
+        name: "" + sceneName + "_CompComp",
+        dataType: DataType.CompositionComponent,
+        item: {
+            id: compositionId
+        },
+        items: [
+            {
+                id: itemId
+            }
+        ],
+        timelineAsset: {
+            id: timeline.timelineAssetId
+        },
+        sceneBindings: [
+            {
+                key: {
+                    id: timeline.objectBindingTrackId
+                },
+                value: {
+                    id: itemId
+                }
+            }
+        ]
+    };
+    // 8. Composition
+    var composition = {
+        id: compositionId,
+        name: sceneName,
+        duration: duration,
+        startTime: 0,
+        endBehavior: endBehavior,
+        previewSize: previewSize,
+        camera: {
+            fov: 60,
+            far: 40,
+            near: 0.1,
+            clipMode: CameraClipMode.portrait,
+            position: [
+                0,
+                0,
+                8
+            ],
+            rotation: [
+                0,
+                0,
+                0
+            ]
+        },
+        components: [
+            {
+                id: compositionComponentId
+            }
+        ],
+        children: [
+            {
+                id: itemId
+            }
+        ]
+    };
+    // 9. 组装 JSONScene
+    return {
+        version: JSONSceneVersion.LATEST,
+        playerVersion: {
+            web: '2.9.0',
+            native: '0.0.1.202311221223'
+        },
+        type: 'ge',
+        compositionId: compositionId,
+        compositions: [
+            composition
+        ],
+        images: textureImages,
+        plugins: [],
+        items: [
+            item
+        ],
+        components: [
+            effectComponent,
+            compositionComponent
+        ],
+        materials: [
+            material
+        ],
+        shaders: [
+            shader
+        ],
+        geometries: [
+            geometry
+        ],
+        animations: [],
+        miscs: timeline.miscs,
+        textures: sceneTextures
+    };
+}
+
+/**
+ * 将 fragment shader 源码转换为可在 GE Runtime 播放的 JSONScene。
+ *
+ * 内部委托 {@link parseShader} 完成输入理解（Shadertoy 桥接、uniform 提取、uTime 桥接、
+ * 基础校验），自身只负责应用 ConvertOptions 与生成 JSONScene。
+ *
+ * @param fragmentShader - GLSL fragment shader 源码
+ * @param options - 转换选项（场景名称、时长、uniform 覆盖、Shadertoy 通道映射等）
+ * @returns 转换结果，包含 scene、warnings 和解析出的 uniforms
+ *
+ * @example
+ * ```ts
+ * // 纯数学生成效果
+ * const result = convert(`
+ *   precision highp float;
+ *   varying vec2 vUV;
+ *   varying float vTime;
+ *   void main() {
+ *     vec3 col = 0.5 + 0.5 * cos(vTime + vUV.xyx + vec3(0,2,4));
+ *     gl_FragColor = vec4(col, 1.0);
+ *   }
+ * `);
+ *
+ * // 带纹理输入的效果
+ * const result = convert(`
+ *   precision highp float;
+ *   varying vec2 vUV;
+ *   uniform sampler2D uMainTex;
+ *   void main() {
+ *     gl_FragColor = texture2D(uMainTex, vUV);
+ *   }
+ * `, {
+ *   uniformOverrides: {
+ *     uMainTex: { url: 'https://example.com/image.png' },
+ *   },
+ * });
+ *
+ * // Shadertoy 带纹理通道
+ * const result = convert(shadertoyCode, {
+ *   shadertoyChannels: {
+ *     iChannel0: { url: 'https://example.com/noise.png' },
+ *   },
+ * });
+ * ```
+ */ function convert(fragmentShader, options) {
+    if (options === void 0) options = {};
+    // ── 解析阶段：输入理解（与 options 无关）──
+    var parsed = parseShader(fragmentShader);
+    var warnings = [].concat(parsed.warnings);
+    // ── 应用 options ──
+    var mergedOverrides = mergeUniformOverrides(options);
+    // 检查 sampler2D uniform：未提供纹理覆盖的给出提示
+    appendMissingSamplerWarnings(parsed.uniforms, mergedOverrides, warnings);
+    // 原生 shader 的 uResolution 自动注入
+    // 和 Shadertoy 的 iResolution 处理方式一致：用当前 previewSize 自动覆盖
+    // 避免用户修改尺寸后，硬编码在 overrides 中的旧值导致宽高比矫正错误（拉伸）
+    if (shouldInjectNativeResolution(parsed.uniforms, options.previewSize)) {
+        mergedOverrides['uResolution'] = toResolutionVector(options.previewSize);
+    }
+    // ── 生成阶段：构建 JSONScene ──
+    var scene = generateScene(parsed.fragment, parsed.uniforms, _extends({}, options, {
+        uniformOverrides: mergedOverrides
+    }), parsed.isShadertoy);
+    return {
+        scene: scene,
+        warnings: warnings,
+        uniforms: parsed.uniforms
+    };
+}
+function appendMissingSamplerWarnings(uniforms, overrides, warnings) {
+    for(var _iterator = _create_for_of_iterator_helper_loose(uniforms), _step; !(_step = _iterator()).done;){
+        var uniform = _step.value;
+        if (uniform.type !== 'sampler2D') {
+            continue;
+        }
+        var override = overrides[uniform.name];
+        if (!isTextureInput(override)) {
+            warnings.push('Uniform "' + uniform.name + '" is sampler2D. No texture override provided — a default 1\xd71 white texture will be used.');
+        }
+    }
+}
+
+exports.DEFAULT_VERTEX_SHADER = DEFAULT_VERTEX_SHADER;
+exports.DEFAULT_WHITE_TEXTURE_URL = DEFAULT_WHITE_TEXTURE_URL;
+exports.FALLBACK_FRAGMENT_SHADER = FALLBACK_FRAGMENT_SHADER;
+exports.GL_TEXTURE_2D = GL_TEXTURE_2D;
+exports.GL_TEXTURE_FILTER_LINEAR = GL_TEXTURE_FILTER_LINEAR;
+exports.GL_TEXTURE_FILTER_NEAREST = GL_TEXTURE_FILTER_NEAREST;
+exports.GL_TEXTURE_WRAP_CLAMP_TO_EDGE = GL_TEXTURE_WRAP_CLAMP_TO_EDGE;
+exports.GL_TEXTURE_WRAP_REPEAT = GL_TEXTURE_WRAP_REPEAT;
+exports.INDEX_OFFSET = INDEX_OFFSET;
+exports.POSITION_BYTES = POSITION_BYTES;
+exports.QUAD_INDICES = QUAD_INDICES;
+exports.QUAD_POSITIONS = QUAD_POSITIONS;
+exports.QUAD_UVS = QUAD_UVS;
+exports.SHADERTOY_VERTEX_SHADER = SHADERTOY_VERTEX_SHADER;
+exports.UV_OFFSET = UV_OFFSET;
+exports.buildQuadGeometry = buildQuadGeometry;
+exports.buildTimeline = buildTimeline;
+exports.buildUniformDefaults = buildUniformDefaults;
+exports.convert = convert;
+exports.encodeQuadBuffer = encodeQuadBuffer;
+exports.generateId = generateId;
+exports.generateScene = generateScene;
+exports.isColorInput = isColorInput;
+exports.isTextureInput = isTextureInput;
+exports.isVectorInput = isVectorInput;
+exports.mergeUniformOverrides = mergeUniformOverrides;
+exports.parseShader = parseShader;
+exports.parseUniforms = parseUniforms;
+exports.shouldInjectNativeResolution = shouldInjectNativeResolution;
+exports.spec = index;
+exports.toResolutionVector = toResolutionVector;
+//# sourceMappingURL=index.js.map