@galacean/engine-loader 1.4.0-alpha.1 → 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() {
@@ -6473,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() {
@@ -6580,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);
@@ -6796,6 +6835,28 @@ 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() {
@@ -6848,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() {