@galacean/effects-plugin-model 2.0.0-alpha.22 → 2.0.0-alpha.23

package/dist/alipay.js

@@ -12013,11 +12013,11 @@ var vertexBufferSemanticMap = {
     a_Target_Tangent3: "TANGENT_BS3"
 };
 
-function getDefaultEffectsGLTFLoader(options) {
+function getDefaultEffectsGLTFLoader(engine, options) {
     if (!defaultGLTFLoader) {
         defaultGLTFLoader = new LoaderImpl();
     }
-    defaultGLTFLoader.initial(options);
+    defaultGLTFLoader.initial(engine, options);
     return defaultGLTFLoader;
 }
 function setDefaultEffectsGLTFLoader(loader) {
@@ -12475,7 +12475,8 @@ var LoaderImpl = /*#__PURE__*/ function() {
         options.premultiplyAlpha = premultiplyAlpha;
         options.generateMipmap = generateMipmap;
     };
-    _proto.initial = function initial(options) {
+    _proto.initial = function initial(engine, options) {
+        this.engine = engine;
         this.loaderOptions = options != null ? options : {};
     };
     _proto.checkMeshComponentData = function checkMeshComponentData(mesh, resource) {
@@ -12875,6 +12876,286 @@ var LoaderImpl = /*#__PURE__*/ function() {
             return false;
         }
     };
+    /**
+   * for old scene compatibility
+   */ _proto.processLight = function processLight(lights, fromGLTF) {
+        var _this = this;
+        lights.forEach(function(l) {
+            if (l.color === undefined) {
+                if (fromGLTF) {
+                    l.color = [
+                        255,
+                        255,
+                        255,
+                        255
+                    ];
+                } else {
+                    l.color = [
+                        1,
+                        1,
+                        1,
+                        1
+                    ];
+                }
+            } else {
+                l.color[0] = _this.scaleColorVal(l.color[0], fromGLTF);
+                l.color[1] = _this.scaleColorVal(l.color[1], fromGLTF);
+                l.color[2] = _this.scaleColorVal(l.color[2], fromGLTF);
+                l.color[3] = _this.scaleColorVal(l.color[3], fromGLTF);
+            }
+        });
+    };
+    _proto.processCamera = function processCamera(cameras, fromGLTF) {
+        var scale = fromGLTF ? 180.0 / Math.PI : Math.PI / 180.0;
+        cameras.forEach(function(camera) {
+            if (camera.perspective !== undefined) {
+                camera.perspective.yfov *= scale;
+            }
+        });
+    };
+    _proto.processMaterial = function processMaterial(materials, fromGLTF) {
+        var _this = this;
+        materials.forEach(function(mat) {
+            if (mat.baseColorFactor === undefined) {
+                if (fromGLTF) {
+                    mat.baseColorFactor = [
+                        255,
+                        255,
+                        255,
+                        255
+                    ];
+                } else {
+                    mat.baseColorFactor = [
+                        1,
+                        1,
+                        1,
+                        1
+                    ];
+                }
+            } else {
+                mat.baseColorFactor[0] = _this.scaleColorVal(mat.baseColorFactor[0], fromGLTF);
+                mat.baseColorFactor[1] = _this.scaleColorVal(mat.baseColorFactor[1], fromGLTF);
+                mat.baseColorFactor[2] = _this.scaleColorVal(mat.baseColorFactor[2], fromGLTF);
+                mat.baseColorFactor[3] = _this.scaleColorVal(mat.baseColorFactor[3], fromGLTF);
+            }
+            if (mat.emissiveFactor === undefined) {
+                if (fromGLTF) {
+                    mat.emissiveFactor = [
+                        255,
+                        255,
+                        255,
+                        255
+                    ];
+                } else {
+                    mat.emissiveFactor = [
+                        1,
+                        1,
+                        1,
+                        1
+                    ];
+                }
+            } else {
+                mat.emissiveFactor[0] = _this.scaleColorVal(mat.emissiveFactor[0], fromGLTF);
+                mat.emissiveFactor[1] = _this.scaleColorVal(mat.emissiveFactor[1], fromGLTF);
+                mat.emissiveFactor[2] = _this.scaleColorVal(mat.emissiveFactor[2], fromGLTF);
+                mat.emissiveFactor[3] = _this.scaleColorVal(mat.emissiveFactor[3], fromGLTF);
+            }
+            if (fromGLTF && mat.occlusionTexture !== undefined && mat.occlusionTexture.strength === undefined) {
+                mat.occlusionTexture.strength = _this.isTiny3dMode() ? 0 : 1;
+            }
+        });
+    };
+    _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;
+            var quat;
+            var scale;
+            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.createGeometry = function createGeometry(primitive, hasSkinAnim) {
+        var proxy = new GeometryProxy(this.engine, primitive, hasSkinAnim);
+        return proxy.geometry;
+    };
+    _proto.createMaterial = function createMaterial(material) {
+        var proxy = new MaterialProxy(material, [], this.isTiny3dMode());
+        return proxy.material;
+    };
+    _proto.createTexture2D = function createTexture2D(image, texture, isBaseColor) {
+        return WebGLHelper.createTexture2D(this.engine, image, texture, isBaseColor, this.isTiny3dMode());
+    };
+    _proto.createTextureCube = function createTextureCube(cubeImages, level0Size) {
+        var _this = this;
+        if (cubeImages.length == 0) {
+            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);
+            }
+            //
+            var imgList = [];
+            cubeImage.forEach(function(img) {
+                if (img.imageData === undefined) {
+                    throw new Error("createTextureCube: Invalid image data from " + img);
+                }
+                //
+                imgList.push({
+                    type: "buffer",
+                    data: img.imageData,
+                    mimeType: img.mimeType
+                });
+            });
+            if (_this.isTiny3dMode()) {
+                var ref;
+                ref = [
+                    imgList[5],
+                    imgList[4]
+                ], imgList[4] = ref[0], imgList[5] = ref[1];
+            }
+            mipmaps.push(imgList);
+        });
+        //
+        if (mipmaps.length == 1) {
+            // no mipmaps
+            return WebGLHelper.createTextureCubeFromBuffer(this.engine, mipmaps[0]);
+        } else {
+            // has mipmaps
+            return WebGLHelper.createTextureCubeMipmapFromBuffer(this.engine, mipmaps, level0Size != null ? level0Size : Math.pow(2, mipmaps.length - 1));
+        }
+    };
+    _proto.createSkybox = function createSkybox(ibl) {
+        var _this = this;
+        var _ibl_reflectionsIntensity;
+        var reflectionsIntensity = (_ibl_reflectionsIntensity = ibl.reflectionsIntensity) != null ? _ibl_reflectionsIntensity : ibl.intensity;
+        var irradianceCoeffs = ibl.irradianceCoefficients;
+        var inSpecularImages = ibl.specularImages;
+        var specularImages = inSpecularImages.map(function(images) {
+            var newImages = images.map(function(img) {
+                var outImg = {
+                    type: "buffer",
+                    data: img.imageData,
+                    mimeType: img.mimeType
+                };
+                return outImg;
+            });
+            if (_this.isTiny3dMode()) {
+                var ref;
+                ref = [
+                    newImages[5],
+                    newImages[4]
+                ], newImages[4] = ref[0], newImages[5] = ref[1];
+            }
+            return newImages;
+        });
+        var specularMipCount = specularImages.length - 1;
+        var _ibl_specularImageSize;
+        var specularImageSize = (_ibl_specularImageSize = ibl.specularImageSize) != null ? _ibl_specularImageSize : Math.pow(2, specularMipCount);
+        var newIrradianceCoeffs = [];
+        irradianceCoeffs.forEach(function(coeffs) {
+            var _newIrradianceCoeffs;
+            (_newIrradianceCoeffs = newIrradianceCoeffs).push.apply(_newIrradianceCoeffs, [].concat(coeffs));
+        });
+        var params = {
+            type: "buffer",
+            renderable: this.isSkyboxVis(),
+            intensity: ibl.intensity,
+            reflectionsIntensity: reflectionsIntensity,
+            irradianceCoeffs: newIrradianceCoeffs,
+            specularImage: specularImages,
+            specularMipCount: specularMipCount,
+            specularImageSize: specularImageSize
+        };
+        return PSkyboxCreator.createSkyboxOptions(this.engine, params);
+    };
+    _proto.createDefaultSkybox = function createDefaultSkybox(typeName) {
+        if (typeName !== "NFT" && typeName !== "FARM") {
+            throw new Error("Invalid skybox type name " + typeName);
+        }
+        //
+        var typ = typeName === "NFT" ? exports.PSkyboxType.NFT : exports.PSkyboxType.FARM;
+        var params = PSkyboxCreator.getSkyboxParams(typ);
+        return PSkyboxCreator.createSkyboxOptions(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);
+        });
+    };
     return LoaderImpl;
 }();
 function getPBRShaderProperties() {
@@ -12959,10 +13240,541 @@ function getDefaultUnlitMaterialData() {
     };
     return material;
 }
+var GeometryProxy = /*#__PURE__*/ function() {
+    function GeometryProxy(engine, gltfGeometry, hasSkinAnimation) {
+        this.engine = engine;
+        this.gltfGeometry = gltfGeometry;
+        this.hasSkinAnimation = hasSkinAnimation;
+    }
+    var _proto = GeometryProxy.prototype;
+    _proto._getBufferAttrib = function _getBufferAttrib(inAttrib) {
+        var attrib = {
+            type: inAttrib.type,
+            size: inAttrib.itemSize,
+            //stride: inAttrib.stride,
+            //offset: inAttrib.offset,
+            data: inAttrib.array,
+            normalize: inAttrib.normalized
+        };
+        return attrib;
+    };
+    _proto.texCoordAttrib = function texCoordAttrib(index) {
+        return this.gltfGeometry.getTexCoord(index);
+    };
+    _proto.getTargetPosition = function getTargetPosition(index) {
+        return this.gltfGeometry.getAttribute("POSITION" + index);
+    };
+    _proto.getTargetNormal = function getTargetNormal(index) {
+        return this.gltfGeometry.getAttribute("NORMAL" + index);
+    };
+    _proto.getTargetTangent = function getTargetTangent(index) {
+        return this.gltfGeometry.getAttribute("TANGENT" + index);
+    };
+    _create_class(GeometryProxy, [
+        {
+            key: "geometry",
+            get: function get() {
+                var _this = this;
+                var attributes = {};
+                if (this.hasPosition) {
+                    var attrib = this.positionAttrib;
+                    attributes["a_Position"] = this._getBufferAttrib(attrib);
+                } else {
+                    throw new Error("Position attribute missing");
+                }
+                if (this.hasNormal) {
+                    var attrib1 = this.normalAttrib;
+                    if (attrib1 !== undefined) {
+                        attributes["a_Normal"] = this._getBufferAttrib(attrib1);
+                    }
+                }
+                if (this.hasTangent) {
+                    var attrib2 = this.tangentAttrib;
+                    if (attrib2 !== undefined) {
+                        attributes["a_Tangent"] = this._getBufferAttrib(attrib2);
+                    }
+                }
+                this.texCoordList.forEach(function(val) {
+                    var attrib = _this.texCoordAttrib(val);
+                    var attribName = "a_UV" + (val + 1);
+                    attributes[attribName] = _this._getBufferAttrib(attrib);
+                });
+                if (this.hasSkinAnimation) {
+                    var jointAttrib = this.jointAttribute;
+                    if (jointAttrib !== undefined) {
+                        attributes["a_Joint1"] = this._getBufferAttrib(jointAttrib);
+                    }
+                    var weightAttrib = this.weightAttribute;
+                    if (weightAttrib !== undefined) {
+                        attributes["a_Weight1"] = this._getBufferAttrib(weightAttrib);
+                    }
+                }
+                /**
+     * 设置Morph动画需要的Attribute，主要包括Position，Normal和Tangent
+     */ for(var i = 0; i < 8; i++){
+                    var positionAttrib = this.getTargetPosition(i);
+                    if (positionAttrib !== undefined) {
+                        attributes["a_Target_Position" + i] = this._getBufferAttrib(positionAttrib);
+                    }
+                    var normalAttrib = this.getTargetNormal(i);
+                    if (normalAttrib !== undefined) {
+                        attributes["a_Target_Normal" + i] = this._getBufferAttrib(normalAttrib);
+                    }
+                    var tangentAttrib = this.getTargetTangent(i);
+                    if (tangentAttrib !== undefined) {
+                        attributes["a_Target_Tangent" + i] = this._getBufferAttrib(tangentAttrib);
+                    }
+                }
+                var indexArray = this.indexArray;
+                if (indexArray !== undefined) {
+                    return EFFECTS.Geometry.create(this.engine, {
+                        attributes: attributes,
+                        indices: {
+                            data: indexArray
+                        },
+                        drawStart: 0,
+                        drawCount: indexArray.length,
+                        mode: EFFECTS.glContext.TRIANGLES
+                    });
+                } else {
+                    return EFFECTS.Geometry.create(this.engine, {
+                        attributes: attributes,
+                        drawStart: 0,
+                        drawCount: this.positionAttrib.array.length / 3,
+                        mode: EFFECTS.glContext.TRIANGLES
+                    });
+                }
+            }
+        },
+        {
+            key: "positionAttrib",
+            get: function get() {
+                return this.gltfGeometry.getPosition();
+            }
+        },
+        {
+            key: "normalAttrib",
+            get: function get() {
+                return this.gltfGeometry.getNormal();
+            }
+        },
+        {
+            key: "tangentAttrib",
+            get: function get() {
+                return this.gltfGeometry.getTangent();
+            }
+        },
+        {
+            key: "jointAttribute",
+            get: function get() {
+                return this.gltfGeometry.getJoints(0);
+            }
+        },
+        {
+            key: "weightAttribute",
+            get: function get() {
+                return this.gltfGeometry.getWeights(0);
+            }
+        },
+        {
+            key: "hasPosition",
+            get: function get() {
+                return this.positionAttrib !== undefined;
+            }
+        },
+        {
+            key: "hasNormal",
+            get: function get() {
+                return this.normalAttrib !== undefined;
+            }
+        },
+        {
+            key: "hasTangent",
+            get: function get() {
+                return this.tangentAttrib !== undefined;
+            }
+        },
+        {
+            key: "hasTexCoord",
+            get: function get() {
+                return this.texCoordCount > 0;
+            }
+        },
+        {
+            key: "texCoordCount",
+            get: function get() {
+                for(var i = 0; i < 10; i++){
+                    if (this.texCoordAttrib(i) === undefined) {
+                        return i;
+                    }
+                }
+                return 0;
+            }
+        },
+        {
+            key: "hasJointAttribute",
+            get: function get() {
+                return this.jointAttribute !== undefined;
+            }
+        },
+        {
+            key: "hasWeightAttribute",
+            get: function get() {
+                return this.weightAttribute !== undefined;
+            }
+        },
+        {
+            key: "indexArray",
+            get: function get() {
+                if (this.gltfGeometry.indices === undefined) {
+                    return undefined;
+                }
+                switch(this.gltfGeometry.indices.type){
+                    case WebGLRenderingContext["UNSIGNED_INT"]:
+                        return this.gltfGeometry.indices.array;
+                    case WebGLRenderingContext["UNSIGNED_SHORT"]:
+                        return this.gltfGeometry.indices.array;
+                    case WebGLRenderingContext["UNSIGNED_BYTE"]:
+                        return this.gltfGeometry.indices.array;
+                }
+                return undefined;
+            }
+        },
+        {
+            key: "indexCount",
+            get: function get() {
+                if (this.gltfGeometry.indices !== undefined) {
+                    return this.gltfGeometry.indices.array.length;
+                } else {
+                    return 0;
+                }
+            }
+        },
+        {
+            key: "texCoordList",
+            get: function get() {
+                var texCoords = [];
+                for(var i = 0; i < 10; i++){
+                    if (this.texCoordAttrib(i) !== undefined) {
+                        texCoords.push(i);
+                    } else {
+                        break;
+                    }
+                }
+                return texCoords;
+            }
+        }
+    ]);
+    return GeometryProxy;
+}();
+var MaterialProxy = /*#__PURE__*/ function() {
+    function MaterialProxy(material, textures, tiny3dMode) {
+        this.gltfMaterial = material;
+        this.textures = textures;
+        this.tiny3dMode = tiny3dMode;
+    }
+    var _proto = MaterialProxy.prototype;
+    _proto.getTextureObject = function getTextureObject(index) {
+        if (index < 0 || index >= this.textures.length) {
+            return;
+        }
+        return this.textures[index];
+    };
+    _proto.getTextureObj = function getTextureObj(texInfo) {
+        return texInfo ? this.getTextureObject(texInfo.index) : undefined;
+    };
+    _proto.getTextureCoord = function getTextureCoord(texInfo) {
+        return texInfo ? texInfo.texCoord : undefined;
+    };
+    _proto.getTextureTransform = function getTextureTransform(texInfo) {
+        var _texInfo_extensions;
+        var transform = texInfo == null ? void 0 : (_texInfo_extensions = texInfo.extensions) == null ? void 0 : _texInfo_extensions.KHR_texture_transform;
+        if (transform === undefined) {
+            return;
+        }
+        if (transform.offset === undefined && transform.rotation === undefined && transform.scale === undefined) {
+            return;
+        }
+        return {
+            offset: transform.offset,
+            rotation: transform.rotation,
+            scale: transform.scale
+        };
+    };
+    _proto.getSpecularAA = function getSpecularAA() {
+        var _this_gltfMaterial_extras;
+        return (_this_gltfMaterial_extras = this.gltfMaterial.extras) == null ? void 0 : _this_gltfMaterial_extras.useSpecularAA;
+    };
+    _create_class(MaterialProxy, [
+        {
+            key: "material",
+            get: function get() {
+                var mat = this.gltfMaterial;
+                var isUnlit = GLTFHelper.isUnlitMaterial(mat);
+                var blending = EFFECTS.spec.MaterialBlending.opaque;
+                switch(mat.alphaMode){
+                    case "OPAQUE":
+                        blending = EFFECTS.spec.MaterialBlending.opaque;
+                        break;
+                    case "MASK":
+                        blending = EFFECTS.spec.MaterialBlending.masked;
+                        break;
+                    case "BLEND":
+                        blending = EFFECTS.spec.MaterialBlending.translucent;
+                        break;
+                }
+                var side = mat.doubleSided ? EFFECTS.spec.SideMode.DOUBLE : EFFECTS.spec.SideMode.FRONT;
+                var enableShadow = false;
+                var _mat_alphaCutOff;
+                var alphaCutOff = (_mat_alphaCutOff = mat.alphaCutOff) != null ? _mat_alphaCutOff : 0.5;
+                var name = mat.name;
+                if (isUnlit) {
+                    var _mat_extras;
+                    return {
+                        name: name,
+                        type: EFFECTS.spec.MaterialType.unlit,
+                        baseColorTexture: this.baseColorTextureObj,
+                        baseColorTextureCoordinate: this.baseColorTextureCoord,
+                        baseColorTextureTransform: this.baseColorTextureTransfrom,
+                        baseColorFactor: this.baseColorFactor,
+                        //
+                        depthMask: (_mat_extras = mat.extras) == null ? void 0 : _mat_extras.depthMask,
+                        blending: blending,
+                        alphaCutOff: alphaCutOff,
+                        side: side
+                    };
+                } else {
+                    var _mat_extras1;
+                    return {
+                        name: name,
+                        type: EFFECTS.spec.MaterialType.pbr,
+                        baseColorTexture: this.baseColorTextureObj,
+                        baseColorTextureCoordinate: this.baseColorTextureCoord,
+                        baseColorTextureTransform: this.baseColorTextureTransfrom,
+                        baseColorFactor: this.baseColorFactor,
+                        //
+                        useSpecularAA: this.getSpecularAA(),
+                        //
+                        metallicRoughnessTexture: this.metallicRoughnessTextureObj,
+                        metallicRoughnessTextureCoordinate: this.metallicRoughnessTextureCoord,
+                        metallicRoughnessTextureTransform: this.metallicRoughnessTextureTransfrom,
+                        metallicFactor: this.metalicFactor,
+                        roughnessFactor: this.roughnessFactor,
+                        //
+                        normalTexture: this.normalTextureObj,
+                        normalTextureCoordinate: this.normalTextureCoord,
+                        normalTextureTransform: this.normalTextureTransfrom,
+                        normalTextureScale: this.normalTextureScale,
+                        //
+                        occlusionTexture: this.occlusionTextureObj,
+                        occlusionTextureCoordinate: this.occlusionTextureCoord,
+                        occlusionTextureTransform: this.occlusionTextureTransfrom,
+                        occlusionTextureStrength: this.occlusionTextureStrength,
+                        //
+                        emissiveTexture: this.emissiveTextureObj,
+                        emissiveTextureCoordinate: this.emissiveTextureCoord,
+                        emissiveTextureTransform: this.emissiveTextureTransfrom,
+                        emissiveFactor: this.emissiveFactor,
+                        emissiveIntensity: 1.0,
+                        //
+                        depthMask: (_mat_extras1 = mat.extras) == null ? void 0 : _mat_extras1.depthMask,
+                        blending: blending,
+                        alphaCutOff: alphaCutOff,
+                        side: side,
+                        enableShadow: enableShadow
+                    };
+                }
+            }
+        },
+        {
+            key: "baseColorTextureObj",
+            get: function get() {
+                return this.getTextureObj(this.gltfMaterial.baseColorTexture);
+            }
+        },
+        {
+            key: "baseColorTextureCoord",
+            get: function get() {
+                return this.getTextureCoord(this.gltfMaterial.baseColorTexture);
+            }
+        },
+        {
+            key: "baseColorTextureTransfrom",
+            get: function get() {
+                return this.getTextureTransform(this.gltfMaterial.baseColorTexture);
+            }
+        },
+        {
+            key: "metallicRoughnessTextureObj",
+            get: function get() {
+                return this.getTextureObj(this.gltfMaterial.metallicRoughnessTexture);
+            }
+        },
+        {
+            key: "metallicRoughnessTextureCoord",
+            get: function get() {
+                return this.getTextureCoord(this.gltfMaterial.metallicRoughnessTexture);
+            }
+        },
+        {
+            key: "metallicRoughnessTextureTransfrom",
+            get: function get() {
+                return this.getTextureTransform(this.gltfMaterial.metallicRoughnessTexture);
+            }
+        },
+        {
+            key: "normalTextureObj",
+            get: function get() {
+                return this.getTextureObj(this.gltfMaterial.normalTexture);
+            }
+        },
+        {
+            key: "normalTextureCoord",
+            get: function get() {
+                return this.getTextureCoord(this.gltfMaterial.normalTexture);
+            }
+        },
+        {
+            key: "normalTextureTransfrom",
+            get: function get() {
+                return this.getTextureTransform(this.gltfMaterial.normalTexture);
+            }
+        },
+        {
+            key: "occlusionTextureObj",
+            get: function get() {
+                return this.getTextureObj(this.gltfMaterial.occlusionTexture);
+            }
+        },
+        {
+            key: "occlusionTextureCoord",
+            get: function get() {
+                return this.getTextureCoord(this.gltfMaterial.occlusionTexture);
+            }
+        },
+        {
+            key: "occlusionTextureTransfrom",
+            get: function get() {
+                return this.getTextureTransform(this.gltfMaterial.occlusionTexture);
+            }
+        },
+        {
+            key: "emissiveTextureObj",
+            get: function get() {
+                return this.getTextureObj(this.gltfMaterial.emissiveTexture);
+            }
+        },
+        {
+            key: "emissiveTextureCoord",
+            get: function get() {
+                return this.getTextureCoord(this.gltfMaterial.emissiveTexture);
+            }
+        },
+        {
+            key: "emissiveTextureTransfrom",
+            get: function get() {
+                return this.getTextureTransform(this.gltfMaterial.emissiveTexture);
+            }
+        },
+        {
+            key: "hasEmissive",
+            get: function get() {
+                var factor = this.emissiveFactor;
+                return factor[0] + factor[1] + factor[2] > 0;
+            }
+        },
+        {
+            key: "baseColorFactor",
+            get: function get() {
+                var f = this.gltfMaterial.baseColorFactor;
+                if (f === undefined || f.length != 4) {
+                    return [
+                        1,
+                        1,
+                        1,
+                        1
+                    ];
+                } else {
+                    return [
+                        f[0],
+                        f[1],
+                        f[2],
+                        f[3]
+                    ];
+                }
+            }
+        },
+        {
+            key: "metalicFactor",
+            get: function get() {
+                var _this_gltfMaterial_metallicFactor;
+                return (_this_gltfMaterial_metallicFactor = this.gltfMaterial.metallicFactor) != null ? _this_gltfMaterial_metallicFactor : 1;
+            }
+        },
+        {
+            key: "roughnessFactor",
+            get: function get() {
+                var _this_gltfMaterial_roughnessFactor;
+                return (_this_gltfMaterial_roughnessFactor = this.gltfMaterial.roughnessFactor) != null ? _this_gltfMaterial_roughnessFactor : 1;
+            }
+        },
+        {
+            key: "normalTextureScale",
+            get: function get() {
+                var _this_gltfMaterial_normalTexture;
+                var _this_gltfMaterial_normalTexture_scale;
+                return (_this_gltfMaterial_normalTexture_scale = (_this_gltfMaterial_normalTexture = this.gltfMaterial.normalTexture) == null ? void 0 : _this_gltfMaterial_normalTexture.scale) != null ? _this_gltfMaterial_normalTexture_scale : 1;
+            }
+        },
+        {
+            key: "occlusionTextureStrength",
+            get: function get() {
+                var _this_gltfMaterial_occlusionTexture;
+                var _this_gltfMaterial_occlusionTexture_strength;
+                return (_this_gltfMaterial_occlusionTexture_strength = (_this_gltfMaterial_occlusionTexture = this.gltfMaterial.occlusionTexture) == null ? void 0 : _this_gltfMaterial_occlusionTexture.strength) != null ? _this_gltfMaterial_occlusionTexture_strength : 1;
+            }
+        },
+        {
+            key: "emissiveFactor",
+            get: function get() {
+                var f = this.gltfMaterial.emissiveFactor;
+                if (f === undefined || f.length != 4) {
+                    return [
+                        0,
+                        0,
+                        0,
+                        1
+                    ];
+                } else {
+                    return [
+                        f[0],
+                        f[1],
+                        f[2],
+                        1.0
+                    ];
+                }
+            }
+        }
+    ]);
+    return MaterialProxy;
+}();
+var GLTFHelper = /*#__PURE__*/ function() {
+    function GLTFHelper() {}
+    GLTFHelper.isUnlitMaterial = function isUnlitMaterial(mat) {
+        var _mat_extensions;
+        return ((_mat_extensions = mat.extensions) == null ? void 0 : _mat_extensions.KHR_materials_unlit) !== undefined;
+    };
+    GLTFHelper.createBoxFromGLTFBound = function createBoxFromGLTFBound(bound) {
+        var boxMin = Vector3.fromArray(bound.box.min);
+        var boxMax = Vector3.fromArray(bound.box.max);
+        return new Box3(boxMin, boxMax);
+    };
+    return GLTFHelper;
+}();
 
 EFFECTS.registerPlugin("tree", ModelTreePlugin, EFFECTS.VFXItem, true);
 EFFECTS.registerPlugin("model", ModelPlugin, EFFECTS.VFXItem);
-var version = "2.0.0-alpha.22";
+var version = "2.0.0-alpha.23";
 EFFECTS.logger.info("Plugin model version: " + version + ".");
 if (version !== EFFECTS__namespace.version) {
     console.error("注意：请统一 Model 插件与 Player 版本，不统一的版本混用会有不可预知的后果！", "\nAttention: Please ensure the Model plugin is synchronized with the Player version. Mixing and matching incompatible versions may result in unpredictable consequences!");