@galacean/effects-plugin-model 2.0.0-alpha.18 → 2.0.0-alpha.19

package/dist/alipay.js

@@ -3136,7 +3136,7 @@ function _assert_this_initialized(self) {
             });
         }
         var proxy = new HitTestingProxy();
-        var doubleSided = this.material.isDoubleSide();
+        var doubleSided = this.material.isBothSide();
         proxy.create(this.geometry.geometry, doubleSided, bindMatrices);
         return proxy.getHitPoint(newOrigin, newDirection);
     };
@@ -3277,8 +3277,7 @@ function _assert_this_initialized(self) {
                         material.setVector3("_shCoefficients." + n, Vector3.fromArray(coeffs[i]));
                     });
                 }
-                var _skybox_specularMipCount;
-                material.setInt("_MipCount", (_skybox_specularMipCount = skybox.specularMipCount) != null ? _skybox_specularMipCount : 1);
+                material.setInt("_MipCount", skybox.specularMipCount - 1);
                 material.setTexture("_SpecularEnvSampler", skybox.specularImage);
             }
         }
@@ -3784,9 +3783,9 @@ var EffectsMeshProxy = /*#__PURE__*/ function() {
             maxLightCount: this.maxLightCount,
             skybox: this.skybox
         };
-        // if (this.enableDynamicSort) {
-        //   this.dynamicSortMeshes(states);
-        // }
+        if (this.enableDynamicSort) {
+            this.dynamicSortMeshes(this.sceneStates);
+        }
         this.tickCount += 1;
         this.lastTickSecond += deltaSeconds;
     };
@@ -3795,12 +3794,14 @@ var EffectsMeshProxy = /*#__PURE__*/ function() {
    * 主要是为了和 Tiny 渲染对齐，正常渲染不进行调整
    * @param states - 场景中的状态数据
    */ _proto.dynamicSortMeshes = function dynamicSortMeshes(states) {
-        var meshList = [];
+        var meshComponents = [];
         var priorityList = [];
-        var meshSet = this.renderedMeshSet.now;
-        meshSet.forEach(function(mesh) {
-            meshList.push(mesh);
-            priorityList.push(mesh.priority);
+        this.meshList.forEach(function(mesh) {
+            if (mesh.owner && mesh.owner.enabled) {
+                var component = mesh.owner;
+                meshComponents.push(component);
+                priorityList.push(component.priority);
+            }
         });
         priorityList.sort(function(a, b) {
             return a - b;
@@ -3808,26 +3809,30 @@ var EffectsMeshProxy = /*#__PURE__*/ function() {
         // 按照 Tiny 排序算法，对 Mesh 对象进行排序
         // 将透明和不透明物体拆开，从而渲染正确
         var viewMatrix = states.viewMatrix;
-        meshList.sort(function(a, b) {
+        meshComponents.sort(function(a, b) {
             var atransparent = WebGLHelper.isTransparentMesh(a);
             var btransparent = WebGLHelper.isTransparentMesh(b);
             if (atransparent && btransparent) {
-                var aposition = Vector3.fromArray(a.worldMatrix.elements, 12);
-                var bposition = Vector3.fromArray(b.worldMatrix.elements, 12);
+                var aposition = a.transform.getWorldPosition();
+                var bposition = b.transform.getWorldPosition();
                 var anewPos = viewMatrix.transformPoint(aposition);
                 var bnewPos = viewMatrix.transformPoint(bposition);
-                return anewPos.z - bnewPos.z;
+                if (anewPos.z === bnewPos.z) {
+                    return a.priority - b.priority;
+                } else {
+                    return anewPos.z - bnewPos.z;
+                }
             } else if (atransparent) {
                 return 1;
             } else if (btransparent) {
                 return -1;
             } else {
-                return 0;
+                return a.priority - b.priority;
             }
         });
         // 重新赋值渲染优先级
-        for(var i = 0; i < meshList.length; i++){
-            var mesh = meshList[i];
+        for(var i = 0; i < meshComponents.length; i++){
+            var mesh = meshComponents[i];
             var priority = priorityList[i];
             mesh.priority = priority;
         }
@@ -3972,7 +3977,7 @@ var StandardShaderSource;
         if (isWebGL2) {
             return "#version 300 es\n" + source;
         } else {
-            return "#version 100\n" + source;
+            return source;
         }
     }
     /**
@@ -3990,7 +3995,7 @@ var StandardShaderSource;
         if (isWebGL2) {
             return "#version 300 es\n" + source;
         }
-        return "#version 100\n" + source;
+        return source;
     }
     StandardShaderSource.getSourceCode = getSourceCode;
 })(StandardShaderSource || (StandardShaderSource = {}));
@@ -4718,7 +4723,8 @@ exports.ModelCameraComponent = /*#__PURE__*/ function(ItemBehaviour) {
     /**
    * 组件销毁
    */ _proto.onDestroy = function onDestroy() {
-        this.content.dispose();
+        var _this_content;
+        (_this_content = this.content) == null ? void 0 : _this_content.dispose();
     };
     /**
    * 反序列化，记录传入参数
@@ -4835,29 +4841,25 @@ var ModelAnimationClip = /*#__PURE__*/ function(AnimationClip) {
         var life = Math.max(0, time) % duration;
         for(var _iterator = _create_for_of_iterator_helper_loose(this.positionCurves), _step; !(_step = _iterator()).done;){
             var curve = _step.value;
-            var maxTime = curve.keyFrames.getMaxTime();
-            var value = curve.keyFrames.getValue(life % maxTime);
+            var value = curve.keyFrames.getValue(life % this.duration);
             var target = this.getTargetItem(vfxItem, curve.path);
             target == null ? void 0 : target.transform.setPosition(value.x, value.y, value.z);
         }
         for(var _iterator1 = _create_for_of_iterator_helper_loose(this.rotationCurves), _step1; !(_step1 = _iterator1()).done;){
             var curve1 = _step1.value;
-            var maxTime1 = curve1.keyFrames.getMaxTime();
-            var value1 = curve1.keyFrames.getValue(life % maxTime1);
+            var value1 = curve1.keyFrames.getValue(life % this.duration);
             var target1 = this.getTargetItem(vfxItem, curve1.path);
             target1 == null ? void 0 : target1.transform.setQuaternion(value1.x, value1.y, value1.z, value1.w);
         }
         for(var _iterator2 = _create_for_of_iterator_helper_loose(this.scaleCurves), _step2; !(_step2 = _iterator2()).done;){
             var curve2 = _step2.value;
-            var maxTime2 = curve2.keyFrames.getMaxTime();
-            var value2 = curve2.keyFrames.getValue(life % maxTime2);
+            var value2 = curve2.keyFrames.getValue(life % this.duration);
             var target2 = this.getTargetItem(vfxItem, curve2.path);
             target2 == null ? void 0 : target2.transform.setScale(value2.x, value2.y, value2.z);
         }
         for(var _iterator3 = _create_for_of_iterator_helper_loose(this.floatCurves), _step3; !(_step3 = _iterator3()).done;){
             var curve3 = _step3.value;
-            var maxTime3 = curve3.keyFrames.getMaxTime();
-            var value3 = curve3.keyFrames.getValue(life % maxTime3);
+            var value3 = curve3.keyFrames.getValue(life % this.duration);
             var target3 = this.getTargetItem(vfxItem, curve3.path);
             if (curve3.className === "ModelMeshComponent") {
                 var component = target3 == null ? void 0 : target3.getComponent(exports.ModelMeshComponent);
@@ -4873,6 +4875,7 @@ var ModelAnimationClip = /*#__PURE__*/ function(AnimationClip) {
         }
     };
     _proto.setFromAnimationClip = function setFromAnimationClip(clip) {
+        this.duration = clip.duration;
         this.positionCurves = clip.positionCurves.slice();
         this.rotationCurves = clip.rotationCurves.slice();
         this.scaleCurves = clip.scaleCurves.slice();
@@ -5628,10 +5631,10 @@ var normal = new Vector3();
     };
     /**
    * 返回 Mesh 是否半透明
-   * @param mesh - gl mesh 对象
+   * @param component - ModelMeshComponent 对象
    * @return 是否半透明
-   */ WebGLHelper.isTransparentMesh = function isTransparentMesh(mesh) {
-        return mesh.material.blending === true;
+   */ WebGLHelper.isTransparentMesh = function isTransparentMesh(component) {
+        return component.material.blending === true;
     };
     /**
    * renderer 是否支持 Float 纹理
@@ -6093,10 +6096,17 @@ var normal = new Vector3();
             texOptions.wrapT = EFFECTS.glContext.REPEAT;
             texOptions.magFilter = EFFECTS.glContext.LINEAR;
             texOptions.minFilter = EFFECTS.glContext.LINEAR_MIPMAP_LINEAR;
-            texOptions.generateMipmap = true;
             if (!isBaseColor) {
                 texOptions.premultiplyAlpha = true;
             }
+            var newOptions = texOptions;
+            newOptions.generateMipmap = true;
+            var image = newOptions.image;
+            if (image && image.width && image.height) {
+                if (!WebGLHelper.isPow2(image.width) || !WebGLHelper.isPow2(image.height)) {
+                    texOptions.minFilter = EFFECTS.glContext.LINEAR;
+                }
+            }
         } else if (texOptions.target === EFFECTS.glContext.TEXTURE_CUBE_MAP) {
             texOptions.wrapS = EFFECTS.glContext.CLAMP_TO_EDGE;
             texOptions.wrapT = EFFECTS.glContext.CLAMP_TO_EDGE;
@@ -7795,18 +7805,6 @@ var toHalf = function() {
     };
 }();
 
-exports.RenderType = void 0;
-(function(RenderType) {
-    RenderType["Opaque"] = "Opaque";
-    RenderType["Mask"] = "Mask";
-    RenderType["Blend"] = "Blend";
-})(exports.RenderType || (exports.RenderType = {}));
-exports.CullMode = void 0;
-(function(CullMode) {
-    CullMode["Front"] = "Front";
-    CullMode["Back"] = "Back";
-    CullMode["Double"] = "Double";
-})(exports.CullMode || (exports.CullMode = {}));
 /**
  * 3D 材质基础类，支持公共的材质功能
  */ var PMaterialBase = /*#__PURE__*/ function(PObject) {
@@ -7831,13 +7829,16 @@ exports.CullMode = void 0;
    */ _this.ZTest = true;
         /**
    * 渲染类型，默认是不透明
-   */ _this.renderType = "Opaque";
+   */ _this.renderType = EFFECTS.spec.RenderType.Opaque;
+        /**
+   * 是否 Alpha 裁剪，默认关闭
+   */ _this.alphaClip = false;
         /**
    * Alpha 测试截断值
-   */ _this.alphaCutOff = 0.5;
+   */ _this.alphaCutoff = 0.5;
         /**
    * 面侧模式，默认是正面
-   */ _this.cullMode = "Front";
+   */ _this.renderFace = EFFECTS.spec.RenderFace.Front;
         return _this;
     }
     var _proto = PMaterialBase.prototype;
@@ -7846,28 +7847,28 @@ exports.CullMode = void 0;
    * @returns 特性列表
    */ _proto.getShaderFeatures = function getShaderFeatures() {
         var featureList = [];
-        if (this.isOpaque()) {
-            featureList.push("ALPHAMODE_OPAQUE 1");
-        } else if (this.isMasked()) {
+        if (this.isAlphaClip()) {
             featureList.push("ALPHAMODE_MASK 1");
+        } else if (this.isOpaque()) {
+            featureList.push("ALPHAMODE_OPAQUE 1");
         }
-        if (this.cullMode === "Double") {
+        if (this.renderFace === EFFECTS.spec.RenderFace.Both) {
             featureList.push("DOUBLE_SIDED 1");
         }
         return featureList;
     };
     _proto.getShaderMacros = function getShaderMacros() {
         var macroList = [];
-        if (this.isOpaque()) {
+        if (this.isAlphaClip()) {
             macroList.push({
-                name: "ALPHAMODE_OPAQUE"
+                name: "ALPHAMODE_MASK"
             });
-        } else if (this.isMasked()) {
+        } else if (this.isOpaque()) {
             macroList.push({
-                name: "ALPHAMODE_MASK"
+                name: "ALPHAMODE_OPAQUE"
             });
         }
-        if (this.cullMode === "Double") {
+        if (this.renderFace === EFFECTS.spec.RenderFace.Both) {
             macroList.push({
                 name: "DOUBLE_SIDED"
             });
@@ -7950,7 +7951,7 @@ exports.CullMode = void 0;
    * 设置材质状态，根据 GE 材质状态
    * @param material - GE 材质
    */ _proto.setMaterialStates = function setMaterialStates(material) {
-        if (this.renderType === "Blend") {
+        if (this.renderType === EFFECTS.spec.RenderType.Transparent) {
             material.blending = true;
             material.depthTest = this.ZTest;
             material.depthMask = this.ZWrite;
@@ -7979,7 +7980,7 @@ exports.CullMode = void 0;
         this.setFaceSideStates(material);
     };
     _proto.setFaceSideStates = function setFaceSideStates(material) {
-        if (this.isDoubleSide()) {
+        if (this.isBothSide()) {
             material.culling = false;
         } else if (this.isBackSide()) {
             material.cullFace = EFFECTS.glContext.FRONT;
@@ -8007,37 +8008,37 @@ exports.CullMode = void 0;
    * 是否不透明
    * @returns
    */ _proto.isOpaque = function isOpaque() {
-        return this.renderType === "Opaque";
+        return this.renderType === EFFECTS.spec.RenderType.Opaque;
     };
     /**
-   * 是否遮罩
+   * 是否 Alpha 裁剪
    * @returns
-   */ _proto.isMasked = function isMasked() {
-        return this.renderType === "Mask";
+   */ _proto.isAlphaClip = function isAlphaClip() {
+        return this.alphaClip;
     };
     /**
    * 是否半透明
    * @returns
-   */ _proto.isBlend = function isBlend() {
-        return this.renderType === "Blend";
+   */ _proto.isTransparent = function isTransparent() {
+        return this.renderType === EFFECTS.spec.RenderType.Transparent;
     };
     /**
    * 是否正面模式
    * @returns
    */ _proto.isFrontSide = function isFrontSide() {
-        return this.cullMode === "Front";
+        return this.renderFace === EFFECTS.spec.RenderFace.Front;
     };
     /**
    * 是否背面模式
    * @returns
    */ _proto.isBackSide = function isBackSide() {
-        return this.cullMode === "Back";
+        return this.renderFace === EFFECTS.spec.RenderFace.Back;
     };
     /**
    * 是否双面模式
    * @returns
-   */ _proto.isDoubleSide = function isDoubleSide() {
-        return this.cullMode === "Double";
+   */ _proto.isBothSide = function isBothSide() {
+        return this.renderFace === EFFECTS.spec.RenderFace.Both;
     };
     return PMaterialBase;
 }(PObject);
@@ -8069,14 +8070,15 @@ exports.CullMode = void 0;
         var _material_getColor;
         this.baseColorFactor = (_material_getColor = material.getColor("_BaseColorFactor")) != null ? _material_getColor : new Color(1.0, 1.0, 1.0, 1.0);
         //
-        this.ZWrite = material.stringTags["ZWrite"] !== "false";
-        this.ZTest = material.stringTags["ZTest"] !== "false";
+        this.ZWrite = material.getFloat("ZWrite") !== 0;
+        this.ZTest = material.getFloat("ZTest") !== 0;
         var _material_stringTags_RenderType;
-        this.renderType = (_material_stringTags_RenderType = material.stringTags["RenderType"]) != null ? _material_stringTags_RenderType : "Opaque";
+        this.renderType = (_material_stringTags_RenderType = material.stringTags["RenderType"]) != null ? _material_stringTags_RenderType : EFFECTS.spec.RenderType.Opaque;
+        this.alphaClip = material.getFloat("AlphaClip") === 1;
         var _material_getFloat;
-        this.alphaCutOff = (_material_getFloat = material.getFloat("_AlphaCutoff")) != null ? _material_getFloat : 0;
-        var _material_stringTags_Cull;
-        this.cullMode = (_material_stringTags_Cull = material.stringTags["Cull"]) != null ? _material_stringTags_Cull : "Front";
+        this.alphaCutoff = (_material_getFloat = material.getFloat("_AlphaCutoff")) != null ? _material_getFloat : 0;
+        var _material_stringTags_RenderFace;
+        this.renderFace = (_material_stringTags_RenderFace = material.stringTags["RenderFace"]) != null ? _material_stringTags_RenderFace : EFFECTS.spec.RenderFace.Front;
     };
     /**
    * 销毁材质
@@ -8244,14 +8246,15 @@ exports.CullMode = void 0;
         var _material_getFloat4;
         this.emissiveIntensity = (_material_getFloat4 = material.getFloat("_EmissiveIntensity")) != null ? _material_getFloat4 : 1;
         //
-        this.ZWrite = material.stringTags["ZWrite"] !== "false";
-        this.ZTest = material.stringTags["ZTest"] !== "false";
+        this.ZWrite = material.getFloat("ZWrite") !== 0;
+        this.ZTest = material.getFloat("ZTest") !== 0;
         var _material_stringTags_RenderType;
-        this.renderType = (_material_stringTags_RenderType = material.stringTags["RenderType"]) != null ? _material_stringTags_RenderType : "Opaque";
+        this.renderType = (_material_stringTags_RenderType = material.stringTags["RenderType"]) != null ? _material_stringTags_RenderType : EFFECTS.spec.RenderType.Opaque;
+        this.alphaClip = material.getFloat("AlphaClip") === 1;
         var _material_getFloat5;
-        this.alphaCutOff = (_material_getFloat5 = material.getFloat("_AlphaCutoff")) != null ? _material_getFloat5 : 0;
-        var _material_stringTags_Cull;
-        this.cullMode = (_material_stringTags_Cull = material.stringTags["Cull"]) != null ? _material_stringTags_Cull : "Front";
+        this.alphaCutoff = (_material_getFloat5 = material.getFloat("_AlphaCutoff")) != null ? _material_getFloat5 : 0;
+        var _material_stringTags_RenderFace;
+        this.renderFace = (_material_stringTags_RenderFace = material.stringTags["RenderFace"]) != null ? _material_stringTags_RenderFace : EFFECTS.spec.RenderFace.Front;
     };
     /**
    * 销毁材质
@@ -8698,7 +8701,7 @@ exports.CullMode = void 0;
                 if (this.irradianceCoeffs === undefined && this.diffuseImage === undefined) {
                     return false;
                 }
-                return this.specularImage !== undefined && this.specularMipCount > 0;
+                return this.specularImage !== undefined && this.specularMipCount >= 0;
             }
         },
         {
@@ -8825,7 +8828,7 @@ exports.CullMode = void 0;
                 material.setVector3("_shCoefficients." + n, Vector3.fromArray(coeffs[i]));
             });
         }
-        material.setInt("_MipCount", this.specularMipCount);
+        material.setInt("_MipCount", this.specularMipCount - 1);
         material.setTexture("_SpecularEnvSampler", this.specularImage);
     };
     /**
@@ -9191,7 +9194,7 @@ exports.PSkyboxType = void 0;
             diffuseImage: this.getDiffuseImageList(skyboxType, specularImage),
             specularImage: specularImage,
             specularImageSize: Math.pow(2, specularImage.length - 1),
-            specularMipCount: specularImage.length - 1
+            specularMipCount: specularImage.length
         };
         return params;
     };
@@ -10900,9 +10903,9 @@ var LoaderImpl = /*#__PURE__*/ function() {
             }
             return newImages;
         });
-        var specularMipCount = specularImages.length - 1;
+        var specularMipCount = specularImages.length;
         var _ibl_specularImageSize;
-        var specularImageSize = (_ibl_specularImageSize = ibl.specularImageSize) != null ? _ibl_specularImageSize : Math.pow(2, specularMipCount);
+        var specularImageSize = (_ibl_specularImageSize = ibl.specularImageSize) != null ? _ibl_specularImageSize : Math.pow(2, specularMipCount - 1);
         var params = {
             type: "buffer",
             renderable: this.isSkyboxVis(),
@@ -11478,11 +11481,11 @@ var TextureManager = /*#__PURE__*/ function() {
         this._textureMap.clear();
     };
     _proto.addTexture = function addTexture(matIndex, texIndex, tex, isBaseColor) {
-        var index = isBaseColor ? matIndex * 100000 + texIndex : texIndex;
+        var index = isBaseColor ? (matIndex + 1) * 100000 + texIndex : texIndex;
         this._textureMap.set(index, tex);
     };
     _proto.getTexture = function getTexture(matIndex, texIndex, isBaseColor) {
-        var index = isBaseColor ? matIndex * 100000 + texIndex : texIndex;
+        var index = isBaseColor ? (matIndex + 1) * 100000 + texIndex : texIndex;
         return this._textureMap.get(index);
     };
     return TextureManager;
@@ -12356,7 +12359,7 @@ var JSONConverter = /*#__PURE__*/ function() {
                 id: scene.textures[skyboxOptions.specularImage].id
             },
             specularImageSize: skyboxOptions.specularImageSize,
-            specularMipCount: skyboxOptions.specularMipCount
+            specularMipCount: skyboxOptions.specularMipCount + 1
         };
         return skyboxComponent;
     };
@@ -12788,7 +12791,7 @@ var JSONConverter = /*#__PURE__*/ function() {
         if (oldMat.blending === EFFECTS.spec.MaterialBlending.masked) {
             newMat.floats["AlphaClip"] = 1;
             var _oldMat_alphaCutOff;
-            newMat.floats["_Cutoff"] = (_oldMat_alphaCutOff = oldMat.alphaCutOff) != null ? _oldMat_alphaCutOff : 0;
+            newMat.floats["_AlphaCutoff"] = (_oldMat_alphaCutOff = oldMat.alphaCutOff) != null ? _oldMat_alphaCutOff : 0;
         } else {
             newMat.floats["AlphaClip"] = 0;
         }
@@ -12805,9 +12808,8 @@ var JSONConverter = /*#__PURE__*/ function() {
         if (oldMat.type === EFFECTS.spec.MaterialType.pbr) {
             newMat.floats["_SpecularAA"] = oldMat.useSpecularAA ? 1 : 0;
         }
-        var _oldMat_depthMask;
-        newMat.stringTags["ZWrite"] = String((_oldMat_depthMask = oldMat.depthMask) != null ? _oldMat_depthMask : true);
-        newMat.stringTags["ZTest"] = String(true);
+        newMat.floats["ZWrite"] = oldMat.depthMask !== false ? 1 : 0;
+        newMat.floats["ZTest"] = 1;
     };
     _proto.getTextureData = function getTextureData(scene, floats, texIndex, texTransform) {
         var _scene_textures_texIndex_id;
@@ -13214,8 +13216,8 @@ function createGeometryData(props, subMeshes) {
         },
         subMeshes: subMeshes,
         mode: EFFECTS.spec.GeometryType.TRIANGLES,
-        indexFormat: EFFECTS.spec.IndexFormatType.UInt16,
-        indexOffset: -1,
+        indexFormat: EFFECTS.spec.IndexFormatType.None,
+        indexOffset: 0,
         buffer: ""
     };
     if (props.indices) {
@@ -13225,6 +13227,8 @@ function createGeometryData(props, subMeshes) {
         geometryData.indexOffset = bufferOffset;
         if (_instanceof1(indices, Uint32Array)) {
             geometryData.indexFormat = EFFECTS.spec.IndexFormatType.UInt32;
+        } else {
+            geometryData.indexFormat = EFFECTS.spec.IndexFormatType.UInt16;
         }
     }
     geometryData.buffer = toBase64String(buffer);
@@ -13379,9 +13383,1049 @@ var vertexBufferSemanticMap = {
     a_Target_Tangent3: "TANGENT_BS3"
 };
 
+var LoaderECSImpl = /*#__PURE__*/ function() {
+    function LoaderECSImpl(composition) {
+        this.gltfSkins = [];
+        this.gltfMeshs = [];
+        this.gltfLights = [];
+        this.gltfCameras = [];
+        this.gltfImages = [];
+        this.gltfTextures = [];
+        this.gltfMaterials = [];
+        this.gltfAnimations = [];
+        this.gltfImageBasedLights = [];
+        this.timelineAssetId = "";
+        this.images = [];
+        this.imageElements = [];
+        this.textures = [];
+        this.items = [];
+        this.components = [];
+        this.materials = [];
+        this.shaders = [];
+        this.geometries = [];
+        this.animations = [];
+        if (composition) {
+            this.composition = composition;
+        } else {
+            this.timelineAssetId = EFFECTS.generateGUID();
+            this.composition = {
+                id: "1",
+                name: "test1",
+                duration: 9999,
+                endBehavior: EFFECTS.spec.CompositionEndBehavior.restart,
+                camera: {
+                    fov: 45,
+                    far: 2000,
+                    near: 0.001,
+                    position: [
+                        0,
+                        0,
+                        8
+                    ],
+                    rotation: [
+                        0,
+                        0,
+                        0
+                    ],
+                    clipMode: EFFECTS.spec.CameraClipMode.portrait
+                },
+                items: [],
+                timelineAsset: {
+                    id: this.timelineAssetId
+                },
+                sceneBindings: []
+            };
+        }
+    }
+    var _proto = LoaderECSImpl.prototype;
+    _proto.initial = function initial(engine, options) {
+        this.engine = engine;
+        this.loaderOptions = options != null ? options : {};
+    };
+    _proto.loadScene = function loadScene(options) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var _this_components, _this_components1, _this_components2, _this_items, _options_effects_renderer, gltfResource, gltfScene, component, clips, index;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _this.clear();
+                        _this.sceneOptions = options;
+                        _this.engine = (_options_effects_renderer = options.effects.renderer) == null ? void 0 : _options_effects_renderer.engine;
+                        _this.loaderOptions = {
+                            compatibleMode: options.gltf.compatibleMode
+                        };
+                        gltfResource = options.gltf.resource;
+                        if (typeof gltfResource === "string" || _instanceof1(gltfResource, Uint8Array)) {
+                            throw new Error("Please load the resource using GLTFTools first.");
+                        }
+                        _this.images = gltfResource.images.map(function(gltfImage) {
+                            var _gltfImage_mimeType;
+                            var blob = new Blob([
+                                gltfImage.imageData.buffer
+                            ], {
+                                type: (_gltfImage_mimeType = gltfImage.mimeType) != null ? _gltfImage_mimeType : "image/png"
+                            });
+                            return {
+                                id: gltfImage.id,
+                                url: URL.createObjectURL(blob)
+                            };
+                        });
+                        return [
+                            4,
+                            Promise.all(_this.images.map(/*#__PURE__*/ _async_to_generator(function(image) {
+                                return __generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        EFFECTS.loadImage(image.url)
+                                    ];
+                                });
+                            })))
+                        ];
+                    case 1:
+                        _this.imageElements = _state.sent();
+                        _this.processGLTFResource(gltfResource);
+                        _this.gltfScene = gltfResource.scenes[0];
+                        _this.gltfSkins = _this.gltfScene.skins;
+                        _this.gltfMeshs = gltfResource.meshes;
+                        _this.gltfLights = _this.gltfScene.lights;
+                        _this.gltfCameras = _this.gltfScene.cameras;
+                        _this.gltfImages = gltfResource.images;
+                        _this.gltfTextures = gltfResource.textures;
+                        _this.gltfMaterials = gltfResource.materials;
+                        _this.gltfAnimations = gltfResource.animations;
+                        _this.gltfImageBasedLights = gltfResource.imageBasedLights;
+                        _this.textures = _this.gltfTextures.map(function(texture) {
+                            var textureOptions = texture.textureOptions;
+                            var source = textureOptions.source;
+                            if (typeof source === "number") {
+                                // @ts-expect-error
+                                textureOptions.source = {
+                                    id: _this.images[source].id
+                                };
+                            }
+                            return textureOptions;
+                        });
+                        _this.materials = _this.gltfMaterials.map(function(material) {
+                            return material.materialData;
+                        });
+                        gltfResource.meshes.forEach(function(mesh) {
+                            _this.geometries.push(mesh.geometryData);
+                        });
+                        gltfScene = gltfResource.scenes[0];
+                        gltfScene.meshesComponentData.forEach(function(mesh) {
+                            return _this.checkMeshComponentData(mesh, gltfResource);
+                        });
+                        (_this_components = _this.components).push.apply(_this_components, [].concat(gltfScene.camerasComponentData));
+                        (_this_components1 = _this.components).push.apply(_this_components1, [].concat(gltfScene.lightsComponentData));
+                        (_this_components2 = _this.components).push.apply(_this_components2, [].concat(gltfScene.meshesComponentData));
+                        if (gltfScene.animationsComponentData.length === 1) {
+                            component = gltfScene.animationsComponentData[0];
+                            if (!options.effects.playAllAnimation && options.effects.playAnimation !== undefined) {
+                                clips = component.animationClips;
+                                index = options.effects.playAnimation;
+                                if (index >= 0 && index < clips.length) {
+                                    component.animationClips = [
+                                        clips[index]
+                                    ];
+                                } else {
+                                    component.animationClips = [];
+                                }
+                            }
+                            _this.components.push(component);
+                        } else if (gltfScene.animationsComponentData.length > 1) {
+                            throw new Error("Find many animation component data " + gltfScene.animationsComponentData.length);
+                        }
+                        _this.animations = [];
+                        _this.gltfAnimations.forEach(function(anim) {
+                            _this.animations.push(anim.animationClipData);
+                        });
+                        _this.items = [];
+                        return [
+                            4,
+                            _this.tryAddSkybox({
+                                skyboxType: options.gltf.skyboxType,
+                                renderable: options.gltf.skyboxVis
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        (_this_items = _this.items).push.apply(_this_items, [].concat(gltfResource.scenes[0].vfxItemData));
+                        _this.items.forEach(function(item) {
+                            if (item.type === "root") {
+                                item.type = "ECS";
+                            }
+                        });
+                        return [
+                            2,
+                            _this.getLoadResult()
+                        ];
+                }
+            });
+        })();
+    };
+    _proto.checkMeshComponentData = function checkMeshComponentData(mesh, resource) {
+        if (mesh.materials.length <= 0) {
+            throw new Error("Submesh array is empty for mesh with ID: " + mesh.id + ".");
+        }
+        var geometryData;
+        resource.meshes.forEach(function(meshData) {
+            if (meshData.geometryData.id === mesh.geometry.id) {
+                geometryData = meshData.geometryData;
+            }
+        });
+        if (geometryData === undefined) {
+            throw new Error("Unable to find geometry data for mesh with ID: " + mesh.geometry.id + ".");
+        }
+        if (geometryData.subMeshes.length !== mesh.materials.length) {
+            throw new Error("Mismatch between submeshes count (" + geometryData.subMeshes.length + ") and materials count (" + mesh.materials.length + ").");
+        }
+    //mesh.materials.length !=
+    };
+    _proto.processGLTFResource = function processGLTFResource(resource) {
+        var _loop = function() {
+            var baseColorId = _step.value;
+            if (emissiveIdSet.has(baseColorId)) {
+                var texData = textures.find(function(tex) {
+                    return tex.textureOptions.id === baseColorId;
+                });
+                if (texData) {
+                    var newId = EFFECTS.generateGUID();
+                    // @ts-expect-error
+                    var newTexData = _extends({}, texData);
+                    newTexData.textureOptions = _extends({}, texData.textureOptions, {
+                        id: newId
+                    });
+                    textures.push(newTexData);
+                    dataMap[newId] = newTexData.textureOptions;
+                    textureIdMap[baseColorId] = newId;
+                    mapCount += 1;
+                }
+            }
+        };
+        var _this = this;
+        var dataMap = {};
+        var textures = resource.textures, materials = resource.materials, scenes = resource.scenes, imageBasedLights = resource.imageBasedLights;
+        textures.forEach(function(tex) {
+            var texData = tex.textureOptions;
+            var texId = texData.id;
+            if (texId) {
+                if (dataMap[texId]) {
+                    console.error("Duplicate GUID found: " + texId + ", old " + dataMap[texId] + ", new " + texData + ".");
+                }
+                dataMap[texId] = texData;
+            } else {
+                console.error("No GUID in texture Data: " + texData + ".");
+            }
+        });
+        var baseColorIdSet = new Set();
+        var emissiveIdSet = new Set();
+        materials.forEach(function(mat) {
+            var _materialData_textures__BaseColorSampler, _materialData_textures__EmissiveSampler;
+            var materialData = mat.materialData;
+            var baseColorTexture = (_materialData_textures__BaseColorSampler = materialData.textures["_BaseColorSampler"]) == null ? void 0 : _materialData_textures__BaseColorSampler.texture;
+            var emissiveTexture = (_materialData_textures__EmissiveSampler = materialData.textures["_EmissiveSampler"]) == null ? void 0 : _materialData_textures__EmissiveSampler.texture;
+            if (baseColorTexture) {
+                baseColorIdSet.add(baseColorTexture.id);
+            }
+            if (emissiveTexture) {
+                emissiveIdSet.add(emissiveTexture.id);
+            }
+        });
+        var mapCount = 0;
+        var textureIdMap = {};
+        for(var _iterator = _create_for_of_iterator_helper_loose(baseColorIdSet), _step; !(_step = _iterator()).done;)_loop();
+        if (mapCount > 0) {
+            console.warn("Duplicate emissive texture " + mapCount);
+        }
+        materials.forEach(function(mat) {
+            var _materialData_shader, _materialData_shader1;
+            var materialData = mat.materialData;
+            _this.processMaterialData(materialData);
+            if (((_materialData_shader = materialData.shader) == null ? void 0 : _materialData_shader.id) === UnlitShaderGUID) {
+                _this.processMaterialTexture(materialData, "_BaseColorSampler", true, dataMap);
+            } else if (((_materialData_shader1 = materialData.shader) == null ? void 0 : _materialData_shader1.id) === PBRShaderGUID) {
+                var _materialData_textures__EmissiveSampler;
+                var emissiveTexture = (_materialData_textures__EmissiveSampler = materialData.textures["_EmissiveSampler"]) == null ? void 0 : _materialData_textures__EmissiveSampler.texture;
+                if (emissiveTexture && textureIdMap[emissiveTexture.id]) {
+                    emissiveTexture.id = textureIdMap[emissiveTexture.id];
+                }
+                _this.processMaterialTexture(materialData, "_BaseColorSampler", true, dataMap);
+                _this.processMaterialTexture(materialData, "_MetallicRoughnessSampler", false, dataMap);
+                _this.processMaterialTexture(materialData, "_NormalSampler", false, dataMap);
+                _this.processMaterialTexture(materialData, "_OcclusionSampler", false, dataMap);
+                _this.processMaterialTexture(materialData, "_EmissiveSampler", false, dataMap);
+            }
+        });
+        var gltfScene = scenes[0];
+        gltfScene.camerasComponentData.forEach(function(comp) {
+            return _this.processCameraComponentData(comp);
+        });
+        gltfScene.lightsComponentData.forEach(function(comp) {
+            return _this.processLightComponentData(comp);
+        });
+        gltfScene.meshesComponentData.forEach(function(comp) {
+            return _this.processMeshComponentData(comp);
+        });
+        var cubeTextures = [];
+        imageBasedLights.forEach(function(ibl) {
+            var data = ibl.imageBaseLightData;
+            if (data.reflectionsIntensity === undefined) {
+                data.reflectionsIntensity = data.intensity;
+            }
+            if (data.diffuseImage) {
+                var diffuseTexture = dataMap[data.diffuseImage.id];
+                EFFECTS.addItem(cubeTextures, diffuseTexture);
+            }
+            if (data.specularImage) {
+                var specularImage = dataMap[data.specularImage.id];
+                EFFECTS.addItem(cubeTextures, specularImage);
+            }
+        });
+        cubeTextures.forEach(function(tex) {
+            if (tex.target === EFFECTS.glContext.TEXTURE_CUBE_MAP) {
+                var cube = tex;
+                cube.mipmaps.forEach(function(mipmap) {
+                    var ref;
+                    ref = [
+                        mipmap[5],
+                        mipmap[4]
+                    ], mipmap[4] = ref[0], mipmap[5] = ref[1];
+                });
+                if (cube.mipmaps.length === 1) {
+                    cube.minFilter = EFFECTS.glContext.LINEAR;
+                    cube.magFilter = EFFECTS.glContext.LINEAR;
+                } else {
+                    cube.minFilter = EFFECTS.glContext.LINEAR_MIPMAP_LINEAR;
+                    cube.magFilter = EFFECTS.glContext.LINEAR;
+                }
+            }
+        });
+    };
+    _proto.processComponentData = function processComponentData(components) {
+        var _this = this;
+        components.forEach(function(comp) {
+            if (comp.dataType === EFFECTS.spec.DataType.LightComponent) {
+                _this.processLightComponentData(comp);
+            } else if (comp.dataType === EFFECTS.spec.DataType.CameraComponent) {
+                _this.processCameraComponentData(comp);
+            } else if (comp.dataType === EFFECTS.spec.DataType.MeshComponent) {
+                _this.processMeshComponentData(comp);
+            } else if (comp.dataType === EFFECTS.spec.DataType.SkyboxComponent) {
+                _this.processSkyboxComponentData(comp);
+            }
+        });
+    };
+    _proto.processLightComponentData = function processLightComponentData(light) {
+        if (!light.color) {
+            light.color = {
+                r: 1,
+                g: 1,
+                b: 1,
+                a: 1
+            };
+        }
+        if (!light.intensity) {
+            light.intensity = 1;
+        }
+        if (light.lightType === EFFECTS.spec.LightType.point) {
+            if (!light.range) {
+                light.range = 0;
+            }
+        } else if (light.lightType === EFFECTS.spec.LightType.spot) {
+            if (!light.range) {
+                light.range = 0;
+            }
+            if (!light.innerConeAngle) {
+                light.innerConeAngle = 0;
+            }
+            if (!light.outerConeAngle) {
+                light.outerConeAngle = Math.PI / 4;
+            }
+        }
+    };
+    _proto.processCameraComponentData = function processCameraComponentData(camera) {
+        if (camera.type === EFFECTS.spec.CameraType.perspective) {
+            if (camera.fov) {
+                camera.fov *= Math.PI / 180;
+            }
+        }
+    };
+    _proto.processMeshComponentData = function processMeshComponentData(mesh) {};
+    _proto.processSkyboxComponentData = function processSkyboxComponentData(skybox) {
+        if (skybox.intensity === undefined) {
+            skybox.intensity = 1;
+        }
+        if (skybox.reflectionsIntensity === undefined) {
+            skybox.reflectionsIntensity = 1;
+        }
+    };
+    _proto.processMaterialData = function processMaterialData(material) {
+        var _material_shader, _material_shader1;
+        if (((_material_shader = material.shader) == null ? void 0 : _material_shader.id) === UnlitShaderGUID) {
+            if (!material.colors["_BaseColorFactor"]) {
+                material.colors["_BaseColorFactor"] = {
+                    r: 1,
+                    g: 1,
+                    b: 1,
+                    a: 1
+                };
+            }
+            if (material.floats["_AlphaCutoff"] === undefined) {
+                material.floats["_AlphaCutoff"] = 0;
+            }
+            if (material.floats["ZWrite"] === undefined) {
+                material.floats["ZWrite"] = 1;
+            }
+            if (material.floats["ZTest"] === undefined) {
+                material.floats["ZTest"] = 1;
+            }
+            if (!material.stringTags["RenderType"]) {
+                material.stringTags["RenderType"] = EFFECTS.spec.RenderType.Opaque;
+            }
+            if (!material.stringTags["RenderFace"]) {
+                material.stringTags["RenderFace"] = EFFECTS.spec.RenderFace.Front;
+            }
+        } else if (((_material_shader1 = material.shader) == null ? void 0 : _material_shader1.id) === PBRShaderGUID) {
+            if (!material.colors["_BaseColorFactor"]) {
+                material.colors["_BaseColorFactor"] = {
+                    r: 1,
+                    g: 1,
+                    b: 1,
+                    a: 1
+                };
+            }
+            if (material.floats["_SpecularAA"] === undefined) {
+                material.floats["_SpecularAA"] = 0;
+            }
+            if (material.floats["_MetallicFactor"] === undefined) {
+                material.floats["_MetallicFactor"] = 1;
+            }
+            if (material.floats["_RoughnessFactor"] === undefined) {
+                material.floats["_RoughnessFactor"] = 0;
+            }
+            if (material.floats["_NormalScale"] === undefined) {
+                material.floats["_NormalScale"] = 1;
+            }
+            if (material.floats["_OcclusionStrength"] === undefined) {
+                material.floats["_OcclusionStrength"] = this.isTiny3dMode() ? 0 : 1;
+            }
+            if (!material.colors["_EmissiveFactor"]) {
+                material.colors["_EmissiveFactor"] = {
+                    r: 0,
+                    g: 0,
+                    b: 0,
+                    a: 1
+                };
+            }
+            if (material.floats["_EmissiveIntensity"] === undefined) {
+                material.floats["_EmissiveIntensity"] = 1;
+            }
+            if (material.floats["_AlphaCutoff"] === undefined) {
+                material.floats["_AlphaCutoff"] = 0;
+            }
+            if (material.floats["ZWrite"] === undefined) {
+                material.floats["ZWrite"] = 1;
+            }
+            if (material.floats["ZTest"] === undefined) {
+                material.floats["ZTest"] = 1;
+            }
+            if (!material.stringTags["RenderType"]) {
+                material.stringTags["RenderType"] = EFFECTS.spec.RenderType.Opaque;
+            }
+            if (!material.stringTags["RenderFace"]) {
+                material.stringTags["RenderFace"] = EFFECTS.spec.RenderFace.Front;
+            }
+        } else {
+            console.error("Encountered unknown shader ID in material with ID: " + material.id + ".");
+        }
+    };
+    _proto.processTextureOptions = function processTextureOptions(options, isBaseColor, image) {
+        var premultiplyAlpha = false;
+        var _options_minFilter;
+        var minFilter = (_options_minFilter = options.minFilter) != null ? _options_minFilter : EFFECTS.glContext.LINEAR_MIPMAP_LINEAR;
+        if (this.isTiny3dMode()) {
+            minFilter = EFFECTS.glContext.LINEAR_MIPMAP_LINEAR;
+            if (image) {
+                if (!WebGLHelper.isPow2(image.width) || !WebGLHelper.isPow2(image.height)) {
+                    minFilter = EFFECTS.glContext.LINEAR;
+                }
+            }
+            premultiplyAlpha = isBaseColor ? false : true;
+        }
+        var generateMipmap = minFilter == EFFECTS.glContext.NEAREST_MIPMAP_NEAREST || minFilter == EFFECTS.glContext.LINEAR_MIPMAP_NEAREST || minFilter == EFFECTS.glContext.NEAREST_MIPMAP_LINEAR || minFilter == EFFECTS.glContext.LINEAR_MIPMAP_LINEAR;
+        var _options_wrapS;
+        options.wrapS = (_options_wrapS = options.wrapS) != null ? _options_wrapS : EFFECTS.glContext.REPEAT;
+        var _options_wrapT;
+        options.wrapT = (_options_wrapT = options.wrapT) != null ? _options_wrapT : EFFECTS.glContext.REPEAT;
+        var _options_magFilter;
+        options.magFilter = (_options_magFilter = options.magFilter) != null ? _options_magFilter : EFFECTS.glContext.LINEAR;
+        options.minFilter = minFilter;
+        options.anisotropic = 1;
+        options.premultiplyAlpha = premultiplyAlpha;
+        options.generateMipmap = generateMipmap;
+    };
+    _proto.processMaterialTexture = function processMaterialTexture(material, textureName, isBaseColor, dataMap) {
+        var texture = material.textures[textureName];
+        if (texture) {
+            var id = texture.texture.id;
+            var texData = dataMap[id];
+            var imageObj;
+            // @ts-expect-error
+            if (typeof texData.source !== "number") {
+                // @ts-expect-error
+                throw new Error("Invalid texture option source data, " + texData.source);
+            } else {
+                // @ts-expect-error
+                imageObj = this.imageElements[texData.source];
+            }
+            if (texData) {
+                this.processTextureOptions(texData, isBaseColor, imageObj);
+            }
+        }
+    };
+    _proto.getLoadResult = function getLoadResult() {
+        var itemIds = [];
+        this.items.forEach(function(item) {
+            return itemIds.push({
+                id: item.id
+            });
+        });
+        this.composition.items = itemIds;
+        var jsonScene = {
+            version: "3.0",
+            playerVersion: {
+                web: "2.0",
+                native: "2.0"
+            },
+            type: "ge",
+            compositionId: this.composition.id,
+            compositions: [
+                this.composition
+            ],
+            images: this.images,
+            shapes: [],
+            plugins: [
+                "model"
+            ],
+            textures: this.textures,
+            items: this.items,
+            components: this.components,
+            materials: this.materials,
+            shaders: this.shaders,
+            geometries: this.geometries,
+            animations: this.animations,
+            miscs: [
+                {
+                    id: this.timelineAssetId,
+                    dataType: EFFECTS.spec.DataType.TimelineAsset
+                }
+            ]
+        };
+        return {
+            source: this.getRemarkString(),
+            jsonScene: jsonScene,
+            sceneAABB: {
+                min: [
+                    -1,
+                    -1,
+                    -1
+                ],
+                max: [
+                    1,
+                    1,
+                    1
+                ]
+            }
+        };
+    };
+    _proto.addLight = function addLight(data) {
+        var itemId = EFFECTS.generateGUID();
+        var component = {
+            id: EFFECTS.generateGUID(),
+            item: {
+                id: itemId
+            },
+            dataType: EFFECTS.spec.DataType.LightComponent,
+            //
+            lightType: data.lightType,
+            color: data.color,
+            intensity: data.intensity,
+            range: data.range,
+            innerConeAngle: data.innerConeAngle,
+            outerConeAngle: data.outerConeAngle
+        };
+        var item = {
+            id: itemId,
+            name: data.name,
+            duration: data.duration,
+            type: EFFECTS.spec.ItemType.light,
+            pn: 0,
+            visible: true,
+            endBehavior: data.endBehavior,
+            transform: {
+                position: {
+                    x: data.position[0],
+                    y: data.position[1],
+                    z: data.position[2]
+                },
+                eulerHint: {
+                    x: data.rotation[0],
+                    y: data.rotation[1],
+                    z: data.rotation[2]
+                },
+                scale: {
+                    x: data.scale[0],
+                    y: data.scale[1],
+                    z: data.scale[2]
+                }
+            },
+            components: [
+                {
+                    id: component.id
+                }
+            ],
+            content: {},
+            dataType: EFFECTS.spec.DataType.VFXItemData
+        };
+        this.items.push(item);
+        this.components.push(component);
+    };
+    _proto.addCamera = function addCamera(camera) {
+        var itemId = EFFECTS.generateGUID();
+        var component = {
+            id: EFFECTS.generateGUID(),
+            item: {
+                id: itemId
+            },
+            dataType: EFFECTS.spec.DataType.CameraComponent,
+            fov: camera.fov,
+            near: camera.near,
+            far: camera.far,
+            clipMode: camera.clipMode
+        };
+        var item = {
+            id: itemId,
+            name: camera.name,
+            duration: camera.duration,
+            // @ts-expect-error
+            type: "camera",
+            pn: 0,
+            visible: true,
+            endBehavior: camera.endBehavior,
+            transform: {
+                position: {
+                    x: camera.position[0],
+                    y: camera.position[1],
+                    z: camera.position[2]
+                },
+                eulerHint: {
+                    x: camera.rotation[0],
+                    y: camera.rotation[1],
+                    z: camera.rotation[2]
+                },
+                scale: {
+                    x: 1,
+                    y: 1,
+                    z: 1
+                }
+            },
+            components: [
+                {
+                    id: component.id
+                }
+            ],
+            content: {},
+            dataType: EFFECTS.spec.DataType.VFXItemData
+        };
+        this.items.push(item);
+        this.components.push(component);
+    };
+    _proto.tryAddSkybox = function tryAddSkybox(skybox) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var ibl, _this_images, // @ts-expect-error
+            _this_textures, itemId, skyboxInfo, imageList, textureOptionsList, component, _skybox_renderable, _skybox_duration, item;
+            return __generator(this, function(_state) {
+                if (_this.gltfImageBasedLights.length > 0 && !_this.ignoreSkybox()) {
+                    ibl = _this.gltfImageBasedLights[0];
+                    _this.components.push(ibl.imageBaseLightData);
+                } else if (skybox.skyboxType !== undefined) {
+                    itemId = EFFECTS.generateGUID();
+                    skyboxInfo = _this.createSkyboxComponentData(skybox.skyboxType);
+                    imageList = skyboxInfo.imageList, textureOptionsList = skyboxInfo.textureOptionsList, component = skyboxInfo.component;
+                    component.item.id = itemId;
+                    if (skybox.intensity !== undefined) {
+                        component.intensity = skybox.intensity;
+                    }
+                    if (skybox.reflectionsIntensity !== undefined) {
+                        component.reflectionsIntensity = skybox.reflectionsIntensity;
+                    }
+                    component.renderable = (_skybox_renderable = skybox.renderable) != null ? _skybox_renderable : false;
+                    item = {
+                        id: itemId,
+                        name: "Skybox-" + skybox.skyboxType,
+                        duration: (_skybox_duration = skybox.duration) != null ? _skybox_duration : 999,
+                        type: EFFECTS.spec.ItemType.skybox,
+                        pn: 0,
+                        visible: true,
+                        endBehavior: EFFECTS.spec.ItemEndBehavior.freeze,
+                        transform: {
+                            position: {
+                                x: 0,
+                                y: 0,
+                                z: 0
+                            },
+                            eulerHint: {
+                                x: 0,
+                                y: 0,
+                                z: 0
+                            },
+                            scale: {
+                                x: 1,
+                                y: 1,
+                                z: 1
+                            }
+                        },
+                        components: [
+                            {
+                                id: component.id
+                            }
+                        ],
+                        content: {},
+                        dataType: EFFECTS.spec.DataType.VFXItemData
+                    };
+                    (_this_images = _this.images).push.apply(_this_images, [].concat(imageList));
+                    (_this_textures = _this.textures).push.apply(_this_textures, [].concat(textureOptionsList));
+                    _this.items.push(item);
+                    _this.components.push(component);
+                }
+                return [
+                    2
+                ];
+            });
+        })();
+    };
+    _proto.createTreeOptions = function createTreeOptions(scene) {
+        var nodeList = scene.nodes.map(function(node, nodeIndex) {
+            var children = node.children.map(function(child) {
+                if (child.nodeIndex === undefined) {
+                    throw new Error("Undefined nodeIndex for child " + child + ".");
+                }
+                return child.nodeIndex;
+            });
+            var pos = [
+                0,
+                0,
+                0
+            ];
+            var quat = [
+                0,
+                0,
+                0,
+                0
+            ];
+            var scale = [
+                0,
+                0,
+                0
+            ];
+            if (node.matrix !== undefined) {
+                if (node.matrix.length !== 16) {
+                    throw new Error("Invalid matrix length " + node.matrix.length + " for node " + node + ".");
+                }
+                var mat = Matrix4.fromArray(node.matrix);
+                var transform = mat.getTransform();
+                pos = transform.translation.toArray();
+                quat = transform.rotation.toArray();
+                scale = transform.scale.toArray();
+            } else {
+                if (node.translation !== undefined) {
+                    pos = node.translation;
+                }
+                if (node.rotation !== undefined) {
+                    quat = node.rotation;
+                }
+                if (node.scale !== undefined) {
+                    scale = node.scale;
+                }
+            }
+            node.nodeIndex = nodeIndex;
+            var treeNode = {
+                name: node.name,
+                transform: {
+                    position: pos,
+                    quat: quat,
+                    scale: scale
+                },
+                children: children,
+                id: "" + node.nodeIndex
+            };
+            return treeNode;
+        });
+        var rootNodes = scene.rootNodes.map(function(root) {
+            if (root.nodeIndex === undefined) {
+                throw new Error("Undefined nodeIndex for root " + root + ".");
+            }
+            return root.nodeIndex;
+        });
+        var treeOptions = {
+            nodes: nodeList,
+            children: rootNodes,
+            animation: -1,
+            animations: []
+        };
+        return treeOptions;
+    };
+    _proto.createAnimations = function createAnimations(animations) {
+        return animations.map(function(anim) {
+            var tracks = anim.channels.map(function(channel) {
+                var track = {
+                    input: channel.input.array,
+                    output: channel.output.array,
+                    node: channel.target.node,
+                    path: channel.target.path,
+                    interpolation: channel.interpolation
+                };
+                return track;
+            });
+            var newAnim = {
+                name: anim.name,
+                tracks: tracks
+            };
+            return newAnim;
+        });
+    };
+    _proto.createTexture2D = function createTexture2D(image, texture, isBaseColor) {
+        return WebGLHelper.createTexture2D(this.engine, image, texture, isBaseColor, this.isTiny3dMode());
+    };
+    _proto.createSkyboxComponentData = function createSkyboxComponentData(typeName) {
+        if (typeName !== "NFT" && typeName !== "FARM") {
+            throw new Error("Invalid skybox type specified: '" + typeName + "'. Valid types are: 'NFT', 'FARM'.");
+        }
+        //
+        var typ = typeName === "NFT" ? exports.PSkyboxType.NFT : exports.PSkyboxType.FARM;
+        var params = PSkyboxCreator.getSkyboxParams(typ);
+        return PSkyboxCreator.createSkyboxComponentData(this.engine, params);
+    };
+    _proto.scaleColorVal = function scaleColorVal(val, fromGLTF) {
+        return fromGLTF ? LoaderHelper.scaleTo255(val) : LoaderHelper.scaleTo1(val);
+    };
+    _proto.scaleColorVec = function scaleColorVec(vec, fromGLTF) {
+        var _this = this;
+        return vec.map(function(val) {
+            return _this.scaleColorVal(val, fromGLTF);
+        });
+    };
+    _proto.createLightOptions = function createLightOptions(light) {
+        return PluginHelper.createLightOptions(light);
+    };
+    _proto.createCameraOptions = function createCameraOptions(camera) {
+        var _PluginHelper_createCameraOptions;
+        return (_PluginHelper_createCameraOptions = PluginHelper.createCameraOptions(camera)) != null ? _PluginHelper_createCameraOptions : {
+            fov: 45,
+            far: 1000,
+            near: 0.01,
+            clipMode: EFFECTS.spec.CameraClipMode.portrait
+        };
+    };
+    _proto.clear = function clear() {
+        this.images = [];
+        this.textures = [];
+        this.items = [];
+        this.components = [];
+        this.materials = [];
+        this.shaders = [];
+        this.geometries = [];
+    };
+    /**
+   * 按照传入的动画播放参数，计算需要播放的动画索引
+   *
+   * @param treeOptions 节点树属性，需要初始化animations列表。
+   * @returns 返回计算的动画索引，-1表示没有动画需要播放，-88888888表示播放所有动画。
+   */ _proto.getPlayAnimationIndex = function getPlayAnimationIndex(treeOptions) {
+        var animations = treeOptions.animations;
+        if (animations === undefined || animations.length <= 0) {
+            // 硬编码，内部指定的不播放动画的索引值
+            return -1;
+        }
+        if (this.isPlayAllAnimation()) {
+            // 硬编码，内部指定的播放全部动画的索引值
+            return -88888888;
+        }
+        var animationInfo = this.sceneOptions.effects.playAnimation;
+        if (animationInfo === undefined) {
+            return -1;
+        }
+        if (typeof animationInfo === "number") {
+            if (animationInfo >= 0 && animationInfo < animations.length) {
+                return animationInfo;
+            } else {
+                return -1;
+            }
+        } else {
+            // typeof animationInfo === 'string'
+            var animationIndex = -1;
+            // 通过动画名字查找动画索引
+            animations.forEach(function(anim, index) {
+                if (anim.name === animationInfo) {
+                    animationIndex = index;
+                }
+            });
+            return animationIndex;
+        }
+    };
+    _proto.isPlayAnimation = function isPlayAnimation() {
+        return this.sceneOptions.effects.playAnimation !== undefined;
+    };
+    _proto.isPlayAllAnimation = function isPlayAllAnimation() {
+        return this.sceneOptions.effects.playAllAnimation === true;
+    };
+    _proto.getRemarkString = function getRemarkString() {
+        var remark = this.sceneOptions.gltf.remark;
+        if (remark === undefined) {
+            return "Unknown";
+        } else if (typeof remark === "string") {
+            return remark;
+        } else {
+            return "BinaryBuffer";
+        }
+    };
+    _proto.getCompositionDuration = function getCompositionDuration() {
+        return this.composition.duration;
+    };
+    _proto.isTiny3dMode = function isTiny3dMode() {
+        return this.loaderOptions.compatibleMode === "tiny3d";
+    };
+    _proto.getItemDuration = function getItemDuration() {
+        var _this_sceneOptions_effects_duration;
+        return (_this_sceneOptions_effects_duration = this.sceneOptions.effects.duration) != null ? _this_sceneOptions_effects_duration : 9999;
+    };
+    _proto.getItemEndBehavior = function getItemEndBehavior() {
+        var _this_sceneOptions_effects_endBehavior;
+        return (_this_sceneOptions_effects_endBehavior = this.sceneOptions.effects.endBehavior) != null ? _this_sceneOptions_effects_endBehavior : EFFECTS.spec.ItemEndBehavior.loop;
+    };
+    _proto.getSkyboxType = function getSkyboxType() {
+        var typeName = this.sceneOptions.gltf.skyboxType;
+        switch(typeName){
+            case "NFT":
+                return exports.PSkyboxType.NFT;
+            case "FARM":
+                return exports.PSkyboxType.FARM;
+        }
+    };
+    _proto.isSkyboxVis = function isSkyboxVis() {
+        return this.sceneOptions.gltf.skyboxVis === true;
+    };
+    _proto.ignoreSkybox = function ignoreSkybox() {
+        return this.sceneOptions.gltf.ignoreSkybox === true;
+    };
+    _proto.isEnvironmentTest = function isEnvironmentTest() {
+        if (typeof this.sceneOptions.gltf.remark === "string") {
+            return this.sceneOptions.gltf.remark.includes("EnvironmentTest");
+        } else {
+            return false;
+        }
+    };
+    return LoaderECSImpl;
+}();
+var globalLoader;
+function getDefaultEffectsGLTFLoaderECS(engine, options) {
+    if (!globalLoader) {
+        globalLoader = new LoaderECSImpl();
+    }
+    globalLoader.initial(engine, options);
+    return globalLoader;
+}
+function setDefaultEffectsGLTFLoaderECS(loader) {
+    globalLoader = loader;
+}
+function getPBRShaderProperties() {
+    return '\n  _BaseColorSampler ("基础贴图", 2D) = "" {}\n  _BaseColorFactor ("基础颜色", Color) = (1, 1, 1, 1)\n  _MetallicRoughnessSampler ("金属贴图", 2D) = "" {}\n  _MetallicFactor ("金属度", Range(0, 1)) = 1\n  _RoughnessFactor ("粗糙度", Range(0, 1)) = 1\n  [Toggle] _SpecularAA ("高光抗锯齿", Float) = 0\n  _NormalSampler ("法线贴图", 2D) = "" {}\n  _NormalScale ("法线贴图强度", Range(0, 2)) = 1\n  _OcclusionSampler ("AO贴图", 2D) = "" {}\n  _OcclusionStrength ("AO贴图强度", Range(0, 1)) = 1\n  _EmissiveSampler ("自发光贴图", 2D) = "" {}\n  _EmissiveIntensity ("自发光贴图强度", Float) = 1\n  _EmissiveFactor ("自发光颜色", Color) = (0, 0, 0, 1)\n  _AlphaCutoff ("Alpha裁剪值", Range(0, 1)) = 0.5\n  ';
+}
+function getUnlitShaderProperties() {
+    return '\n  _BaseColorSampler ("基础贴图", 2D) = "" {}\n  _BaseColorFactor ("基础颜色", Color) = (1, 1, 1, 1)\n  _AlphaCutoff ("Alpha裁剪值", Range(0, 1)) = 0.5\n  ';
+}
+function getDefaultPBRMaterialData() {
+    var material = {
+        "id": "00000000000000000000000000000000",
+        "name": "PBR Material",
+        "dataType": EFFECTS.spec.DataType.Material,
+        "stringTags": {
+            "RenderType": EFFECTS.spec.RenderType.Opaque,
+            "RenderFace": "Front"
+        },
+        "macros": [],
+        "shader": {
+            "id": "pbr00000000000000000000000000000"
+        },
+        "ints": {},
+        "floats": {
+            "ZWrite": 1,
+            "ZTest": 1,
+            "_SpecularAA": 0,
+            "_MetallicFactor": 1,
+            "_RoughnessFactor": 0.0,
+            "_NormalScale": 1,
+            "_OcclusionStrength": 1,
+            "_EmissiveIntensity": 1,
+            "_AlphaCutoff": 0.5
+        },
+        "vector4s": {},
+        "colors": {
+            "_BaseColorFactor": {
+                "r": 1,
+                "g": 1,
+                "b": 1,
+                "a": 1
+            },
+            "_EmissiveFactor": {
+                "r": 0,
+                "g": 0,
+                "b": 0,
+                "a": 1
+            }
+        },
+        "textures": {}
+    };
+    return material;
+}
+function getDefaultUnlitMaterialData() {
+    var material = {
+        "id": "00000000000000000000000000000000",
+        "name": "Unlit Material",
+        "dataType": EFFECTS.spec.DataType.Material,
+        "stringTags": {
+            "ZWrite": "true",
+            "ZTest": "true",
+            "RenderType": EFFECTS.spec.RenderType.Opaque,
+            "Cull": "Front"
+        },
+        "macros": [],
+        "shader": {
+            "id": "unlit000000000000000000000000000"
+        },
+        "ints": {},
+        "floats": {
+            "_AlphaCutoff": 0.5
+        },
+        "vector4s": {},
+        "colors": {
+            "_BaseColorFactor": {
+                "r": 1,
+                "g": 1,
+                "b": 1,
+                "a": 1
+            }
+        },
+        "textures": {}
+    };
+    return material;
+}
+
 EFFECTS.registerPlugin("tree", ModelTreePlugin, EFFECTS.VFXItem, true);
 EFFECTS.registerPlugin("model", ModelPlugin, EFFECTS.VFXItem);
-var version = "2.0.0-alpha.18";
+var version = "2.0.0-alpha.19";
 EFFECTS.logger.info("Plugin model version: " + version + ".");
 if (version !== EFFECTS__namespace.version) {
     console.error("注意：请统一 Model 插件与 Player 版本，不统一的版本混用会有不可预知的后果！", "\nAttention: Please ensure the Model plugin is synchronized with the Player version. Mixing and matching incompatible versions may result in unpredictable consequences!");
@@ -13404,6 +14448,7 @@ exports.HitTestingProxy = HitTestingProxy;
 exports.HookOGLFunc = HookOGLFunc;
 exports.InterpolationSampler = InterpolationSampler;
 exports.JSONConverter = JSONConverter;
+exports.LoaderECSImpl = LoaderECSImpl;
 exports.LoaderHelper = LoaderHelper;
 exports.LoaderImpl = LoaderImpl;
 exports.Matrix3 = Matrix3;
@@ -13461,6 +14506,9 @@ exports.createPluginMaterial = createPluginMaterial;
 exports.fetchPBRShaderCode = fetchPBRShaderCode;
 exports.fetchUnlitShaderCode = fetchUnlitShaderCode;
 exports.getDefaultEffectsGLTFLoader = getDefaultEffectsGLTFLoader;
+exports.getDefaultEffectsGLTFLoaderECS = getDefaultEffectsGLTFLoaderECS;
+exports.getDefaultPBRMaterialData = getDefaultPBRMaterialData;
+exports.getDefaultUnlitMaterialData = getDefaultUnlitMaterialData;
 exports.getDiffuseOnlyShaderCode = getDiffuseOnlyShaderCode;
 exports.getGaussianBlurShaderCodeV1 = getGaussianBlurShaderCodeV1;
 exports.getGaussianBlurShaderCodeV2 = getGaussianBlurShaderCodeV2;
@@ -13469,6 +14517,7 @@ exports.getGeometryDataFromPropsList = getGeometryDataFromPropsList;
 exports.getKawaseBlurShaderCode = getKawaseBlurShaderCode;
 exports.getNormalVisShaderCode = getNormalVisShaderCode;
 exports.getPBRPassShaderCode = getPBRPassShaderCode;
+exports.getPBRShaderProperties = getPBRShaderProperties;
 exports.getPMeshList = getPMeshList;
 exports.getQuadFilterShaderCode = getQuadFilterShaderCode;
 exports.getRendererGPUInfo = getRendererGPUInfo;
@@ -13478,6 +14527,8 @@ exports.getSimpleFilterShaderCode = getSimpleFilterShaderCode;
 exports.getSkyBoxShaderCode = getSkyBoxShaderCode;
 exports.getTransparecyBaseShader = getTransparecyBaseShader;
 exports.getTransparecyFilterShader = getTransparecyFilterShader;
+exports.getUnlitShaderProperties = getUnlitShaderProperties;
 exports.setDefaultEffectsGLTFLoader = setDefaultEffectsGLTFLoader;
+exports.setDefaultEffectsGLTFLoaderECS = setDefaultEffectsGLTFLoaderECS;
 exports.version = version;
 //# sourceMappingURL=alipay.js.map