@galacean/engine-loader 1.4.0-alpha.0 → 1.4.0-alpha.2

package/dist/main.js

@@ -537,11 +537,7 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
     return ParserType;
 }({});
 /**
- * Parser context
- * @export
- * @class ParserContext
- * @template T
- * @template I
+ * @internal
  */ var ParserContext = /*#__PURE__*/ function() {
     function ParserContext(engine, type, resource) {
         if (type === void 0) type = 1;
@@ -553,13 +549,39 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
         this.components = new Map();
         this.rootIds = [];
         this.strippedIds = [];
+        this.componentWaitingMap = new Map();
         this.resourceManager = engine.resourceManager;
     }
     var _proto = ParserContext.prototype;
-    /**
-   * Destroy the context.
-   * @memberof ParserContext
-   */ _proto.clear = function clear() {
+    _proto.addComponent = function addComponent(id, component) {
+        this.components.set(id, component);
+        var waitingList = this.componentWaitingMap.get(id);
+        if (waitingList == null ? void 0 : waitingList.length) {
+            waitingList.forEach(function(resolve) {
+                return resolve(component);
+            });
+            this.componentWaitingMap.delete(id);
+        }
+    };
+    _proto.getComponentByRef = function getComponentByRef(ref) {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            var component = _this.components.get(ref.componentId);
+            if (component) {
+                resolve(component);
+            } else {
+                var resolves = _this.componentWaitingMap.get(ref.componentId);
+                if (resolves) {
+                    resolves.push(resolve);
+                } else {
+                    _this.componentWaitingMap.set(ref.componentId, [
+                        resolve
+                    ]);
+                }
+            }
+        });
+    };
+    _proto.clear = function clear() {
         this.entityMap.clear();
         this.components.clear();
         this.entityConfigMap.clear();
@@ -659,6 +681,8 @@ var ReflectionParser = /*#__PURE__*/ function() {
                     }
                     return resource;
                 });
+            } else if (ReflectionParser._isComponentRef(value)) {
+                return this._context.getComponentByRef(value);
             } else if (ReflectionParser._isEntityRef(value)) {
                 // entity reference
                 return Promise.resolve(this._context.entityMap.get(value.entityId));
@@ -720,13 +744,16 @@ var ReflectionParser = /*#__PURE__*/ function() {
         this.customParseComponentHandles[componentType] = handle;
     };
     ReflectionParser._isClass = function _isClass(value) {
-        return value["class"] != undefined;
+        return value["class"] !== undefined;
     };
     ReflectionParser._isAssetRef = function _isAssetRef(value) {
-        return value["refId"] != undefined;
+        return value["refId"] !== undefined;
     };
     ReflectionParser._isEntityRef = function _isEntityRef(value) {
-        return value["entityId"] != undefined;
+        return value["entityId"] !== undefined;
+    };
+    ReflectionParser._isComponentRef = function _isComponentRef(value) {
+        return value["ownerId"] !== undefined && value["componentId"] !== undefined;
     };
     return ReflectionParser;
 }();
@@ -1083,7 +1110,6 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
     _proto._parseComponents = function _parseComponents() {
         var entitiesConfig = this.data.entities;
         var entityMap = this.context.entityMap;
-        var components = this.context.components;
         var promises = [];
         for(var i = 0, l = entitiesConfig.length; i < l; i++){
             var entityConfig = entitiesConfig[i];
@@ -1092,11 +1118,17 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
                 var componentConfig = entityConfig.components[i1];
                 var key = !componentConfig.refId ? componentConfig.class : componentConfig.refId;
                 var component = entity.addComponent(engineCore.Loader.getClass(key));
-                components.set(componentConfig.id, component);
+                this.context.addComponent(componentConfig.id, component);
                 var promise = this._reflectionParser.parsePropsAndMethods(component, componentConfig);
                 promises.push(promise);
             }
         }
+        for(var _iterator = _create_for_of_iterator_helper_loose(this.context.componentWaitingMap.values()), _step; !(_step = _iterator()).done;){
+            var waitingList = _step.value;
+            waitingList.forEach(function(resolve) {
+                return resolve(null);
+            });
+        }
         return Promise.all(promises);
     };
     _proto._parsePrefabModification = function _parsePrefabModification() {
@@ -1574,32 +1606,18 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
     var _proto = EnvLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         return new engineCore.AssetPromise(function(resolve, reject) {
-            resourceManager// @ts-ignore
-            ._request(item.url, _extends({}, item, {
+            var requestConfig = _extends({}, item, {
                 type: "arraybuffer"
-            })).then(function(arraybuffer) {
-                var _this;
-                var shArray = new Float32Array(arraybuffer, 0, 27);
-                var shByteLength = 27 * 4;
-                var size = (_this = new Uint16Array(arraybuffer, shByteLength, 1)) == null ? void 0 : _this[0];
-                var engine = resourceManager.engine;
-                var texture = new engineCore.TextureCube(engine, size);
-                texture.filterMode = engineCore.TextureFilterMode.Trilinear;
-                var mipmapCount = texture.mipmapCount;
-                var offset = shByteLength + 2;
-                for(var mipLevel = 0; mipLevel < mipmapCount; mipLevel++){
-                    var mipSize = size >> mipLevel;
-                    for(var face = 0; face < 6; face++){
-                        var dataSize = mipSize * mipSize * 4;
-                        var data = new Uint8Array(arraybuffer, offset, dataSize);
-                        offset += dataSize;
-                        texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + face, data, mipLevel);
-                    }
-                }
+            });
+            var engine = resourceManager.engine;
+            resourceManager// @ts-ignore
+            ._request(item.url, requestConfig).then(function(arraybuffer) {
+                var texture = EnvLoader._setTextureByBuffer(engine, arraybuffer);
+                engine.resourceManager.addContentRestorer(new EnvContentRestorer(texture, item.url, requestConfig));
                 var ambientLight = new engineCore.AmbientLight(engine);
                 var sh = new engineMath.SphericalHarmonics3();
                 ambientLight.diffuseMode = engineCore.DiffuseMode.SphericalHarmonics;
-                sh.copyFromArray(shArray);
+                sh.copyFromArray(new Float32Array(arraybuffer, 0, 27));
                 ambientLight.diffuseSphericalHarmonics = sh;
                 ambientLight.specularTexture = texture;
                 ambientLight.specularTextureDecodeRGBM = true;
@@ -1609,6 +1627,27 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
             });
         });
     };
+    /**
+   * @internal
+   */ EnvLoader._setTextureByBuffer = function _setTextureByBuffer(engine, buffer, texture) {
+        var _this;
+        var shByteLength = 27 * 4;
+        var size = (_this = new Uint16Array(buffer, shByteLength, 1)) == null ? void 0 : _this[0];
+        texture || (texture = new engineCore.TextureCube(engine, size));
+        texture.filterMode = engineCore.TextureFilterMode.Trilinear;
+        var mipmapCount = texture.mipmapCount;
+        var offset = shByteLength + 2;
+        for(var mipLevel = 0; mipLevel < mipmapCount; mipLevel++){
+            var mipSize = size >> mipLevel;
+            for(var face = 0; face < 6; face++){
+                var dataSize = mipSize * mipSize * 4;
+                var data = new Uint8Array(buffer, offset, dataSize);
+                offset += dataSize;
+                texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + face, data, mipLevel);
+            }
+        }
+        return texture;
+    };
     return EnvLoader;
 }(engineCore.Loader);
 EnvLoader = __decorate([
@@ -1616,6 +1655,27 @@ EnvLoader = __decorate([
         "env"
     ])
 ], EnvLoader);
+/**
+ * @internal
+ */ var EnvContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(EnvContentRestorer, ContentRestorer);
+    function EnvContentRestorer(resource, url, requestConfig) {
+        var _this;
+        _this = ContentRestorer.call(this, resource) || this, _this.url = url, _this.requestConfig = requestConfig;
+        return _this;
+    }
+    var _proto = EnvContentRestorer.prototype;
+    _proto.restoreContent = function restoreContent() {
+        var _this = this;
+        return new engineCore.AssetPromise(function(resolve, reject) {
+            engineCore.request(_this.url, _this.requestConfig).then(function(buffer) {
+                EnvLoader._setTextureByBuffer(_this.resource.engine, buffer, _this.resource);
+                resolve(_this.resource);
+            }).catch(reject);
+        });
+    };
+    return EnvContentRestorer;
+}(engineCore.ContentRestorer);
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -2033,7 +2093,7 @@ FontLoader = __decorate([
         task.total += 1;
         taskPromise.then(function() {
             _this._setTaskCompleteProgress(++task.loaded, task.total);
-        });
+        }, function() {});
     };
     _proto._handleSubAsset = function _handleSubAsset(resource, type, index) {
         var _this = this;
@@ -6323,6 +6383,45 @@ TextureCubeLoader = __decorate([
     ])
 ], TextureCubeLoader);
 
+var AudioLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(AudioLoader, Loader);
+    function AudioLoader() {
+        return Loader.apply(this, arguments) || this;
+    }
+    var _proto = AudioLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        return new engineCore.AssetPromise(function(resolve, reject) {
+            var url = item.url;
+            var requestConfig = _extends({}, item, {
+                type: "arraybuffer"
+            });
+            // @ts-ignore
+            resourceManager._request(url, requestConfig).then(function(arrayBuffer) {
+                var audioClip = new engineCore.AudioClip(resourceManager.engine);
+                engineCore.AudioManager.getContext().decodeAudioData(arrayBuffer).then(function(result) {
+                    // @ts-ignore
+                    audioClip._setAudioSource(result);
+                    if (url.indexOf("data:") !== 0) {
+                        var index = url.lastIndexOf("/");
+                        audioClip.name = url.substring(index + 1);
+                    }
+                    resolve(audioClip);
+                }).catch(function(e) {
+                    reject(e);
+                });
+            });
+        });
+    };
+    return AudioLoader;
+}(engineCore.Loader);
+AudioLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Audio, [
+        "mp3",
+        "ogg",
+        "wav"
+    ])
+], AudioLoader);
+
 var ShaderChunkLoader = /*#__PURE__*/ function(Loader) {
     _inherits(ShaderChunkLoader, Loader);
     function ShaderChunkLoader() {
@@ -6360,7 +6459,7 @@ var ShaderChunkLoader = /*#__PURE__*/ function(Loader) {
     };
     return ShaderChunkLoader;
 }(engineCore.Loader);
-ShaderChunkLoader._shaderIncludeRegex = /\s#include\s+"([./][^\\"]+)"/gm;
+ShaderChunkLoader._shaderIncludeRegex = /#include\s+"([./][^\\"]+)"/gm;
 ShaderChunkLoader = __decorate([
     engineCore.resourceLoader("ShaderChunk", [
         "glsl"
@@ -6406,6 +6505,34 @@ ShaderLoader = __decorate([
     ])
 ], ShaderLoader);
 
+var PhysicsMaterialLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(PhysicsMaterialLoader, Loader);
+    function PhysicsMaterialLoader() {
+        return Loader.apply(this, arguments) || this;
+    }
+    var _proto = PhysicsMaterialLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        return resourceManager// @ts-ignore
+        ._request(item.url, _extends({}, item, {
+            type: "json"
+        })).then(function(data) {
+            var physicsMaterial = new engineCore.PhysicsMaterial();
+            physicsMaterial.bounciness = data.bounciness;
+            physicsMaterial.dynamicFriction = data.dynamicFriction;
+            physicsMaterial.staticFriction = data.staticFriction;
+            physicsMaterial.bounceCombine = data.bounceCombine;
+            physicsMaterial.frictionCombine = data.frictionCombine;
+            return physicsMaterial;
+        });
+    };
+    return PhysicsMaterialLoader;
+}(engineCore.Loader);
+PhysicsMaterialLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.PhysicsMaterial, [
+        "mesh"
+    ])
+], PhysicsMaterialLoader);
+
 var SceneLoader = /*#__PURE__*/ function(Loader) {
     _inherits(SceneLoader, Loader);
     function SceneLoader() {
@@ -6513,28 +6640,7 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                     // Post Process
                     var postProcessData = data.scene.postProcess;
                     if (postProcessData) {
-                        // @ts-ignore
-                        var postProcessManager = scene._postProcessManager;
-                        var bloomEffect = postProcessManager._bloomEffect;
-                        var tonemappingEffect = postProcessManager._tonemappingEffect;
-                        postProcessManager.isActive = postProcessData.isActive;
-                        bloomEffect.enabled = postProcessData.bloom.enabled;
-                        bloomEffect.downScale = postProcessData.bloom.downScale;
-                        bloomEffect.threshold = postProcessData.bloom.threshold;
-                        bloomEffect.scatter = postProcessData.bloom.scatter;
-                        bloomEffect.intensity = postProcessData.bloom.intensity;
-                        bloomEffect.tint.copyFrom(postProcessData.bloom.tint);
-                        bloomEffect.dirtIntensity = postProcessData.bloom.dirtIntensity;
-                        tonemappingEffect.enabled = postProcessData.tonemapping.enabled;
-                        tonemappingEffect.mode = postProcessData.tonemapping.mode;
-                        if (postProcessData.bloom.dirtTexture) {
-                            // @ts-ignore
-                            // prettier-ignore
-                            var dirtTexturePromise = resourceManager.getResourceByRef(postProcessData.bloom.dirtTexture).then(function(texture) {
-                                bloomEffect.dirtTexture = texture;
-                            });
-                            promises.push(dirtTexturePromise);
-                        }
+                        engineCore.Logger.warn("Post Process is not supported in scene yet, please add PostProcess component in entity instead.");
                     }
                     return Promise.all(promises).then(function() {
                         resolve(scene);
@@ -6698,6 +6804,59 @@ KHR_materials_pbrSpecularGlossiness = __decorate([
     registerGLTFExtension("KHR_materials_pbrSpecularGlossiness", GLTFExtensionMode.CreateAndParse)
 ], KHR_materials_pbrSpecularGlossiness);
 
+var KHR_materials_sheen = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_sheen, GLTFExtensionParser);
+    function KHR_materials_sheen() {
+        return GLTFExtensionParser.apply(this, arguments) || this;
+    }
+    var _proto = KHR_materials_sheen.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var sheenColorFactor = schema.sheenColorFactor, sheenColorTexture = schema.sheenColorTexture, _schema_sheenRoughnessFactor = schema.sheenRoughnessFactor, sheenRoughnessFactor = _schema_sheenRoughnessFactor === void 0 ? 0 : _schema_sheenRoughnessFactor, sheenRoughnessTexture = schema.sheenRoughnessTexture;
+        if (sheenColorFactor) {
+            material.sheenColor.set(engineMath.Color.linearToGammaSpace(sheenColorFactor[0]), engineMath.Color.linearToGammaSpace(sheenColorFactor[1]), engineMath.Color.linearToGammaSpace(sheenColorFactor[2]), undefined);
+        }
+        material.sheenRoughness = sheenRoughnessFactor;
+        if (sheenColorTexture) {
+            exports.GLTFMaterialParser._checkOtherTextureTransform(sheenColorTexture, "Sheen texture");
+            context.get(GLTFParserType.Texture, sheenColorTexture.index).then(function(texture) {
+                material.sheenColorTexture = texture;
+            });
+        }
+        if (sheenRoughnessTexture) {
+            exports.GLTFMaterialParser._checkOtherTextureTransform(sheenRoughnessTexture, "SheenRoughness texture");
+            context.get(GLTFParserType.Texture, sheenRoughnessTexture.index).then(function(texture) {
+                material.sheenRoughnessTexture = texture;
+            });
+        }
+    };
+    return KHR_materials_sheen;
+}(GLTFExtensionParser);
+KHR_materials_sheen = __decorate([
+    registerGLTFExtension("KHR_materials_sheen", GLTFExtensionMode.AdditiveParse)
+], KHR_materials_sheen);
+
+var KHR_materials_transmission = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_transmission, GLTFExtensionParser);
+    function KHR_materials_transmission() {
+        return GLTFExtensionParser.apply(this, arguments) || this;
+    }
+    var _proto = KHR_materials_transmission.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var _schema_transmissionFactor = schema.transmissionFactor, transmissionFactor = _schema_transmissionFactor === void 0 ? 0 : _schema_transmissionFactor, transmissionTexture = schema.transmissionTexture;
+        material.transmission = transmissionFactor;
+        if (transmissionTexture) {
+            exports.GLTFMaterialParser._checkOtherTextureTransform(transmissionTexture, "Transmission texture");
+            context.get(GLTFParserType.Texture, transmissionTexture.index).then(function(texture) {
+                material.transmissionTexture = texture;
+            });
+        }
+    };
+    return KHR_materials_transmission;
+}(GLTFExtensionParser);
+KHR_materials_transmission = __decorate([
+    registerGLTFExtension("KHR_materials_transmission", GLTFExtensionMode.AdditiveParse)
+], KHR_materials_transmission);
+
 var KHR_materials_unlit = /*#__PURE__*/ function(GLTFExtensionParser) {
     _inherits(KHR_materials_unlit, GLTFExtensionParser);
     function KHR_materials_unlit() {
@@ -6750,6 +6909,32 @@ KHR_materials_variants = __decorate([
     registerGLTFExtension("KHR_materials_variants", GLTFExtensionMode.AdditiveParse)
 ], KHR_materials_variants);
 
+var KHR_materials_volume = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_volume, GLTFExtensionParser);
+    function KHR_materials_volume() {
+        return GLTFExtensionParser.apply(this, arguments) || this;
+    }
+    var _proto = KHR_materials_volume.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var _schema_thicknessFactor = schema.thicknessFactor, thicknessFactor = _schema_thicknessFactor === void 0 ? 0 : _schema_thicknessFactor, thicknessTexture = schema.thicknessTexture, _schema_attenuationDistance = schema.attenuationDistance, attenuationDistance = _schema_attenuationDistance === void 0 ? Infinity : _schema_attenuationDistance, attenuationColor = schema.attenuationColor;
+        material.thickness = thicknessFactor;
+        material.attenuationDistance = attenuationDistance;
+        if (attenuationColor) {
+            material.attenuationColor.set(engineMath.Color.linearToGammaSpace(attenuationColor[0]), engineMath.Color.linearToGammaSpace(attenuationColor[1]), engineMath.Color.linearToGammaSpace(attenuationColor[2]), undefined);
+        }
+        if (thicknessTexture) {
+            exports.GLTFMaterialParser._checkOtherTextureTransform(thicknessTexture, "Thickness texture");
+            context.get(GLTFParserType.Texture, thicknessTexture.index).then(function(texture) {
+                material.thicknessTexture = texture;
+            });
+        }
+    };
+    return KHR_materials_volume;
+}(GLTFExtensionParser);
+KHR_materials_volume = __decorate([
+    registerGLTFExtension("KHR_materials_volume", GLTFExtensionMode.AdditiveParse)
+], KHR_materials_volume);
+
 var KHR_mesh_quantization = /*#__PURE__*/ function(GLTFExtensionParser) {
     _inherits(KHR_mesh_quantization, GLTFExtensionParser);
     function KHR_mesh_quantization() {