@galacean/engine-loader 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/miniprogram.js

@@ -1824,21 +1824,31 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
         var vertexCount;
         var bufferBindIndex = 0;
         var positions;
-        keepMeshData && (positions = new Array(vertexCount));
+        var boneIndices;
+        var boneWeights;
+        if (keepMeshData) {
+            positions = new Array(vertexCount);
+            boneIndices = new Array(vertexCount);
+            boneWeights = new Array(vertexCount);
+        }
         for(var attribute in attributes){
             var accessor = accessors[attributes[attribute]];
             var accessorBuffer = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, accessor);
             var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
-            var attributeCount = accessor.count;
+            var accessorCount = accessor.count;
             var vertices = accessorBuffer.data;
             var vertexElement = void 0;
             var meshId = mesh.instanceId;
             var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, accessor.normalized);
+            var elementNormalized = accessor.normalized;
+            var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
+            var scaleFactor = void 0;
+            elementNormalized && (scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType));
+            var elementOffset = void 0;
             if (accessorBuffer.interleaved) {
                 var byteOffset = accessor.byteOffset || 0;
                 var stride = accessorBuffer.stride;
-                var elementOffset = byteOffset % stride;
+                elementOffset = byteOffset % stride;
                 if (vertexBindingInfos[meshId] === undefined) {
                     vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                     var vertexBuffer = accessorBuffer.vertexBuffer;
@@ -1854,7 +1864,8 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                     vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
                 }
             } else {
-                vertexElement = new miniprogram.VertexElement(attribute, 0, elementFormat, bufferBindIndex);
+                elementOffset = 0;
+                vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
                 var vertexBuffer1 = new miniprogram.Buffer(engine, miniprogram.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram.BufferUsage.Static);
                 vertexBuffer1.setData(vertices);
                 meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer1, accessorBuffer.restoreInfo));
@@ -1863,35 +1874,61 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
             }
             vertexElements.push(vertexElement);
             if (attribute === "POSITION") {
-                vertexCount = attributeCount;
+                vertexCount = accessorCount;
                 var _mesh_bounds = mesh.bounds, min = _mesh_bounds.min, max = _mesh_bounds.max;
                 if (accessor.min && accessor.max) {
                     min.copyFromArray(accessor.min);
                     max.copyFromArray(accessor.max);
                     if (keepMeshData) {
-                        var stride1 = vertices.length / attributeCount;
-                        for(var j = 0; j < attributeCount; j++){
-                            var offset = j * stride1;
-                            positions[j] = new miniprogram$1.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                        var baseOffset = elementOffset / vertices.BYTES_PER_ELEMENT;
+                        var stride1 = vertices.length / accessorCount;
+                        for(var j = 0; j < accessorCount; j++){
+                            var offset = baseOffset + j * stride1;
+                            var position = new miniprogram$1.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                            elementNormalized && position.scale(scaleFactor);
+                            positions[j] = position;
                         }
                     }
                 } else {
-                    var position = GLTFMeshParser._tempVector3;
+                    var position1 = GLTFMeshParser._tempVector3;
                     min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
                     max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-                    var stride2 = vertices.length / attributeCount;
-                    for(var j1 = 0; j1 < attributeCount; j1++){
-                        var offset1 = j1 * stride2;
-                        position.copyFromArray(vertices, offset1);
-                        miniprogram$1.Vector3.min(min, position, min);
-                        miniprogram$1.Vector3.max(max, position, max);
+                    var baseOffset1 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                    var stride2 = vertices.length / accessorCount;
+                    for(var j1 = 0; j1 < accessorCount; j1++){
+                        var offset1 = baseOffset1 + j1 * stride2;
+                        position1.copyFromArray(vertices, offset1);
+                        miniprogram$1.Vector3.min(min, position1, min);
+                        miniprogram$1.Vector3.max(max, position1, max);
+                        if (keepMeshData) {
+                            var clonePosition = position1.clone();
+                            elementNormalized && clonePosition.scale(scaleFactor);
+                            positions[j1] = clonePosition;
+                        }
                     }
                 }
-                if (accessor.normalized) {
-                    var scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType);
+                if (elementNormalized) {
                     min.scale(scaleFactor);
                     max.scale(scaleFactor);
                 }
+            } else if (attribute === "JOINTS_0" && keepMeshData) {
+                var baseOffset2 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                var stride3 = vertices.length / accessorCount;
+                for(var j2 = 0; j2 < accessorCount; j2++){
+                    var offset2 = baseOffset2 + j2 * stride3;
+                    var boneIndex = new miniprogram$1.Vector4(vertices[offset2], vertices[offset2 + 1], vertices[offset2 + 2], vertices[offset2 + 3]);
+                    elementNormalized && boneIndex.scale(scaleFactor);
+                    boneIndices[j2] = boneIndex;
+                }
+            } else if (attribute === "WEIGHTS_0" && keepMeshData) {
+                var baseOffset3 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                var stride4 = vertices.length / accessorCount;
+                for(var j3 = 0; j3 < accessorCount; j3++){
+                    var offset3 = baseOffset3 + j3 * stride4;
+                    var boneWeight = new miniprogram$1.Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
+                    elementNormalized && boneWeight.scale(scaleFactor);
+                    boneWeights[j3] = boneWeight;
+                }
             }
         }
         mesh.setVertexElements(vertexElements);
@@ -1910,6 +1947,10 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
         mesh.uploadData(!keepMeshData);
         //@ts-ignore
         mesh._positions = positions;
+        //@ts-ignore
+        mesh._boneIndices = boneIndices;
+        //@ts-ignore
+        mesh._boneWeights = boneWeights;
         return Promise.resolve(mesh);
     };
     /**
@@ -2000,14 +2041,7 @@ var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         camera.enabled = false;
     };
     _proto._createRenderer = function _createRenderer(context, glTFNode, entity) {
-        var glTFResource = context.glTFResource, glTF = context.glTF;
-        var glTFMeshes = glTF.meshes;
-        var engine = glTFResource.engine, meshes = glTFResource.meshes, materials = glTFResource.materials, skins = glTFResource.skins;
-        var meshID = glTFNode.mesh, skinID = glTFNode.skin;
-        var glTFMesh = glTFMeshes[meshID];
-        var glTFMeshPrimitives = glTFMesh.primitives;
-        var blendShapeWeights = glTFNode.weights || glTFMesh.weights;
-        for(var i = 0; i < glTFMeshPrimitives.length; i++){
+        var _loop = function(i) {
             var gltfPrimitive = glTFMeshPrimitives[i];
             var mesh = meshes[meshID][i];
             var renderer = void 0;
@@ -2029,8 +2063,22 @@ var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
             var materialIndex = gltfPrimitive.material;
             var material = (materials == null ? void 0 : materials[materialIndex]) || GLTFSceneParser._getDefaultMaterial(engine);
             renderer.setMaterial(material);
+            // Enable vertex color if mesh has COLOR_0 vertex element
+            mesh.vertexElements.forEach(function(element) {
+                if (element.semantic === "COLOR_0") {
+                    renderer.enableVertexColor = true;
+                }
+            });
             GLTFParser.executeExtensionsAdditiveAndParse(gltfPrimitive.extensions, context, renderer, gltfPrimitive);
-        }
+        };
+        var glTFResource = context.glTFResource, glTF = context.glTF;
+        var glTFMeshes = glTF.meshes;
+        var engine = glTFResource.engine, meshes = glTFResource.meshes, materials = glTFResource.materials, skins = glTFResource.skins;
+        var meshID = glTFNode.mesh, skinID = glTFNode.skin;
+        var glTFMesh = glTFMeshes[meshID];
+        var glTFMeshPrimitives = glTFMesh.primitives;
+        var blendShapeWeights = glTFNode.weights || glTFMesh.weights;
+        for(var i = 0; i < glTFMeshPrimitives.length; i++)_loop(i);
     };
     _proto._createAnimator = function _createAnimator(context) {
         if (!context.hasSkinned && !context.glTFResource.animations) {
@@ -2328,7 +2376,9 @@ var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
         return _this;
     }
     var _proto = GLTFResource.prototype;
-    _proto._onDestroy = function _onDestroy() {
+    /**
+   * @internal
+   */ _proto._onDestroy = function _onDestroy() {
         EngineObject.prototype._onDestroy.call(this);
         this.defaultSceneRoot.destroy();
         this.textures = null;
@@ -2976,6 +3026,15 @@ KTXLoader = __decorate([
     ])
 ], KTXLoader);
 
+function parseProperty(object, key, value) {
+    if (typeof value === "object") {
+        for(var subKey in value){
+            parseProperty(object[key], subKey, value[subKey]);
+        }
+    } else {
+        object[key] = value;
+    }
+}
 var MaterialLoader = /*#__PURE__*/ function(Loader) {
     _inherits(MaterialLoader, Loader);
     function MaterialLoader() {
@@ -2987,7 +3046,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
         return new miniprogram.AssetPromise(function(resolve, reject) {
             _this.request(item.url, _extends({}, item, {
                 type: "json"
-            })).then(function(json) {
+            })).then(function(materialSchema) {
                 var _loop = function(key) {
                     var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
                     switch(type){
@@ -3015,27 +3074,8 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     }
                 };
                 var engine = resourceManager.engine;
-                var name = json.name, shader = json.shader, shaderData = json.shaderData, macros = json.macros, renderState = json.renderState;
-                var material;
-                switch(shader){
-                    case "pbr":
-                        material = new miniprogram.PBRMaterial(engine);
-                        break;
-                    case "pbr-specular":
-                        material = new miniprogram.PBRSpecularMaterial(engine);
-                        break;
-                    case "unlit":
-                        material = new miniprogram.UnlitMaterial(engine);
-                        break;
-                    case "blinn-phong":
-                        material = new miniprogram.BlinnPhongMaterial(engine);
-                        break;
-                    case "bake-pbr":
-                        // @todo refactor custom shader later
-                        // @ts-ignore
-                        material = new miniprogram.PBRBaseMaterial(engine, miniprogram.Shader.find("bake-pbr"));
-                        break;
-                }
+                var name = materialSchema.name, shader = materialSchema.shader, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
+                var material = new miniprogram.Material(engine, miniprogram.Shader.find(shader));
                 material.name = name;
                 var texturePromises = new Array();
                 var materialShaderData = material.shaderData;
@@ -3048,9 +3088,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                         materialShaderData.enableMacro(name1, value);
                     }
                 }
-                for(var key1 in renderState){
-                    material[key1] = renderState[key1];
-                }
+                parseProperty(material, "renderState", renderState);
                 return Promise.all(texturePromises).then(function() {
                     resolve(material);
                 });
@@ -3805,6 +3843,12 @@ exports.AnimationClipDecoder = __decorate([
     decoder("AnimationClip")
 ], exports.AnimationClipDecoder);
 
+exports.SpecularMode = void 0;
+(function(SpecularMode) {
+    SpecularMode["Sky"] = "Sky";
+    SpecularMode["Custom"] = "Custom";
+})(exports.SpecularMode || (exports.SpecularMode = {}));
+
 var SceneParserContext = /*#__PURE__*/ function() {
     function SceneParserContext(originalData, scene) {
         this.originalData = originalData;
@@ -4087,7 +4131,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
                     var atlasItem = atlasItems[i];
                     if (atlasItem.img) {
                         chainPromises.push(resourceManager.load({
-                            url: atlasItem.img,
+                            url: miniprogram.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
                             type: miniprogram.AssetType.Texture2D,
                             params: {
                                 format: format,
@@ -4363,47 +4407,63 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                 // @ts-ignore
                 engine.resourceManager.initVirtualResources(data.files);
                 return SceneParser.parse(engine, data).then(function(scene) {
+                    var promises = [];
                     // parse ambient light
                     var ambient = data.scene.ambient;
-                    var ambientLightPromise = Promise.resolve();
-                    if (ambient.ambientLight) {
-                        ambientLightPromise = resourceManager// @ts-ignore
-                        .getResourceByRef(data.scene.ambient.ambientLight).then(function(light) {
-                            scene.ambientLight = light;
+                    var useCustomAmbient = ambient.specularMode === "Custom";
+                    if (useCustomAmbient && ambient.customAmbientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var customAmbientPromise = resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
                             scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                             scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
                         });
-                    } else {
-                        scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
-                        scene.ambientLight.specularIntensity = ambient.specularIntensity;
-                        scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+                        promises.push(customAmbientPromise);
+                    } else if (!useCustomAmbient && ambient.ambientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var ambientLightPromise = resourceManager.getResourceByRef(ambient.ambientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
+                            scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+                            scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+                        });
+                        promises.push(ambientLightPromise);
                     }
                     var background = data.scene.background;
                     scene.background.mode = background.mode;
-                    var backgroundPromise = Promise.resolve();
                     switch(scene.background.mode){
                         case miniprogram.BackgroundMode.SolidColor:
                             scene.background.solidColor.copyFrom(background.color);
                             break;
                         case miniprogram.BackgroundMode.Sky:
-                            if (background.sky) {
+                            if (background.skyMesh && background.skyMaterial) {
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.sky).then(function(light) {
-                                    var sky = scene.background.sky;
-                                    var skyMaterial = new miniprogram.SkyBoxMaterial(engine);
-                                    skyMaterial.texture = light.specularTexture;
-                                    skyMaterial.textureDecodeRGBM = true;
-                                    sky.material = skyMaterial;
-                                    sky.mesh = miniprogram.PrimitiveMesh.createCuboid(engine, 1, 1, 1);
+                                var skyMeshPromise = resourceManager.getResourceByRef(background.skyMesh).then(function(mesh) {
+                                    scene.background.sky.mesh = mesh;
                                 });
+                                // @ts-ignore
+                                // prettier-ignore
+                                var skyMaterialPromise = resourceManager.getResourceByRef(background.skyMaterial).then(function(material) {
+                                    scene.background.sky.material = material;
+                                });
+                                promises.push(skyMeshPromise, skyMaterialPromise);
+                            } else {
+                                miniprogram.Logger.warn("Sky background mode requires skyMesh and skyMaterial");
                             }
                             break;
                         case miniprogram.BackgroundMode.Texture:
                             if (background.texture) {
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
+                                // prettier-ignore
+                                var backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
                                     scene.background.texture = texture;
                                 });
+                                promises.push(backgroundPromise);
                             }
                             break;
                     }
@@ -4415,10 +4475,7 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                         if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
                         if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
                     }
-                    return Promise.all([
-                        ambientLightPromise,
-                        backgroundPromise
-                    ]).then(function() {
+                    return Promise.all(promises).then(function() {
                         resolve(scene);
                     });
                 });
@@ -4678,6 +4735,22 @@ KHR_materials_clearcoat = __decorate([
     registerGLTFExtension("KHR_materials_clearcoat", exports.GLTFExtensionMode.AdditiveParse)
 ], KHR_materials_clearcoat);
 
+var KHR_materials_ior = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_ior, GLTFExtensionParser);
+    function KHR_materials_ior() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_ior.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var _schema_ior = schema.ior, ior = _schema_ior === void 0 ? 1.5 : _schema_ior;
+        material.ior = ior;
+    };
+    return KHR_materials_ior;
+}(GLTFExtensionParser);
+KHR_materials_ior = __decorate([
+    registerGLTFExtension("KHR_materials_ior", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_materials_ior);
+
 var KHR_materials_pbrSpecularGlossiness = /*#__PURE__*/ function(GLTFExtensionParser) {
     _inherits(KHR_materials_pbrSpecularGlossiness, GLTFExtensionParser);
     function KHR_materials_pbrSpecularGlossiness() {