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

package/dist/index.mjs

@@ -3,10 +3,11 @@
  * Description: Galacean Effects player model plugin
  * Author: Ant Group CO., Ltd.
  * Contributors: 飂兮
- * Version: v2.0.0-alpha.17
+ * Version: v2.0.0-alpha.19
  */
 
-import { math, Transform, PLAYER_OPTIONS_ENV_EDITOR, spec, glContext, Texture, TextureSourceType, RenderPassAttachmentStorageType, Material, Mesh, Geometry, GLSLVersion, addItem, removeItem, effectsClass, RendererComponent, ItemBehaviour, HitTestType, AnimationClip, RenderPass, TextureLoadAction, DestroyOptions, RenderPassDestroyAttachmentType, Player, Renderer, getDefaultTextureFactory, loadImage, generateGUID, VFXItem, AbstractPlugin, glType2VertexFormatType, Downloader, getStandardJSON, isObject, registerPlugin, logger, version as version$1 } from '@galacean/effects';
+import * as EFFECTS from '@galacean/effects';
+import { math, Transform, PLAYER_OPTIONS_ENV_EDITOR, spec, glContext, Texture, TextureSourceType, RenderPassAttachmentStorageType, Material, Mesh, Geometry, GLSLVersion, addItem, removeItem, effectsClass, RendererComponent, ItemBehaviour, HitTestType, AnimationClip, RenderPass, TextureLoadAction, DestroyOptions, RenderPassDestroyAttachmentType, Player, Renderer, getDefaultTextureFactory, loadImage, generateGUID, VFXItem, AbstractPlugin, glType2VertexFormatType, Downloader, getStandardJSON, isObject, registerPlugin, logger } from '@galacean/effects';
 
 /**
  * Model 插件元素类型
@@ -1155,7 +1156,7 @@ var TextureDataMode;
         var matList = props.inverseBindMatrices;
         if (matList !== undefined && matList.length > 0) {
             if (matList.length % 16 !== 0 || matList.length !== this.jointItem.length * 16) {
-                throw new Error("Invalid array length, invert bind matrices " + matList.length + ", joint array " + this.jointItem.length);
+                throw new Error("Invalid array length, invert bind matrices " + matList.length + ", joint array " + this.jointItem.length + ".");
             }
             var matrixCount = matList.length / 16;
             for(var i = 0; i < matrixCount; i++){
@@ -1186,7 +1187,7 @@ var TextureDataMode;
             });
         } else {
             this.animationMatrices = this.inverseBindMatrices;
-            console.error("Some error occured, replace skin animation matrices by invert bind matrices");
+            console.error("Some error occured, replace skin animation matrices by invert bind matrices.");
         }
     };
     /**
@@ -1247,7 +1248,7 @@ var TextureDataMode;
             } else if (detail.halfFloatTexture) {
                 return 2;
             } else {
-                throw new Error("Too many joint count " + jointCount + ", half float texture not support");
+                throw new Error("Too many joint count " + jointCount + ", half float texture not support.");
             }
         } else {
             return 0;
@@ -1260,7 +1261,7 @@ var TextureDataMode;
         (_props_boneNames = props.boneNames) == null ? void 0 : _props_boneNames.forEach(function(boneName) {
             var node = name2Item[boneName];
             if (!node) {
-                throw new Error("Can't find node of bone name " + boneName);
+                throw new Error("Can't find node of bone name " + boneName + ".");
             }
             jointItems.push(node);
         });
@@ -1357,19 +1358,19 @@ var TextureDataMode;
      * 还要注意最大数目不能超过5，否则也直接报错。
      * 后续考虑是否做个兼容，目前还是严格报错比较好。
      */ if (positionCount > 0 && positionCount != this.morphWeightsLength) {
-            console.error("Position morph count mismatch: " + this.morphWeightsLength + ", " + positionCount);
+            console.error("Position morph count mismatch: " + this.morphWeightsLength + ", " + positionCount + ".");
             return false;
         }
         if (normalCount > 0 && normalCount != this.morphWeightsLength) {
-            console.error("Normal morph count mismatch: " + this.morphWeightsLength + ", " + normalCount);
+            console.error("Normal morph count mismatch: " + this.morphWeightsLength + ", " + normalCount + ".");
             return false;
         }
         if (tangentCount > 0 && tangentCount != this.morphWeightsLength) {
-            console.error("Tangent morph count mismatch: " + this.morphWeightsLength + ", " + tangentCount);
+            console.error("Tangent morph count mismatch: " + this.morphWeightsLength + ", " + tangentCount + ".");
             return false;
         }
         if (this.morphWeightsLength > 5) {
-            console.error("Tangent morph count should not greater than 5, current " + this.morphWeightsLength);
+            console.error("Tangent morph count should not greater than 5, current " + this.morphWeightsLength + ".");
             return false;
         }
         return true;
@@ -1391,7 +1392,7 @@ var TextureDataMode;
     _proto.updateWeights = function updateWeights(weights) {
         var _this = this;
         if (weights.length != this.morphWeightsArray.length) {
-            console.error("Length of morph weights mismatch: input " + weights.length + ", internel " + this.morphWeightsArray.length);
+            console.error("Length of morph weights mismatch: input " + weights.length + ", internel " + this.morphWeightsArray.length + ".");
             return;
         }
         weights.forEach(function(value, index) {
@@ -1512,16 +1513,16 @@ var PAnimPathType;
             this.component = this.dataArray.length / this.timeArray.length;
             // special checker for weights animation
             if (this.component <= 0) {
-                console.error("Invalid weights component: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length);
+                console.error("Invalid weights component: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length + ".");
             } else if (this.timeArray.length * this.component != this.dataArray.length) {
-                console.error("Invalid weights array length: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length);
+                console.error("Invalid weights array length: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length + ".");
             }
         } else {
             // should never happened
-            console.error("Invalid path status: " + path);
+            console.error("Invalid path status: " + path + ".");
         }
         if (this.timeArray.length * this.component > this.dataArray.length) {
-            throw new Error("Data length mismatch: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length);
+            throw new Error("Data length mismatch: " + this.timeArray.length + ", " + this.component + ", " + this.dataArray.length + ".");
         }
         if (interpolation === "LINEAR") {
             this.interp = 0;
@@ -2541,7 +2542,7 @@ function _assert_this_initialized(self) {
             _this.subMeshes.push(subMesh);
         });
         if (_this.subMeshes.length <= 0) {
-            console.warn("No primitive inside mesh item " + name);
+            console.warn("No primitive inside mesh item " + name + ".");
         }
         _this.boundingBox = _this.getItemBoundingBox(meshData.interaction);
         return _this;
@@ -2629,7 +2630,7 @@ function _assert_this_initialized(self) {
             return;
         }
         if (updatedArray.length != weightsArray.length) {
-            throw new Error("weight array length mismatch");
+            throw new Error("Weight array length mismatch.");
         }
         for(var i = 0; i < updatedArray.length; i++){
             updatedArray[i] = weightsArray[i];
@@ -3120,7 +3121,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);
     };
@@ -3261,8 +3262,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);
             }
         }
@@ -3623,7 +3623,7 @@ var EffectsMeshProxy = /*#__PURE__*/ function() {
         this.brdfLUT = this.sceneCache.getBrdfLutTexture();
         this.initGlobalState(opts);
         if (this.maxLightCount > 8) {
-            console.warn("Too many light items: " + this.maxLightCount + " light(s)");
+            console.warn("Too many light items: " + this.maxLightCount + " light(s).");
         }
     };
     _proto.initGlobalState = function initGlobalState(opts) {
@@ -3768,9 +3768,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;
     };
@@ -3779,12 +3779,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;
@@ -3792,26 +3794,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;
         }
@@ -3956,7 +3962,7 @@ var StandardShaderSource;
         if (isWebGL2) {
             return "#version 300 es\n" + source;
         } else {
-            return "#version 100\n" + source;
+            return source;
         }
     }
     /**
@@ -3973,9 +3979,8 @@ var StandardShaderSource;
         }
         if (isWebGL2) {
             return "#version 300 es\n" + source;
-        } else {
-            return "#version 100\n" + source;
         }
+        return source;
     }
     StandardShaderSource.getSourceCode = getSourceCode;
 })(StandardShaderSource || (StandardShaderSource = {}));
@@ -4253,7 +4258,7 @@ function getQuadFilterVS() {
         if (func !== undefined) {
             return func(context);
         } else {
-            throw new Error("Invalid material type " + materialType + ", shader content " + context);
+            throw new Error("Invalid material type " + materialType + ", shader content " + context + ".");
         }
     };
     /**
@@ -4703,7 +4708,8 @@ var ModelCameraComponent = /*#__PURE__*/ function(ItemBehaviour) {
     /**
    * 组件销毁
    */ _proto.onDestroy = function onDestroy() {
-        this.content.dispose();
+        var _this_content;
+        (_this_content = this.content) == null ? void 0 : _this_content.dispose();
     };
     /**
    * 反序列化，记录传入参数
@@ -4820,29 +4826,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(ModelMeshComponent);
@@ -4850,14 +4852,15 @@ var ModelAnimationClip = /*#__PURE__*/ function(AnimationClip) {
                     var properties = curve3.property.split(".");
                     setProperty(component, properties, value3);
                 } else {
-                    console.error("Can't find mesh component");
+                    console.error("Can't find mesh component.");
                 }
             } else {
-                console.warn("Ignore curve: className " + curve3.className);
+                console.warn("Ignore curve: className " + curve3.className + ".");
             }
         }
     };
     _proto.setFromAnimationClip = function setFromAnimationClip(clip) {
+        this.duration = clip.duration;
         this.positionCurves = clip.positionCurves.slice();
         this.rotationCurves = clip.rotationCurves.slice();
         this.scaleCurves = clip.scaleCurves.slice();
@@ -4881,7 +4884,7 @@ var ModelAnimationClip = /*#__PURE__*/ function(AnimationClip) {
                 }
             }
             if (!findTag) {
-                throw new Error("Can't find path in tree " + rootItem.id + ", " + path);
+                throw new Error("Can't find path in tree " + rootItem.id + ", " + path + ".");
             }
         }
         this.path2Node[path] = target;
@@ -4895,7 +4898,7 @@ function setProperty(obj, properties, value) {
     for(var i = 0; i < len - 1; i++){
         var propName = properties[i];
         if (!(propName in current) || typeof current[propName] !== "object") {
-            console.error("Invalid properties " + properties);
+            console.error("Invalid properties " + properties + ".");
             return;
         }
         current = current[propName];
@@ -5138,7 +5141,7 @@ var normal = new Vector3();
             var blob, urlCreator, imageUrl, imageObj;
             return __generator(this, function(_state) {
                 if (image.imageData === undefined) {
-                    console.error("createTexture2D: Invalid image data from " + image);
+                    console.error("createTexture2D: Invalid image data from " + image + ".");
                     // 这里不应该发生的，做个兜底
                     return [
                         2,
@@ -5613,10 +5616,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 纹理
@@ -6078,10 +6081,17 @@ var normal = new Vector3();
             texOptions.wrapT = glContext.REPEAT;
             texOptions.magFilter = glContext.LINEAR;
             texOptions.minFilter = 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 = glContext.LINEAR;
+                }
+            }
         } else if (texOptions.target === glContext.TEXTURE_CUBE_MAP) {
             texOptions.wrapS = glContext.CLAMP_TO_EDGE;
             texOptions.wrapT = glContext.CLAMP_TO_EDGE;
@@ -6157,7 +6167,7 @@ var normal = new Vector3();
                         if (_instanceof1(inverseBindMatrices, Float32Array)) {
                             studioSkin.inverseBindMatrices = inverseBindMatrices;
                         } else {
-                            console.error("setupItem3DOptions: Invalid inverseBindMatrices type, " + inverseBindMatrices);
+                            console.error("setupItem3DOptions: Invalid inverseBindMatrices type, " + inverseBindMatrices + ".");
                         }
                     }
                 } else if (item.type === spec.ItemType.tree) {
@@ -6175,12 +6185,12 @@ var normal = new Vector3();
                                 if (_instanceof1(inputArray, Float32Array)) {
                                     studioTrack.input = inputArray;
                                 } else {
-                                    console.error("setupItem3DOptions: Type of inputArray should be float32, " + inputArray);
+                                    console.error("setupItem3DOptions: Type of inputArray should be float32, " + inputArray + ".");
                                 }
                                 if (_instanceof1(outputArray, Float32Array)) {
                                     studioTrack.output = outputArray;
                                 } else {
-                                    console.error("setupItem3DOptions: Type of outputArray should be float32, " + outputArray);
+                                    console.error("setupItem3DOptions: Type of outputArray should be float32, " + outputArray + ".");
                                 }
                             });
                         });
@@ -6192,7 +6202,7 @@ var normal = new Vector3();
                     var studioOptions = studioSkybox.content.options;
                     var specularImage = _this.getTextureObj(composition.textures, options.specularImage);
                     if (specularImage === undefined) {
-                        console.error("setupItem3DOptions: skybox specualrImage is undefined, " + CheckerHelper.stringify(options));
+                        console.error("setupItem3DOptions: skybox specualrImage is undefined, " + CheckerHelper.stringify(options) + ".");
                     }
                     studioOptions.specularImage = specularImage;
                     //
@@ -6236,7 +6246,7 @@ var normal = new Vector3();
             case WebGLRenderingContext["UNSIGNED_BYTE"]:
                 return array;
             default:
-                console.error("Invalid index attribute type " + type);
+                console.error("Invalid index attribute type " + type + ".");
         }
     };
     /**
@@ -6264,7 +6274,7 @@ var normal = new Vector3();
             // aPos, aNormal, aTangent,
             // aUV, aUV2, aJoints, aWeights
             // aTargetXXX
-            console.warn("Unknown attribute name: " + name);
+            console.warn("Unknown attribute name: " + name + ".");
         }
         return name;
     };
@@ -6278,7 +6288,7 @@ var normal = new Vector3();
             return null;
         }
         if (index < 0 || index >= textures.length) {
-            console.error("Invalid index for textures: " + index + ", " + textures.length);
+            console.error("Invalid index for textures: " + index + ", " + textures.length + ".");
         }
         return textures[index];
     };
@@ -6404,7 +6414,7 @@ var normal = new Vector3();
                             if (b) {
                                 resolve(b.arrayBuffer());
                             } else {
-                                reject(new Error("no canvas blob"));
+                                reject(new Error("No canvas blob."));
                             }
                         }, "image/png", 1);
                     })
@@ -6566,7 +6576,7 @@ var AttributeArray = /*#__PURE__*/ function() {
         this.offset = (_inAttrib_offset = inAttrib.offset) != null ? _inAttrib_offset : 0;
         if (this.offset > 0) {
             if (this.offset % this.typeSize !== 0) {
-                console.error("Invalid offset " + this.offset + ", type size " + this.typeSize);
+                console.error("Invalid offset " + this.offset + ", type size " + this.typeSize + ".");
             }
             this.offset = this.offset / this.typeSize;
         }
@@ -6575,7 +6585,7 @@ var AttributeArray = /*#__PURE__*/ function() {
         this.stride = (_inAttrib_stride = inAttrib.stride) != null ? _inAttrib_stride : 0;
         if (this.stride > 0) {
             if (this.stride % this.typeSize !== 0) {
-                console.error("Invalid stride " + this.stride + ", type size " + this.typeSize);
+                console.error("Invalid stride " + this.stride + ", type size " + this.typeSize + ".");
             }
             this.stride = this.stride / this.typeSize;
         } else {
@@ -7088,7 +7098,7 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.checkTexture = function checkTexture(v) {
         if (_instanceof1(v, Texture)) {
             if (v.isDestroyed) {
-                console.error("Texture is destroyed, " + v.name);
+                console.error("Texture is destroyed, " + v.name + ".");
             }
             return !v.isDestroyed;
         } else {
@@ -7165,14 +7175,14 @@ var AttributeArray = /*#__PURE__*/ function() {
    * @param s - 蒙皮参数
    */ CheckerHelper.assertGeometry = function assertGeometry(v, s) {
         if (!_instanceof1(v, Geometry)) {
-            console.error("Invalid geometry type " + this.stringify(v));
+            console.error("Invalid geometry type " + this.stringify(v) + ".");
         }
         // @ts-expect-error
         if (v.isDestroyed === true) {
-            console.error("Geometry object is destroyed");
+            console.error("Geometry object is destroyed.");
         }
         if (!this.checkNonnegative(v.getDrawStart())) {
-            console.error("Invalid geometry draw start: " + v.getDrawStart() + ", " + this.stringify(v));
+            console.error("Invalid geometry draw start: " + v.getDrawStart() + ", " + this.stringify(v) + ".");
         }
     // // drawCount不再为负
     // if (!this.checkPositive(v.getDrawCount())) {
@@ -7231,7 +7241,7 @@ var AttributeArray = /*#__PURE__*/ function() {
         var attribArray = this.createAttributeArray(v, name);
         if (attribArray !== undefined) {
             if (attribArray.getLength() < drawCount) {
-                console.error(name + " Length(" + attribArray.getLength() + ") is less than draw count(" + drawCount + "), " + this.stringify(v));
+                console.error(name + " Length(" + attribArray.getLength() + ") is less than draw count(" + drawCount + "), " + this.stringify(v) + ".");
             }
         }
     };
@@ -7264,24 +7274,24 @@ var AttributeArray = /*#__PURE__*/ function() {
    * @param v - 蒙皮参数
    */ CheckerHelper.assertModelSkinOptions = function assertModelSkinOptions(v) {
         if (!this.checkStringUndef(v.name)) {
-            console.error("Invalid skin name " + v.name + ", " + this.stringify(v));
+            console.error("Invalid skin name " + v.name + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNumberArray(v.joints)) {
-            console.error("Invalid skin joints " + v.joints + ", " + this.stringify(v));
+            console.error("Invalid skin joints " + v.joints + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNumberUndef(v.skeleton)) {
-            console.error("Invalid skin skeleton " + v.skeleton + ", " + this.stringify(v));
+            console.error("Invalid skin skeleton " + v.skeleton + ", " + this.stringify(v) + ".");
         }
         if (!this.checkFloat32ArrayUndef(v.inverseBindMatrices)) {
-            console.error("Invalid skin inverseBindMatrices " + v.inverseBindMatrices + ", " + this.stringify(v));
+            console.error("Invalid skin inverseBindMatrices " + v.inverseBindMatrices + ", " + this.stringify(v) + ".");
         }
         //
         if (v.inverseBindMatrices !== undefined) {
             if (v.inverseBindMatrices.length <= 0 || v.inverseBindMatrices.length % 16 !== 0) {
-                console.error("Invalid skin inverseBindMatrices length " + v.inverseBindMatrices + ", " + this.stringify(v));
+                console.error("Invalid skin inverseBindMatrices length " + v.inverseBindMatrices + ", " + this.stringify(v) + ".");
             }
             if (v.joints.length * 16 !== v.inverseBindMatrices.length) {
-                console.error("Mismatch: skin joints and inverseBindMatrices length, " + v.joints + ", " + v.inverseBindMatrices + ", " + this.stringify(v));
+                console.error("Mismatch: skin joints and inverseBindMatrices length, " + v.joints + ", " + v.inverseBindMatrices + ", " + this.stringify(v) + ".");
             }
             var mat = new Matrix4();
             for(var i = 0; i < v.inverseBindMatrices.length; i += 16){
@@ -7289,12 +7299,12 @@ var AttributeArray = /*#__PURE__*/ function() {
                     mat.elements[j] = v.inverseBindMatrices[i + j];
                 }
                 if (Math.abs(mat.determinant()) < 1e-5) {
-                    console.error("Determinant of inverseBindMatrices is too small " + mat.determinant() + ", index " + i / 16 + ", " + this.stringify(v));
+                    console.error("Determinant of inverseBindMatrices is too small " + mat.determinant() + ", index " + i / 16 + ", " + this.stringify(v) + ".");
                 }
             }
         } else {
             if (v.joints.length <= 0) {
-                console.error("Invalid skin joints length " + v.joints + ", " + this.stringify(v));
+                console.error("Invalid skin joints length " + v.joints + ", " + this.stringify(v) + ".");
             }
         }
     };
@@ -7304,138 +7314,138 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.assertMatOptions = function assertMatOptions(v) {
         if (v.type === spec.MaterialType.unlit) {
             if (!this.checkString(v.name)) {
-                console.error("Invalid material name " + v.name + ", " + this.stringify(v));
+                console.error("Invalid material name " + v.name + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkNonnegative4(v.baseColorFactor)) {
-                console.error("Invalid material baseColorFactor " + v.baseColorFactor + ", " + this.stringify(v));
+                console.error("Invalid material baseColorFactor " + v.baseColorFactor + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTextureUndef(v.baseColorTexture)) {
-                console.error("Invalid material baseColorTexture " + v.baseColorTexture + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTexture " + v.baseColorTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.baseColorTextureTransform)) {
-                console.error("Invalid material baseColorTextureTransform " + v.baseColorTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTextureTransform " + v.baseColorTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.baseColorTextureCoordinate)) {
-                console.error("Invalid material baseColorTextureCoordinate " + v.baseColorTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTextureCoordinate " + v.baseColorTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkBooleanUndef(v.depthMask)) {
-                console.error("Invalid material depthMask " + v.depthMask + ", " + this.stringify(v));
+                console.error("Invalid material depthMask " + v.depthMask + ", " + this.stringify(v) + ".");
             }
             if (!this.checkMatBlending(v.blending)) {
-                console.error("Invalid material blending " + v.blending + ", " + this.stringify(v));
+                console.error("Invalid material blending " + v.blending + ", " + this.stringify(v) + ".");
             }
             if (!this.checkMatSide(v.side)) {
-                console.error("Invalid material side " + v.side + ", " + this.stringify(v));
+                console.error("Invalid material side " + v.side + ", " + this.stringify(v) + ".");
             }
             if (v.blending === spec.MaterialBlending.masked) {
                 if (v.alphaCutOff === undefined) {
-                    console.error("Material alphaCutOff is required for mask, " + this.stringify(v));
+                    console.error("Material alphaCutOff is required for mask, " + this.stringify(v) + ".");
                 }
             }
             if (!this.checkNumber01Undef(v.alphaCutOff)) {
-                console.error("Invalid material alphaCutOff " + v.alphaCutOff + ", " + this.stringify(v));
+                console.error("Invalid material alphaCutOff " + v.alphaCutOff + ", " + this.stringify(v) + ".");
             }
         } else if (v.type === spec.MaterialType.pbr) {
             if (!this.checkString(v.name)) {
-                console.error("Invalid material name " + v.name + ", " + this.stringify(v));
+                console.error("Invalid material name " + v.name + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkNonnegative4(v.baseColorFactor)) {
-                console.error("Invalid material baseColorFactor " + v.baseColorFactor + ", " + this.stringify(v));
+                console.error("Invalid material baseColorFactor " + v.baseColorFactor + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTextureUndef(v.baseColorTexture)) {
-                console.error("Invalid material baseColorTexture " + v.baseColorTexture + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTexture " + v.baseColorTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.baseColorTextureTransform)) {
-                console.error("Invalid material baseColorTextureTransform " + v.baseColorTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTextureTransform " + v.baseColorTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.baseColorTextureCoordinate)) {
-                console.error("Invalid material baseColorTextureCoordinate " + v.baseColorTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material baseColorTextureCoordinate " + v.baseColorTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkBooleanUndef(v.useSpecularAA)) {
-                console.error("Invalid material useSpecularAA " + v.useSpecularAA + ", " + this.stringify(v));
+                console.error("Invalid material useSpecularAA " + v.useSpecularAA + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNumber01(v.metallicFactor)) {
-                console.error("Invalid material metallicFactor " + v.metallicFactor + ", " + this.stringify(v));
+                console.error("Invalid material metallicFactor " + v.metallicFactor + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.roughnessFactor)) {
-                console.error("Invalid material roughnessFactor " + v.roughnessFactor + ", " + this.stringify(v));
+                console.error("Invalid material roughnessFactor " + v.roughnessFactor + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTextureUndef(v.metallicRoughnessTexture)) {
-                console.error("Invalid material metallicRoughnessTexture " + v.metallicRoughnessTexture + ", " + this.stringify(v));
+                console.error("Invalid material metallicRoughnessTexture " + v.metallicRoughnessTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.metallicRoughnessTextureTransform)) {
-                console.error("Invalid material metallicRoughnessTextureTransform " + v.metallicRoughnessTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material metallicRoughnessTextureTransform " + v.metallicRoughnessTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.metallicRoughnessTextureCoordinate)) {
-                console.error("Invalid material metallicRoughnessTextureCoordinate " + v.metallicRoughnessTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material metallicRoughnessTextureCoordinate " + v.metallicRoughnessTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkTextureUndef(v.normalTexture)) {
-                console.error("Invalid material normalTexture " + v.normalTexture + ", " + this.stringify(v));
+                console.error("Invalid material normalTexture " + v.normalTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegativeUndef(v.normalTextureScale)) {
-                console.error("Invalid material normalTextureScale " + v.normalTextureScale + ", " + this.stringify(v));
+                console.error("Invalid material normalTextureScale " + v.normalTextureScale + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.normalTextureTransform)) {
-                console.error("Invalid material normalTextureTransform " + v.normalTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material normalTextureTransform " + v.normalTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.normalTextureCoordinate)) {
-                console.error("Invalid material normalTextureCoordinate " + v.normalTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material normalTextureCoordinate " + v.normalTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkTextureUndef(v.occlusionTexture)) {
-                console.error("Invalid material occlusionTexture " + v.occlusionTexture + ", " + this.stringify(v));
+                console.error("Invalid material occlusionTexture " + v.occlusionTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNumber01Undef(v.occlusionTextureStrength)) {
-                console.error("Invalid material occlusionTextureStrength " + v.occlusionTextureStrength + ", " + this.stringify(v));
+                console.error("Invalid material occlusionTextureStrength " + v.occlusionTextureStrength + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.occlusionTextureTransform)) {
-                console.error("Invalid material occlusionTextureTransform " + v.occlusionTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material occlusionTextureTransform " + v.occlusionTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.occlusionTextureCoordinate)) {
-                console.error("Invalid material occlusionTextureCoordinate " + v.occlusionTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material occlusionTextureCoordinate " + v.occlusionTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             //
             if (!this.checkNonnegative4(v.emissiveFactor)) {
-                console.error("Invalid material emissiveFactor " + v.emissiveFactor + ", " + this.stringify(v));
+                console.error("Invalid material emissiveFactor " + v.emissiveFactor + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.emissiveIntensity)) {
-                console.error("Invalid material emissiveIntensity " + v.emissiveIntensity + ", " + this.stringify(v));
+                console.error("Invalid material emissiveIntensity " + v.emissiveIntensity + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTextureUndef(v.emissiveTexture)) {
-                console.error("Invalid material emissiveTexture " + v.emissiveTexture + ", " + this.stringify(v));
+                console.error("Invalid material emissiveTexture " + v.emissiveTexture + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexTransformUndef(v.emissiveTextureTransform)) {
-                console.error("Invalid material emissiveTextureTransform " + v.emissiveTextureTransform + ", " + this.stringify(v));
+                console.error("Invalid material emissiveTextureTransform " + v.emissiveTextureTransform + ", " + this.stringify(v) + ".");
             }
             if (!this.checkTexCoord(v.emissiveTextureCoordinate)) {
-                console.error("Invalid material emissiveTextureCoordinate " + v.emissiveTextureCoordinate + ", " + this.stringify(v));
+                console.error("Invalid material emissiveTextureCoordinate " + v.emissiveTextureCoordinate + ", " + this.stringify(v) + ".");
             }
             //
             if (!this.checkBooleanUndef(v.depthMask)) {
-                console.error("Invalid material depthMask " + v.depthMask + ", " + this.stringify(v));
+                console.error("Invalid material depthMask " + v.depthMask + ", " + this.stringify(v) + ".");
             }
             if (!this.checkMatBlending(v.blending)) {
-                console.error("Invalid material blending " + v.blending + ", " + this.stringify(v));
+                console.error("Invalid material blending " + v.blending + ", " + this.stringify(v) + ".");
             }
             if (!this.checkMatSide(v.side)) {
-                console.error("Invalid material side " + v.side + ", " + this.stringify(v));
+                console.error("Invalid material side " + v.side + ", " + this.stringify(v) + ".");
             }
             if (v.blending === spec.MaterialBlending.masked) {
                 if (v.alphaCutOff === undefined) {
-                    console.error("Material alphaCutOff is required for mask, " + this.stringify(v));
+                    console.error("Material alphaCutOff is required for mask, " + this.stringify(v) + ".");
                 }
             }
             if (!this.checkNumber01Undef(v.alphaCutOff)) {
-                console.error("Invalid material alphaCutOff " + v.alphaCutOff + ", " + this.stringify(v));
+                console.error("Invalid material alphaCutOff " + v.alphaCutOff + ", " + this.stringify(v) + ".");
             }
         } else {
-            console.error("Invalid material type " + this.stringify(v));
+            console.error("Invalid material type " + this.stringify(v) + ".");
         }
     };
     /**
@@ -7453,7 +7463,7 @@ var AttributeArray = /*#__PURE__*/ function() {
    * @param v - Model 插件 Mesh 参数
    */ CheckerHelper.assertModelMeshOptions = function assertModelMeshOptions(v) {
         if (!this.checkParent(v.parent)) {
-            console.error("Invalid mesh parent " + v.parent + ", " + this.stringify(v));
+            console.error("Invalid mesh parent " + v.parent + ", " + this.stringify(v) + ".");
         }
         if (v.skin !== undefined) {
             this.assertModelSkinOptions(v.skin);
@@ -7462,7 +7472,7 @@ var AttributeArray = /*#__PURE__*/ function() {
         for(var i = 0; i < v.primitives.length; i++){
             var prim = v.primitives[i];
             if (!this.assertPrimOptions(prim)) {
-                console.error("Invalid primitive " + prim + ", " + this.stringify(v));
+                console.error("Invalid primitive " + prim + ", " + this.stringify(v) + ".");
             }
             var morph = new PMorph();
             morph.create(prim.geometry);
@@ -7472,11 +7482,11 @@ var AttributeArray = /*#__PURE__*/ function() {
             var morph0 = morphList[i1 - 1];
             var morph1 = morphList[i1];
             if (!morph0.equals(morph1)) {
-                console.error("Morph states mismatch: " + this.stringify(morph0) + ", " + this.stringify(morph1) + ", " + this.stringify(v));
+                console.error("Morph states mismatch: " + this.stringify(morph0) + ", " + this.stringify(morph1) + ", " + this.stringify(v) + ".");
             }
         }
         if (!this.checkBooleanUndef(v.hide)) {
-            console.error("Invalid mesh hide " + v.hide + ", " + this.stringify(v));
+            console.error("Invalid mesh hide " + v.hide + ", " + this.stringify(v) + ".");
         }
     };
     /**
@@ -7484,22 +7494,22 @@ var AttributeArray = /*#__PURE__*/ function() {
    * @param v - Model 插件相机参数
    */ CheckerHelper.assertModelCameraOptions = function assertModelCameraOptions(v) {
         if (!this.checkParent(v.parent)) {
-            console.error("Invalid camera parent " + v.parent + ", " + this.stringify(v));
+            console.error("Invalid camera parent " + v.parent + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNumberUndef(v.aspect)) {
-            console.error("Invalid camera aspect " + v.aspect + ", " + this.stringify(v));
+            console.error("Invalid camera aspect " + v.aspect + ", " + this.stringify(v) + ".");
         }
         if (!this.checkPositive(v.near)) {
-            console.error("Invalid camera near " + v.near + ", " + this.stringify(v));
+            console.error("Invalid camera near " + v.near + ", " + this.stringify(v) + ".");
         }
         if (!this.checkPositive(v.far) || v.far <= v.near) {
-            console.error("Invalid camera far " + v.far + ", " + this.stringify(v));
+            console.error("Invalid camera far " + v.far + ", " + this.stringify(v) + ".");
         }
         if (!this.checkPositive(v.fov)) {
-            console.error("Invalid camera fov " + v.fov + ", " + this.stringify(v));
+            console.error("Invalid camera fov " + v.fov + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNumber01(v.clipMode)) {
-            console.error("Invalid camera clipMode " + v.clipMode + ", " + this.stringify(v));
+            console.error("Invalid camera clipMode " + v.clipMode + ", " + this.stringify(v) + ".");
         }
     };
     /**
@@ -7508,58 +7518,58 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.assertModelLightOptions = function assertModelLightOptions(v) {
         if (v.lightType === "directional") {
             if (!this.checkParent(v.parent)) {
-                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v));
+                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative4(v.color)) {
-                console.error("Invalid light color " + v.color + ", " + this.stringify(v));
+                console.error("Invalid light color " + v.color + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.intensity)) {
-                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v));
+                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v) + ".");
             }
         } else if (v.lightType === "point") {
             if (!this.checkParent(v.parent)) {
-                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v));
+                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative4(v.color)) {
-                console.error("Invalid light color " + v.color + ", " + this.stringify(v));
+                console.error("Invalid light color " + v.color + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.intensity)) {
-                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v));
+                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.range)) {
-                console.error("Invalid light range " + v.range + ", " + this.stringify(v));
+                console.error("Invalid light range " + v.range + ", " + this.stringify(v) + ".");
             }
         } else if (v.lightType === "spot") {
             if (!this.checkParent(v.parent)) {
-                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v));
+                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative4(v.color)) {
-                console.error("Invalid light color " + v.color + ", " + this.stringify(v));
+                console.error("Invalid light color " + v.color + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.intensity)) {
-                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v));
+                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.range)) {
-                console.error("Invalid light range " + v.range + ", " + this.stringify(v));
+                console.error("Invalid light range " + v.range + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.innerConeAngle)) {
-                console.error("Invalid light innerConeAngle " + v.innerConeAngle + ", " + this.stringify(v));
+                console.error("Invalid light innerConeAngle " + v.innerConeAngle + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.outerConeAngle)) {
-                console.error("Invalid light outerConeAngle " + v.outerConeAngle + ", " + this.stringify(v));
+                console.error("Invalid light outerConeAngle " + v.outerConeAngle + ", " + this.stringify(v) + ".");
             }
         } else if (v.lightType === "ambient") {
             if (!this.checkParent(v.parent)) {
-                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v));
+                console.error("Invalid light parent " + v.parent + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative4(v.color)) {
-                console.error("Invalid light color " + v.color + ", " + this.stringify(v));
+                console.error("Invalid light color " + v.color + ", " + this.stringify(v) + ".");
             }
             if (!this.checkNonnegative(v.intensity)) {
-                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v));
+                console.error("Invalid light intensity " + v.intensity + ", " + this.stringify(v) + ".");
             }
         } else {
-            console.error("Invalid light type " + this.stringify(v));
+            console.error("Invalid light type " + this.stringify(v) + ".");
         }
     };
     /**
@@ -7568,43 +7578,43 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.assertModelSkyboxOptions = function assertModelSkyboxOptions(v) {
         var _this = this;
         if (!this.checkBoolean(v.renderable)) {
-            console.error("Invalid skybox renderable " + v.renderable + ", " + this.stringify(v));
+            console.error("Invalid skybox renderable " + v.renderable + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNonnegative(v.intensity)) {
-            console.error("Invalid skybox intensity " + v.intensity + ", " + this.stringify(v));
+            console.error("Invalid skybox intensity " + v.intensity + ", " + this.stringify(v) + ".");
         }
         if (!this.checkNonnegative(v.reflectionsIntensity)) {
-            console.error("Invalid skybox reflectionsIntensity " + v.reflectionsIntensity + ", " + this.stringify(v));
+            console.error("Invalid skybox reflectionsIntensity " + v.reflectionsIntensity + ", " + this.stringify(v) + ".");
         }
         //
         var c = v.irradianceCoeffs;
         if (c !== undefined) {
             if (!Array.isArray(c) || c.length != 9) {
-                console.error("Invalid skybox irradianceCoeffs " + c + ", " + this.stringify(v));
+                console.error("Invalid skybox irradianceCoeffs " + c + ", " + this.stringify(v) + ".");
             }
             c.forEach(function(v) {
                 if (!_this.checkVec3(v)) {
-                    console.error("Invalid skybox irradianceCoeffs " + c + ", " + _this.stringify(v));
+                    console.error("Invalid skybox irradianceCoeffs " + c + ", " + _this.stringify(v) + ".");
                 }
             });
         } else if (v.diffuseImage !== undefined) {
             if (!this.checkTexture(v.diffuseImage)) {
-                console.error("Invalid skybox diffuseImage " + v.diffuseImage + ", " + this.stringify(v));
+                console.error("Invalid skybox diffuseImage " + v.diffuseImage + ", " + this.stringify(v) + ".");
             }
         } else {
-            console.error("Invalid skybox, irradianceCoeffs or diffuseImage should give one, " + this.stringify(v));
+            console.error("Invalid skybox, irradianceCoeffs or diffuseImage should give one, " + this.stringify(v) + ".");
         }
         if (!this.checkTexture(v.specularImage)) {
-            console.error("Invalid skybox specularImage " + v.specularImage + ", " + this.stringify(v));
+            console.error("Invalid skybox specularImage " + v.specularImage + ", " + this.stringify(v) + ".");
         }
         if (!this.checkPositive(v.specularImageSize)) {
-            console.error("Invalid skybox specularImageSize " + v.specularImageSize + ", " + this.stringify(v));
+            console.error("Invalid skybox specularImageSize " + v.specularImageSize + ", " + this.stringify(v) + ".");
         }
         if (!this.checkPositive(v.specularMipCount)) {
-            console.error("Invalid skybox specularMipCount " + v.specularMipCount + ", " + this.stringify(v));
+            console.error("Invalid skybox specularMipCount " + v.specularMipCount + ", " + this.stringify(v) + ".");
         }
         if (this.pow2(v.specularMipCount) > v.specularImageSize) {
-            console.error("Invalid skybox specularMipCount or specularImageSize, " + this.stringify(v));
+            console.error("Invalid skybox specularMipCount or specularImageSize, " + this.stringify(v) + ".");
         }
     };
     /**
@@ -7640,14 +7650,14 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.assertModelAnimOptions = function assertModelAnimOptions(v) {
         var _this = this;
         if (!this.checkStringUndef(v.name)) {
-            console.error("Invalid animation name " + v.name + ", " + this.stringify(v));
+            console.error("Invalid animation name " + v.name + ", " + this.stringify(v) + ".");
         }
         if (!Array.isArray(v.tracks)) {
-            console.error("Invalid animation tracks " + v.tracks + ", " + this.stringify(v));
+            console.error("Invalid animation tracks " + v.tracks + ", " + this.stringify(v) + ".");
         }
         v.tracks.forEach(function(t) {
             if (!_this.checkModelAnimTrackOptions(t)) {
-                console.error("Invalid animation track " + t + ", " + _this.stringify(v));
+                console.error("Invalid animation track " + t + ", " + _this.stringify(v) + ".");
             }
         });
     };
@@ -7657,18 +7667,18 @@ var AttributeArray = /*#__PURE__*/ function() {
    */ CheckerHelper.assertTreeOptions = function assertTreeOptions(v) {
         var _this = this;
         if (!this.checkNumberUndef(v.animation)) {
-            console.error("Invalid tree animation " + v.animation + ", " + this.stringify(v));
+            console.error("Invalid tree animation " + v.animation + ", " + this.stringify(v) + ".");
         }
         if (v.animations !== undefined) {
             if (!Array.isArray(v.animations)) {
-                console.error("Invalid tree animations " + v.animations + ", " + this.stringify(v));
+                console.error("Invalid tree animations " + v.animations + ", " + this.stringify(v) + ".");
             }
             v.animations.forEach(function(anim) {
                 _this.assertModelAnimOptions(anim);
             });
             if (v.animation !== undefined) {
                 if (v.animation < -1 || v.animation >= v.animations.length) {
-                    console.error("Invalid tree animations " + v.animations + ", " + this.stringify(v));
+                    console.error("Invalid tree animations " + v.animations + ", " + this.stringify(v) + ".");
                 }
             }
         }
@@ -7780,18 +7790,6 @@ var toHalf = function() {
     };
 }();
 
-var RenderType;
-(function(RenderType) {
-    RenderType["Opaque"] = "Opaque";
-    RenderType["Mask"] = "Mask";
-    RenderType["Blend"] = "Blend";
-})(RenderType || (RenderType = {}));
-var CullMode;
-(function(CullMode) {
-    CullMode["Front"] = "Front";
-    CullMode["Back"] = "Back";
-    CullMode["Double"] = "Double";
-})(CullMode || (CullMode = {}));
 /**
  * 3D 材质基础类，支持公共的材质功能
  */ var PMaterialBase = /*#__PURE__*/ function(PObject) {
@@ -7816,13 +7814,16 @@ var CullMode;
    */ _this.ZTest = true;
         /**
    * 渲染类型，默认是不透明
-   */ _this.renderType = "Opaque";
+   */ _this.renderType = spec.RenderType.Opaque;
+        /**
+   * 是否 Alpha 裁剪，默认关闭
+   */ _this.alphaClip = false;
         /**
    * Alpha 测试截断值
-   */ _this.alphaCutOff = 0.5;
+   */ _this.alphaCutoff = 0.5;
         /**
    * 面侧模式，默认是正面
-   */ _this.cullMode = "Front";
+   */ _this.renderFace = spec.RenderFace.Front;
         return _this;
     }
     var _proto = PMaterialBase.prototype;
@@ -7831,28 +7832,28 @@ var CullMode;
    * @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 === 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 === spec.RenderFace.Both) {
             macroList.push({
                 name: "DOUBLE_SIDED"
             });
@@ -7935,7 +7936,7 @@ var CullMode;
    * 设置材质状态，根据 GE 材质状态
    * @param material - GE 材质
    */ _proto.setMaterialStates = function setMaterialStates(material) {
-        if (this.renderType === "Blend") {
+        if (this.renderType === spec.RenderType.Transparent) {
             material.blending = true;
             material.depthTest = this.ZTest;
             material.depthMask = this.ZWrite;
@@ -7964,7 +7965,7 @@ var CullMode;
         this.setFaceSideStates(material);
     };
     _proto.setFaceSideStates = function setFaceSideStates(material) {
-        if (this.isDoubleSide()) {
+        if (this.isBothSide()) {
             material.culling = false;
         } else if (this.isBackSide()) {
             material.cullFace = glContext.FRONT;
@@ -7992,37 +7993,37 @@ var CullMode;
    * 是否不透明
    * @returns
    */ _proto.isOpaque = function isOpaque() {
-        return this.renderType === "Opaque";
+        return this.renderType === 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 === spec.RenderType.Transparent;
     };
     /**
    * 是否正面模式
    * @returns
    */ _proto.isFrontSide = function isFrontSide() {
-        return this.cullMode === "Front";
+        return this.renderFace === spec.RenderFace.Front;
     };
     /**
    * 是否背面模式
    * @returns
    */ _proto.isBackSide = function isBackSide() {
-        return this.cullMode === "Back";
+        return this.renderFace === spec.RenderFace.Back;
     };
     /**
    * 是否双面模式
    * @returns
-   */ _proto.isDoubleSide = function isDoubleSide() {
-        return this.cullMode === "Double";
+   */ _proto.isBothSide = function isBothSide() {
+        return this.renderFace === spec.RenderFace.Both;
     };
     return PMaterialBase;
 }(PObject);
@@ -8054,14 +8055,15 @@ var CullMode;
         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 : 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 : spec.RenderFace.Front;
     };
     /**
    * 销毁材质
@@ -8229,14 +8231,15 @@ var CullMode;
         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 : 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 : spec.RenderFace.Front;
     };
     /**
    * 销毁材质
@@ -8683,7 +8686,7 @@ var CullMode;
                 if (this.irradianceCoeffs === undefined && this.diffuseImage === undefined) {
                     return false;
                 }
-                return this.specularImage !== undefined && this.specularMipCount > 0;
+                return this.specularImage !== undefined && this.specularMipCount >= 0;
             }
         },
         {
@@ -8793,7 +8796,7 @@ var CullMode;
         } else {
             var coeffs = this.irradianceCoeffs;
             if (coeffs === undefined || coeffs.length != 9) {
-                throw new Error("Invalid skybox irradiance coeffs " + coeffs);
+                throw new Error("Invalid skybox irradiance coeffs " + coeffs + ".");
             }
             var aliasName = [
                 "l00",
@@ -8810,7 +8813,7 @@ var CullMode;
                 material.setVector3("_shCoefficients." + n, Vector3.fromArray(coeffs[i]));
             });
         }
-        material.setInt("_MipCount", this.specularMipCount);
+        material.setInt("_MipCount", this.specularMipCount - 1);
         material.setTexture("_SpecularEnvSampler", this.specularImage);
     };
     /**
@@ -8856,11 +8859,11 @@ var PSkyboxType;
                         if (i > 0) {
                             if (i % 6 === 0) {
                                 if (image.width * 2 !== lastImage.width || image.height * 2 !== lastImage.height) {
-                                    throw new Error("Invalid cube map list1: index " + i + ", image0 " + lastImage + ", image1 " + image);
+                                    throw new Error("Invalid cube map list1: index " + i + ", image0 " + lastImage + ", image1 " + image + ".");
                                 }
                             } else {
                                 if (image.width !== lastImage.width || image.height !== lastImage.height) {
-                                    throw new Error("Invalid cube map list2: index " + i + ", image0 " + lastImage + ", image1 " + image);
+                                    throw new Error("Invalid cube map list2: index " + i + ", image0 " + lastImage + ", image1 " + image + ".");
                                 }
                             }
                         }
@@ -9176,7 +9179,7 @@ var PSkyboxType;
             diffuseImage: this.getDiffuseImageList(skyboxType, specularImage),
             specularImage: specularImage,
             specularImageSize: Math.pow(2, specularImage.length - 1),
-            specularMipCount: specularImage.length - 1
+            specularMipCount: specularImage.length
         };
         return params;
     };
@@ -9394,7 +9397,7 @@ var PSkyboxType;
         this.loadSkybox = loadSkybox;
         if (this.brdfLutTexture === undefined || this.brdfLutTexture.isDestroyed) {
             if (CompositionCache.brdfLutTexOptions === undefined) {
-                throw new Error("Please load brdfLutTexOptions at first");
+                throw new Error("Please load brdfLutTexOptions at first.");
             }
             //
             var brdfLutTextureName = "brdfLutTexture";
@@ -9803,8 +9806,8 @@ var ModelPluginComponent = /*#__PURE__*/ function(ItemBehaviour) {
                         var newPosition = invWorldMatrix.transformPoint(position);
                         component.setTransform(newPosition);
                         // 正式版本不会走到这个流程，只在测试时使用
-                        console.info("Scene AABB [" + sceneAABB.min.toArray() + "], [" + sceneAABB.max.toArray() + "]");
-                        console.info("Update camera position [" + newPosition.toArray() + "]");
+                        console.info("Scene AABB [" + sceneAABB.min.toArray() + "], [" + sceneAABB.max.toArray() + "].");
+                        console.info("Update camera position [" + newPosition.toArray() + "].");
                     }
                 }
             });
@@ -10154,7 +10157,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         // can't find camera item, throw error message
         var item = this.getItem();
         if (item === undefined) {
-            console.warn("can't find camera item " + this.startParams.target);
+            console.warn("[CameraGestureHandlerImp] Unable to locate camera item with ID: " + this.startParams.target + ".");
             return this.composition.camera.getOptions();
         }
         var camera = this.composition.camera;
@@ -10325,7 +10328,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         this.startParams.type = CameraGestureType.none;
         var item = this.getItem();
         if (item === undefined) {
-            console.warn("can't find camera item");
+            console.warn("[CameraGestureHandlerImp] Can't find camera item.");
             return;
         }
         this.setPosition(item, position);
@@ -10335,7 +10338,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         this.startParams.type = CameraGestureType.none;
         var item = this.getItem();
         if (item === undefined) {
-            console.warn("can't find camera item");
+            console.warn("[CameraGestureHandlerImp] Can't find camera item.");
             return;
         }
         this.setQuaternion(item, quat);
@@ -10345,7 +10348,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         this.startParams.type = CameraGestureType.none;
         var item = this.getItem();
         if (item === undefined) {
-            console.warn("can't find camera item");
+            console.warn("[CameraGestureHandlerImp] Can't find camera item.");
             return;
         }
         var newDistance = distance != null ? distance : 5;
@@ -10402,7 +10405,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         this.startParams = args;
         this.updateCameraTransform(this.composition.camera.getOptions());
         if (!this.getItem()) {
-            console.warn("invalid target");
+            console.warn("[CameraGestureHandlerImp] Invalid target specified in startGesture.");
         }
         return this.composition.camera.getOptions();
     };
@@ -10410,7 +10413,7 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
         if (this.getCurrentType() === arg.type) {
             var item = this.getItem();
             if (item === undefined) {
-                console.warn("can't find camera item");
+                console.warn("[CameraGestureHandlerImp] Can't find camera item.");
                 return this.composition.camera.getOptions();
             }
             var _arg_speed;
@@ -10464,10 +10467,10 @@ var CameraGestureHandlerImp = /*#__PURE__*/ function() {
                 item.transform.setQuaternion(newRotation1.x, newRotation1.y, newRotation1.z, newRotation1.w);
                 this.setTransform(item, newPosition, item.transform.rotation);
             } else {
-                console.warn("not implement");
+                console.warn("[CameraGestureHandlerImp] Movement type not implemented.");
             }
         } else {
-            console.warn("invalid move type");
+            console.warn("[CameraGestureHandlerImp] Invalid move type specified: " + arg.type);
         }
         return this.composition.camera.getOptions();
     };
@@ -10736,7 +10739,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
         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);
+                    throw new Error("Undefined nodeIndex for child " + child + ".");
                 }
                 return child.nodeIndex;
             });
@@ -10745,7 +10748,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
             var scale;
             if (node.matrix !== undefined) {
                 if (node.matrix.length !== 16) {
-                    throw new Error("Invalid matrix length " + node.matrix.length + " for node " + node);
+                    throw new Error("Invalid matrix length " + node.matrix.length + " for node " + node + ".");
                 }
                 var mat = Matrix4.fromArray(node.matrix);
                 var transform = mat.getTransform();
@@ -10778,7 +10781,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
         });
         var rootNodes = scene.rootNodes.map(function(root) {
             if (root.nodeIndex === undefined) {
-                throw new Error("Undefined nodeIndex for root " + root);
+                throw new Error("Undefined nodeIndex for root " + root + ".");
             }
             return root.nodeIndex;
         });
@@ -10823,18 +10826,18 @@ var LoaderImpl = /*#__PURE__*/ function() {
     _proto.createTextureCube = function createTextureCube(cubeImages, level0Size) {
         var _this = this;
         if (cubeImages.length == 0) {
-            throw new Error("createTextureCube: Invalid cubeImages length " + cubeImages);
+            throw new Error("createTextureCube: Invalid cubeImages length " + cubeImages + ".");
         }
         var mipmaps = [];
         cubeImages.forEach(function(cubeImage) {
             if (cubeImage.length != 6) {
-                throw new Error("createTextureCube: cubeimage count should always be 6, " + cubeImage);
+                throw new Error("createTextureCube: cubeimage count should always be 6, " + cubeImage + ".");
             }
             //
             var imgList = [];
             cubeImage.forEach(function(img) {
                 if (img.imageData === undefined) {
-                    throw new Error("createTextureCube: Invalid image data from " + img);
+                    throw new Error("createTextureCube: Invalid image data from " + img + ".");
                 }
                 //
                 imgList.push({
@@ -10885,9 +10888,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(),
@@ -10902,7 +10905,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
     };
     _proto.createDefaultSkybox = function createDefaultSkybox(typeName) {
         if (typeName !== "NFT" && typeName !== "FARM") {
-            throw new Error("Invalid skybox type name " + typeName);
+            throw new Error("Invalid skybox type specified: '" + typeName + "'. Valid types are: 'NFT', 'FARM'.");
         }
         //
         var typ = typeName === "NFT" ? PSkyboxType.NFT : PSkyboxType.FARM;
@@ -10933,7 +10936,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
                         };
                         gltfResource = options.gltf.resource;
                         if (typeof gltfResource === "string" || _instanceof1(gltfResource, Uint8Array)) {
-                            throw new Error("Please load resource by GLTFTools at first");
+                            throw new Error("Please load the resource using GLTFTools first.");
                         }
                         _this._gltfScene = gltfResource.scenes[0];
                         _this._gltfSkins = _this._gltfScene.skins;
@@ -11144,7 +11147,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
         var texIndex = texInfo.index;
         var tex = this.getTextureManager().getTexture(matIndex, texIndex, isBaseColor);
         if (tex === undefined && noWarning !== true) {
-            console.warn("Can't find texture for mat " + matIndex + ", tex " + JSON.stringify(texInfo) + ", basecolor " + isBaseColor);
+            console.warn("Can't find texture for mat " + matIndex + ", tex " + JSON.stringify(texInfo) + ", basecolor " + isBaseColor + ".");
         }
         return tex;
     };
@@ -11176,7 +11179,7 @@ var LoaderImpl = /*#__PURE__*/ function() {
         var _this = this;
         var meshIndex = node.mesh;
         if (meshIndex === undefined) {
-            throw new Error("Invalid mesh index in node " + node);
+            throw new Error("Invalid mesh index in node " + node + ".");
         }
         var skin;
         if (node.skin !== undefined) {
@@ -11463,11 +11466,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;
@@ -11512,7 +11515,7 @@ var GeometryProxy = /*#__PURE__*/ function() {
                     var attrib = this.positionAttrib;
                     attributes["aPos"] = this._getBufferAttrib(attrib);
                 } else {
-                    throw new Error("Position attribute missing");
+                    throw new Error("Position attribute missing.");
                 }
                 if (this.hasNormal) {
                     var attrib1 = this.normalAttrib;
@@ -12226,7 +12229,7 @@ var JSONConverter = /*#__PURE__*/ function() {
                 newComponents.push(this.createLightComponent(comp, newScene));
             } else if (comp.dataType === spec.DataType.CameraComponent) {
                 newComponents.push(comp);
-                console.warn("Find camera component", comp);
+                console.warn("Camera component found: " + comp + ".");
             } else if (comp.dataType === spec.DataType.TreeComponent) {
                 var treeComp = comp;
                 this.createItemsFromTreeComponent(comp, newScene, oldScene);
@@ -12270,7 +12273,7 @@ var JSONConverter = /*#__PURE__*/ function() {
                     2,
                     new Promise(function(resolve, reject) {
                         _this.downloader.downloadJSON(url, resolve, function(status, responseText) {
-                            reject(new Error("Couldn't load JSON " + JSON.stringify(url) + ": status " + status + ", " + responseText));
+                            reject(new Error("Failed to load JSON from URL '" + url + "': status " + status + " - " + responseText + ". Please check the URL or network settings."));
                         });
                     })
                 ];
@@ -12299,7 +12302,7 @@ var JSONConverter = /*#__PURE__*/ function() {
                 _pointer_ = pointer[1], index = _pointer_[0], start = _pointer_[1], length = _pointer_[2];
                 bin = bins[index];
                 if (!bin) {
-                    throw new Error("invalid bin pointer: " + JSON.stringify(pointer));
+                    throw new Error("Invalid bin pointer: " + JSON.stringify(pointer) + ".");
                 }
                 return [
                     2,
@@ -12341,7 +12344,7 @@ var JSONConverter = /*#__PURE__*/ function() {
                 id: scene.textures[skyboxOptions.specularImage].id
             },
             specularImageSize: skyboxOptions.specularImageSize,
-            specularMipCount: skyboxOptions.specularMipCount
+            specularMipCount: skyboxOptions.specularMipCount + 1
         };
         return skyboxComponent;
     };
@@ -12368,7 +12371,7 @@ var JSONConverter = /*#__PURE__*/ function() {
         });
         var geometryData = getGeometryDataFromPropsList(geometryPropsList);
         if (!geometryData) {
-            throw new Error("no primitives");
+            throw new Error("No primitives available to process.");
         }
         newScene.geometries.push(geometryData);
         (_newScene_materials = newScene.materials).push.apply(_newScene_materials, [].concat(materialDatas));
@@ -12395,12 +12398,12 @@ var JSONConverter = /*#__PURE__*/ function() {
                 }
             }
             if (parentItemId === component.item.id) {
-                throw new Error("Can't item " + component.item);
+                throw new Error("Can't item " + component.item + ".");
             }
             var treeItem = this.treeInfo.getTreeItemByNodeId(parentItemId);
             var treeNodeList = this.treeInfo.getTreeNodeListByNodeId(parentItemId);
             if (!treeItem || !treeNodeList) {
-                throw new Error("Can't find tree node list for " + component.item);
+                throw new Error("Failed to retrieve tree node list for item with ID " + component.item.id + ". Ensure the item exists and has a valid tree structure.");
             }
             var rootBoneItem = this.setupBoneData(geometryData, meshOptions.skin, oldScene, treeItem, treeNodeList);
             meshComponent.rootBone = {
@@ -12529,13 +12532,13 @@ var JSONConverter = /*#__PURE__*/ function() {
                     var inputArray = typedArrayFromBinary(bins, track.input);
                     var outputArray = typedArrayFromBinary(bins, track.output);
                     if (!_instanceof1(inputArray, Float32Array)) {
-                        throw new Error("Type of inputArray should be float32, " + inputArray);
+                        throw new Error("Type of inputArray should be float32, " + inputArray + ".");
                     }
                     if (!_instanceof1(outputArray, Float32Array)) {
-                        throw new Error("Type of outputArray should be float32, " + outputArray);
+                        throw new Error("Type of outputArray should be float32, " + outputArray + ".");
                     }
                     if (track.interpolation !== "LINEAR") {
-                        throw new Error("Invalid interpolation type " + track.interpolation);
+                        throw new Error("Invalid interpolation type " + track.interpolation + ".");
                     }
                     if (track.path === "rotation") {
                         var points = [];
@@ -12773,7 +12776,7 @@ var JSONConverter = /*#__PURE__*/ function() {
         if (oldMat.blending === 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;
         }
@@ -12790,9 +12793,8 @@ var JSONConverter = /*#__PURE__*/ function() {
         if (oldMat.type === 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;
@@ -12871,7 +12873,7 @@ var JSONConverter = /*#__PURE__*/ function() {
         var bins = oldScene.bins;
         var joints = skin.joints, skeleton = skin.skeleton, inverseBindMatrices = skin.inverseBindMatrices;
         if (!inverseBindMatrices) {
-            throw new Error("inverseBindMatrices is undefined " + skin);
+            throw new Error("'inverseBindMatrices' is undefined for the skin configuration: " + JSON.stringify(skin) + ". Ensure 'inverseBindMatrices' is properly defined in your skin data.");
         }
         var bindMatrixArray = typedArrayFromBinary(bins, inverseBindMatrices);
         geom.inverseBindMatrices = Array.from(bindMatrixArray);
@@ -12880,12 +12882,12 @@ var JSONConverter = /*#__PURE__*/ function() {
         if (skeleton !== undefined) {
             rootBoneItem = treeNodeList[skeleton];
         } else {
-            console.warn("Root bone is missing");
+            console.warn("Root bone is missing for the skeleton. Defaulting to the primary tree item as the root bone.");
         }
         joints.forEach(function(joint) {
             var node = treeNodeList[joint];
             if (node !== rootBoneItem && node.parentId === rootBoneItem.parentId) {
-                console.error("Find invalid node for rootBoneItem and adjust rootBoneItem");
+                console.error("Invalid node detected for 'rootBoneItem'. Adjusting 'rootBoneItem' to the primary tree item. Please verify the tree structure.");
                 rootBoneItem = treeItem;
             }
         });
@@ -12923,12 +12925,12 @@ var TreeInfo = /*#__PURE__*/ function() {
     _proto.add = function add(treeItem, treeNodeList) {
         var _this = this;
         if (this.tree2NodeList[treeItem.id]) {
-            throw new Error("Find duplicate treeItem id: " + treeItem.id);
+            throw new Error("Duplicate treeItem ID detected: " + treeItem.id + ". Ensure each tree item has a unique ID.");
         }
         this.tree2NodeList[treeItem.id] = treeNodeList;
         treeNodeList.forEach(function(node) {
             if (_this.nodeList2Tree[node.id]) {
-                throw new Error("Find duplicate tree node id: " + node.id);
+                throw new Error("Duplicate tree node ID found: " + node.id + ". Each node in the tree must have a unique ID.");
             }
             _this.nodeList2Tree[node.id] = treeItem;
             _this.nodeId2Node[node.id] = node;
@@ -12957,7 +12959,7 @@ var TreeInfo = /*#__PURE__*/ function() {
     _proto.getTreeNodeListByNodeId = function getTreeNodeListByNodeId(id) {
         var treeItem = this.nodeList2Tree[id];
         if (!treeItem) {
-            throw new Error("Invalid id " + id);
+            throw new Error("Invalid id " + id + ".");
         }
         return this.getTreeNodeListByTreeId(treeItem.id);
     };
@@ -13171,7 +13173,7 @@ function createGeometryData(props, subMeshes) {
         var attribData1 = props.attributes[attrib1];
         var semantic = vertexBufferSemanticMap[attrib1];
         if (!semantic) {
-            throw new Error("Invalid attrib " + attrib1);
+            throw new Error("Invalid attrib " + attrib1 + ".");
         }
         // @ts-expect-error
         vertexCount = attribData1.data.length / attribData1.size;
@@ -13199,8 +13201,8 @@ function createGeometryData(props, subMeshes) {
         },
         subMeshes: subMeshes,
         mode: spec.GeometryType.TRIANGLES,
-        indexFormat: spec.IndexFormatType.UInt16,
-        indexOffset: -1,
+        indexFormat: spec.IndexFormatType.None,
+        indexOffset: 0,
         buffer: ""
     };
     if (props.indices) {
@@ -13210,6 +13212,8 @@ function createGeometryData(props, subMeshes) {
         geometryData.indexOffset = bufferOffset;
         if (_instanceof1(indices, Uint32Array)) {
             geometryData.indexFormat = spec.IndexFormatType.UInt32;
+        } else {
+            geometryData.indexFormat = spec.IndexFormatType.UInt16;
         }
     }
     geometryData.buffer = toBase64String(buffer);
@@ -13364,13 +13368,1053 @@ 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 = generateGUID();
+            this.composition = {
+                id: "1",
+                name: "test1",
+                duration: 9999,
+                endBehavior: spec.CompositionEndBehavior.restart,
+                camera: {
+                    fov: 45,
+                    far: 2000,
+                    near: 0.001,
+                    position: [
+                        0,
+                        0,
+                        8
+                    ],
+                    rotation: [
+                        0,
+                        0,
+                        0
+                    ],
+                    clipMode: 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,
+                                        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 = 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];
+                addItem(cubeTextures, diffuseTexture);
+            }
+            if (data.specularImage) {
+                var specularImage = dataMap[data.specularImage.id];
+                addItem(cubeTextures, specularImage);
+            }
+        });
+        cubeTextures.forEach(function(tex) {
+            if (tex.target === 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 = glContext.LINEAR;
+                    cube.magFilter = glContext.LINEAR;
+                } else {
+                    cube.minFilter = glContext.LINEAR_MIPMAP_LINEAR;
+                    cube.magFilter = glContext.LINEAR;
+                }
+            }
+        });
+    };
+    _proto.processComponentData = function processComponentData(components) {
+        var _this = this;
+        components.forEach(function(comp) {
+            if (comp.dataType === spec.DataType.LightComponent) {
+                _this.processLightComponentData(comp);
+            } else if (comp.dataType === spec.DataType.CameraComponent) {
+                _this.processCameraComponentData(comp);
+            } else if (comp.dataType === spec.DataType.MeshComponent) {
+                _this.processMeshComponentData(comp);
+            } else if (comp.dataType === 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 === spec.LightType.point) {
+            if (!light.range) {
+                light.range = 0;
+            }
+        } else if (light.lightType === 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 === 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"] = spec.RenderType.Opaque;
+            }
+            if (!material.stringTags["RenderFace"]) {
+                material.stringTags["RenderFace"] = 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"] = spec.RenderType.Opaque;
+            }
+            if (!material.stringTags["RenderFace"]) {
+                material.stringTags["RenderFace"] = 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 : glContext.LINEAR_MIPMAP_LINEAR;
+        if (this.isTiny3dMode()) {
+            minFilter = glContext.LINEAR_MIPMAP_LINEAR;
+            if (image) {
+                if (!WebGLHelper.isPow2(image.width) || !WebGLHelper.isPow2(image.height)) {
+                    minFilter = glContext.LINEAR;
+                }
+            }
+            premultiplyAlpha = isBaseColor ? false : true;
+        }
+        var generateMipmap = minFilter == glContext.NEAREST_MIPMAP_NEAREST || minFilter == glContext.LINEAR_MIPMAP_NEAREST || minFilter == glContext.NEAREST_MIPMAP_LINEAR || minFilter == glContext.LINEAR_MIPMAP_LINEAR;
+        var _options_wrapS;
+        options.wrapS = (_options_wrapS = options.wrapS) != null ? _options_wrapS : glContext.REPEAT;
+        var _options_wrapT;
+        options.wrapT = (_options_wrapT = options.wrapT) != null ? _options_wrapT : glContext.REPEAT;
+        var _options_magFilter;
+        options.magFilter = (_options_magFilter = options.magFilter) != null ? _options_magFilter : 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: 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 = generateGUID();
+        var component = {
+            id: generateGUID(),
+            item: {
+                id: itemId
+            },
+            dataType: 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: 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: spec.DataType.VFXItemData
+        };
+        this.items.push(item);
+        this.components.push(component);
+    };
+    _proto.addCamera = function addCamera(camera) {
+        var itemId = generateGUID();
+        var component = {
+            id: generateGUID(),
+            item: {
+                id: itemId
+            },
+            dataType: 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: 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 = 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: spec.ItemType.skybox,
+                        pn: 0,
+                        visible: true,
+                        endBehavior: 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: 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" ? PSkyboxType.NFT : 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: 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 : spec.ItemEndBehavior.loop;
+    };
+    _proto.getSkyboxType = function getSkyboxType() {
+        var typeName = this.sceneOptions.gltf.skyboxType;
+        switch(typeName){
+            case "NFT":
+                return PSkyboxType.NFT;
+            case "FARM":
+                return 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": spec.DataType.Material,
+        "stringTags": {
+            "RenderType": 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": spec.DataType.Material,
+        "stringTags": {
+            "ZWrite": "true",
+            "ZTest": "true",
+            "RenderType": 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;
+}
+
 registerPlugin("tree", ModelTreePlugin, VFXItem, true);
 registerPlugin("model", ModelPlugin, VFXItem);
-var version = "2.0.0-alpha.17";
-logger.info("plugin model version: " + version);
-if (version !== version$1) {
+var version = "2.0.0-alpha.19";
+logger.info("Plugin model version: " + version + ".");
+if (version !== EFFECTS.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!");
 }
 
-export { AnimationComponent, Box3, BoxMesh, CameraGestureHandlerImp, CameraGestureType, CheckerHelper, Color, CompositionCache, CompositionHitTest, CullMode, DEG2RAD, Euler, EulerOrder, FBOOptions, Float16ArrayWrapper, GeometryBoxProxy, HitTestingProxy, HookOGLFunc, InterpolationSampler, JSONConverter, LoaderHelper, LoaderImpl, Matrix3, Matrix4, MeshHelper, ModelCameraComponent, ModelLightComponent, ModelMeshComponent, ModelPlugin, ModelPluginComponent, ModelSkyboxComponent, ModelTreeComponent, ModelTreeItem, ModelTreePlugin, PAnimInterpType, PAnimPathType, PAnimTexture, PAnimTrack, PAnimation, PAnimationManager, PBRShaderGUID, PBlendMode, PCamera, PCameraManager, PCoordinate, PEntity, PFaceSideMode, PGeometry, PGlobalState, PLight, PLightManager, PLightType, PMaterialBase, PMaterialPBR, PMaterialSkyboxFilter, PMaterialType, PMaterialUnlit, PMesh, PMorph, PObject, PObjectType, PSceneManager, PShaderManager, PShadowType, PSkin, PSkybox, PSkyboxCreator, PSkyboxType, PSubMesh, PTextureType, PTransform, PluginHelper, Quaternion, Ray, RayBoxTesting, RayIntersectsBoxWithRotation, RayTriangleTesting, RenderType, Sphere, TextureDataMode, ToggleItemBounding, TwoStatesSet, UnlitShaderGUID, VFX_ITEM_TYPE_3D, Vector2, Vector3, Vector4, VertexAttribBuffer, WebGLHelper, WebHelper, createAnimationSampler, createPluginMaterial, fetchPBRShaderCode, fetchUnlitShaderCode, getDefaultEffectsGLTFLoader, getDiffuseOnlyShaderCode, getGaussianBlurShaderCodeV1, getGaussianBlurShaderCodeV2, getGeometryDataFromOptions, getGeometryDataFromPropsList, getKawaseBlurShaderCode, getNormalVisShaderCode, getPBRPassShaderCode, getPMeshList, getQuadFilterShaderCode, getRendererGPUInfo, getSceneManager, getShadowPassShaderCode, getSimpleFilterShaderCode, getSkyBoxShaderCode, getTransparecyBaseShader, getTransparecyFilterShader, setDefaultEffectsGLTFLoader, version };
+export { AnimationComponent, Box3, BoxMesh, CameraGestureHandlerImp, CameraGestureType, CheckerHelper, Color, CompositionCache, CompositionHitTest, DEG2RAD, Euler, EulerOrder, FBOOptions, Float16ArrayWrapper, GeometryBoxProxy, HitTestingProxy, HookOGLFunc, InterpolationSampler, JSONConverter, LoaderECSImpl, LoaderHelper, LoaderImpl, Matrix3, Matrix4, MeshHelper, ModelCameraComponent, ModelLightComponent, ModelMeshComponent, ModelPlugin, ModelPluginComponent, ModelSkyboxComponent, ModelTreeComponent, ModelTreeItem, ModelTreePlugin, PAnimInterpType, PAnimPathType, PAnimTexture, PAnimTrack, PAnimation, PAnimationManager, PBRShaderGUID, PBlendMode, PCamera, PCameraManager, PCoordinate, PEntity, PFaceSideMode, PGeometry, PGlobalState, PLight, PLightManager, PLightType, PMaterialBase, PMaterialPBR, PMaterialSkyboxFilter, PMaterialType, PMaterialUnlit, PMesh, PMorph, PObject, PObjectType, PSceneManager, PShaderManager, PShadowType, PSkin, PSkybox, PSkyboxCreator, PSkyboxType, PSubMesh, PTextureType, PTransform, PluginHelper, Quaternion, Ray, RayBoxTesting, RayIntersectsBoxWithRotation, RayTriangleTesting, Sphere, TextureDataMode, ToggleItemBounding, TwoStatesSet, UnlitShaderGUID, VFX_ITEM_TYPE_3D, Vector2, Vector3, Vector4, VertexAttribBuffer, WebGLHelper, WebHelper, createAnimationSampler, createPluginMaterial, fetchPBRShaderCode, fetchUnlitShaderCode, getDefaultEffectsGLTFLoader, getDefaultEffectsGLTFLoaderECS, getDefaultPBRMaterialData, getDefaultUnlitMaterialData, getDiffuseOnlyShaderCode, getGaussianBlurShaderCodeV1, getGaussianBlurShaderCodeV2, getGeometryDataFromOptions, getGeometryDataFromPropsList, getKawaseBlurShaderCode, getNormalVisShaderCode, getPBRPassShaderCode, getPBRShaderProperties, getPMeshList, getQuadFilterShaderCode, getRendererGPUInfo, getSceneManager, getShadowPassShaderCode, getSimpleFilterShaderCode, getSkyBoxShaderCode, getTransparecyBaseShader, getTransparecyFilterShader, getUnlitShaderProperties, setDefaultEffectsGLTFLoader, setDefaultEffectsGLTFLoaderECS, version };
 //# sourceMappingURL=index.mjs.map