@galacean/engine-loader 2.0.0-alpha.53 → 2.0.0-alpha.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/module.js CHANGED
@@ -5758,78 +5758,104 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
5758
5758
  }
5759
5759
  }
5760
5760
  var engine = resourceManager.engine;
5761
- var shader = Shader.find(shaderName);
5762
- if (shader) {
5763
- return _this._getMaterialByShader(materialSchema, shader, engine);
5764
- }
5765
- if (!shaderRef) {
5766
- throw new Error('MaterialLoader: shader "' + shaderName + '" not found.');
5761
+ if (shaderRef) {
5762
+ return resourceManager.getResourceByRef(shaderRef).then(function(shader) {
5763
+ if (!_instanceof(shader, Shader)) {
5764
+ throw new Error('MaterialLoader: shader reference "' + shaderRef.url + '" did not resolve to a Shader.');
5765
+ }
5766
+ return _this._getMaterialByShader(materialSchema, shader, engine);
5767
+ });
5767
5768
  }
5768
- return resourceManager.getResourceByRef(shaderRef).then(function(shader) {
5769
- if (!_instanceof(shader, Shader)) {
5770
- throw new Error('MaterialLoader: shader reference "' + shaderRef.url + '" did not resolve to a Shader.');
5771
- }
5772
- return _this._getMaterialByShader(materialSchema, shader, engine);
5773
- });
5769
+ var shader = shaderName && Shader.find(shaderName);
5770
+ if (!shader) throw new Error('MaterialLoader: shader "' + shaderName + '" not found.');
5771
+ return _this._getMaterialByShader(materialSchema, shader, engine);
5774
5772
  });
5775
5773
  };
5776
5774
  _proto._getMaterialByShader = function _getMaterialByShader(materialSchema, shader, engine) {
5777
- var _loop = function(key) {
5778
- var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
5779
- switch(type){
5780
- case MaterialLoaderType.Vector2:
5781
- materialShaderData.setVector2(key, new Vector2(value.x, value.y));
5782
- break;
5783
- case MaterialLoaderType.Vector3:
5784
- materialShaderData.setVector3(key, new Vector3(value.x, value.y, value.z));
5785
- break;
5786
- case MaterialLoaderType.Vector4:
5787
- materialShaderData.setVector4(key, new Vector4(value.x, value.y, value.z, value.w));
5788
- break;
5789
- case MaterialLoaderType.Color:
5790
- materialShaderData.setColor(key, new Color(value.r, value.g, value.b, value.a));
5791
- break;
5792
- case MaterialLoaderType.Float:
5793
- materialShaderData.setFloat(key, value);
5794
- break;
5795
- case MaterialLoaderType.Texture:
5796
- texturePromises.push(engine.resourceManager.getResourceByRef(value).then(function(texture) {
5797
- if (!_instanceof(texture, Texture)) {
5798
- throw new Error('MaterialLoader: texture reference "' + value.url + '" did not resolve to a Texture.');
5775
+ return _async_to_generator(function() {
5776
+ var _loop, name, shaderData, macros, textures, texturePromises, material, materialShaderData, _shaderData_key, type, value, i, length, _macros_i, name1, value1;
5777
+ return __generator(this, function(_state) {
5778
+ switch(_state.label){
5779
+ case 0:
5780
+ _loop = function(key) {
5781
+ var property = shaderData[key];
5782
+ if (property.type === MaterialLoaderType.Texture) {
5783
+ var value = property.value;
5784
+ texturePromises.push(engine.resourceManager.getResourceByRef(value).then(function(texture) {
5785
+ if (!_instanceof(texture, Texture)) {
5786
+ throw new Error('MaterialLoader: texture reference "' + value.url + '" did not resolve to a Texture.');
5787
+ }
5788
+ textures.set(key, texture);
5789
+ }));
5790
+ }
5791
+ };
5792
+ name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
5793
+ textures = new Map();
5794
+ texturePromises = new Array();
5795
+ for(var key in shaderData)_loop(key);
5796
+ return [
5797
+ 4,
5798
+ Promise.all(texturePromises)
5799
+ ];
5800
+ case 1:
5801
+ _state.sent();
5802
+ material = new Material(engine, shader);
5803
+ try {
5804
+ material.name = name;
5805
+ materialShaderData = material.shaderData;
5806
+ for(var key1 in shaderData){
5807
+ _shaderData_key = shaderData[key1], type = _shaderData_key.type, value = _shaderData_key.value;
5808
+ switch(type){
5809
+ case MaterialLoaderType.Vector2:
5810
+ materialShaderData.setVector2(key1, new Vector2(value.x, value.y));
5811
+ break;
5812
+ case MaterialLoaderType.Vector3:
5813
+ materialShaderData.setVector3(key1, new Vector3(value.x, value.y, value.z));
5814
+ break;
5815
+ case MaterialLoaderType.Vector4:
5816
+ materialShaderData.setVector4(key1, new Vector4(value.x, value.y, value.z, value.w));
5817
+ break;
5818
+ case MaterialLoaderType.Color:
5819
+ materialShaderData.setColor(key1, new Color(value.r, value.g, value.b, value.a));
5820
+ break;
5821
+ case MaterialLoaderType.Float:
5822
+ materialShaderData.setFloat(key1, value);
5823
+ break;
5824
+ case MaterialLoaderType.Texture:
5825
+ materialShaderData.setTexture(key1, textures.get(key1));
5826
+ break;
5827
+ case MaterialLoaderType.Boolean:
5828
+ materialShaderData.setInt(key1, value ? 1 : 0);
5829
+ break;
5830
+ case MaterialLoaderType.Integer:
5831
+ materialShaderData.setInt(key1, Number(value));
5832
+ break;
5833
+ default:
5834
+ throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
5835
+ }
5836
+ }
5837
+ for(i = 0, length = macros.length; i < length; i++){
5838
+ _macros_i = macros[i], name1 = _macros_i.name, value1 = _macros_i.value;
5839
+ if (value1 == undefined) {
5840
+ materialShaderData.enableMacro(name1);
5841
+ } else {
5842
+ materialShaderData.enableMacro(name1, value1);
5843
+ }
5844
+ }
5845
+ return [
5846
+ 2,
5847
+ material
5848
+ ];
5849
+ } catch (error) {
5850
+ material.destroy();
5851
+ throw error;
5799
5852
  }
5800
- materialShaderData.setTexture(key, texture);
5801
- }));
5802
- break;
5803
- case MaterialLoaderType.Boolean:
5804
- materialShaderData.setInt(key, value ? 1 : 0);
5805
- break;
5806
- case MaterialLoaderType.Integer:
5807
- materialShaderData.setInt(key, Number(value));
5808
- break;
5809
- default:
5810
- throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
5811
- }
5812
- };
5813
- var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
5814
- var material = new Material(engine, shader);
5815
- material.name = name;
5816
- var texturePromises = new Array();
5817
- var materialShaderData = material.shaderData;
5818
- for(var key in shaderData)_loop(key);
5819
- for(var i = 0, length = macros.length; i < length; i++){
5820
- var _macros_i = macros[i], name1 = _macros_i.name, value = _macros_i.value;
5821
- if (value == undefined) {
5822
- materialShaderData.enableMacro(name1);
5823
- } else {
5824
- materialShaderData.enableMacro(name1, value);
5825
- }
5826
- }
5827
- return Promise.all(texturePromises).then(function() {
5828
- return material;
5829
- }, function(error) {
5830
- material.destroy();
5831
- throw error;
5832
- });
5853
+ return [
5854
+ 2
5855
+ ];
5856
+ }
5857
+ });
5858
+ })();
5833
5859
  };
5834
5860
  return MaterialLoader;
5835
5861
  }(Loader);
@@ -6386,11 +6412,7 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
6386
6412
  type: "text"
6387
6413
  })).then(function(code) {
6388
6414
  var source = code.trimStart();
6389
- var shader = source.startsWith("{") ? Shader._createFromPrecompiled(JSON.parse(source)) : Shader._createFromSource(code, undefined, sourceFileForShader(url, resourceManager.baseUrl));
6390
- if (!shader) {
6391
- throw new Error('ShaderLoader: failed to create shader "' + url + '".');
6392
- }
6393
- return shader;
6415
+ return source.startsWith("{") ? Shader._createFromPrecompiled(JSON.parse(source)) : Shader._createFromSource(code, undefined, sourceFileForShader(url, resourceManager.baseUrl));
6394
6416
  });
6395
6417
  };
6396
6418
  return ShaderLoader;