@galacean/engine-loader 2.0.0-alpha.54 → 2.0.0-alpha.56

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/main.js CHANGED
@@ -5762,78 +5762,104 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
5762
5762
  }
5763
5763
  }
5764
5764
  var engine = resourceManager.engine;
5765
- var shader = engineCore.Shader.find(shaderName);
5766
- if (shader) {
5767
- return _this._getMaterialByShader(materialSchema, shader, engine);
5768
- }
5769
- if (!shaderRef) {
5770
- throw new Error('MaterialLoader: shader "' + shaderName + '" not found.');
5765
+ if (shaderRef) {
5766
+ return resourceManager.getResourceByRef(shaderRef).then(function(shader) {
5767
+ if (!_instanceof(shader, engineCore.Shader)) {
5768
+ throw new Error('MaterialLoader: shader reference "' + shaderRef.url + '" did not resolve to a Shader.');
5769
+ }
5770
+ return _this._getMaterialByShader(materialSchema, shader, engine);
5771
+ });
5771
5772
  }
5772
- return resourceManager.getResourceByRef(shaderRef).then(function(shader) {
5773
- if (!_instanceof(shader, engineCore.Shader)) {
5774
- throw new Error('MaterialLoader: shader reference "' + shaderRef.url + '" did not resolve to a Shader.');
5775
- }
5776
- return _this._getMaterialByShader(materialSchema, shader, engine);
5777
- });
5773
+ var shader = shaderName && engineCore.Shader.find(shaderName);
5774
+ if (!shader) throw new Error('MaterialLoader: shader "' + shaderName + '" not found.');
5775
+ return _this._getMaterialByShader(materialSchema, shader, engine);
5778
5776
  });
5779
5777
  };
5780
5778
  _proto._getMaterialByShader = function _getMaterialByShader(materialSchema, shader, engine) {
5781
- var _loop = function(key) {
5782
- var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
5783
- switch(type){
5784
- case MaterialLoaderType.Vector2:
5785
- materialShaderData.setVector2(key, new engineMath.Vector2(value.x, value.y));
5786
- break;
5787
- case MaterialLoaderType.Vector3:
5788
- materialShaderData.setVector3(key, new engineMath.Vector3(value.x, value.y, value.z));
5789
- break;
5790
- case MaterialLoaderType.Vector4:
5791
- materialShaderData.setVector4(key, new engineMath.Vector4(value.x, value.y, value.z, value.w));
5792
- break;
5793
- case MaterialLoaderType.Color:
5794
- materialShaderData.setColor(key, new engineMath.Color(value.r, value.g, value.b, value.a));
5795
- break;
5796
- case MaterialLoaderType.Float:
5797
- materialShaderData.setFloat(key, value);
5798
- break;
5799
- case MaterialLoaderType.Texture:
5800
- texturePromises.push(engine.resourceManager.getResourceByRef(value).then(function(texture) {
5801
- if (!_instanceof(texture, engineCore.Texture)) {
5802
- throw new Error('MaterialLoader: texture reference "' + value.url + '" did not resolve to a Texture.');
5779
+ return _async_to_generator(function() {
5780
+ var _loop, name, shaderData, macros, textures, texturePromises, material, materialShaderData, _shaderData_key, type, value, i, length, _macros_i, name1, value1;
5781
+ return __generator(this, function(_state) {
5782
+ switch(_state.label){
5783
+ case 0:
5784
+ _loop = function(key) {
5785
+ var property = shaderData[key];
5786
+ if (property.type === MaterialLoaderType.Texture) {
5787
+ var value = property.value;
5788
+ texturePromises.push(engine.resourceManager.getResourceByRef(value).then(function(texture) {
5789
+ if (!_instanceof(texture, engineCore.Texture)) {
5790
+ throw new Error('MaterialLoader: texture reference "' + value.url + '" did not resolve to a Texture.');
5791
+ }
5792
+ textures.set(key, texture);
5793
+ }));
5794
+ }
5795
+ };
5796
+ name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
5797
+ textures = new Map();
5798
+ texturePromises = new Array();
5799
+ for(var key in shaderData)_loop(key);
5800
+ return [
5801
+ 4,
5802
+ Promise.all(texturePromises)
5803
+ ];
5804
+ case 1:
5805
+ _state.sent();
5806
+ material = new engineCore.Material(engine, shader);
5807
+ try {
5808
+ material.name = name;
5809
+ materialShaderData = material.shaderData;
5810
+ for(var key1 in shaderData){
5811
+ _shaderData_key = shaderData[key1], type = _shaderData_key.type, value = _shaderData_key.value;
5812
+ switch(type){
5813
+ case MaterialLoaderType.Vector2:
5814
+ materialShaderData.setVector2(key1, new engineMath.Vector2(value.x, value.y));
5815
+ break;
5816
+ case MaterialLoaderType.Vector3:
5817
+ materialShaderData.setVector3(key1, new engineMath.Vector3(value.x, value.y, value.z));
5818
+ break;
5819
+ case MaterialLoaderType.Vector4:
5820
+ materialShaderData.setVector4(key1, new engineMath.Vector4(value.x, value.y, value.z, value.w));
5821
+ break;
5822
+ case MaterialLoaderType.Color:
5823
+ materialShaderData.setColor(key1, new engineMath.Color(value.r, value.g, value.b, value.a));
5824
+ break;
5825
+ case MaterialLoaderType.Float:
5826
+ materialShaderData.setFloat(key1, value);
5827
+ break;
5828
+ case MaterialLoaderType.Texture:
5829
+ materialShaderData.setTexture(key1, textures.get(key1));
5830
+ break;
5831
+ case MaterialLoaderType.Boolean:
5832
+ materialShaderData.setInt(key1, value ? 1 : 0);
5833
+ break;
5834
+ case MaterialLoaderType.Integer:
5835
+ materialShaderData.setInt(key1, Number(value));
5836
+ break;
5837
+ default:
5838
+ throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
5839
+ }
5840
+ }
5841
+ for(i = 0, length = macros.length; i < length; i++){
5842
+ _macros_i = macros[i], name1 = _macros_i.name, value1 = _macros_i.value;
5843
+ if (value1 == undefined) {
5844
+ materialShaderData.enableMacro(name1);
5845
+ } else {
5846
+ materialShaderData.enableMacro(name1, value1);
5847
+ }
5848
+ }
5849
+ return [
5850
+ 2,
5851
+ material
5852
+ ];
5853
+ } catch (error) {
5854
+ material.destroy();
5855
+ throw error;
5803
5856
  }
5804
- materialShaderData.setTexture(key, texture);
5805
- }));
5806
- break;
5807
- case MaterialLoaderType.Boolean:
5808
- materialShaderData.setInt(key, value ? 1 : 0);
5809
- break;
5810
- case MaterialLoaderType.Integer:
5811
- materialShaderData.setInt(key, Number(value));
5812
- break;
5813
- default:
5814
- throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
5815
- }
5816
- };
5817
- var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
5818
- var material = new engineCore.Material(engine, shader);
5819
- material.name = name;
5820
- var texturePromises = new Array();
5821
- var materialShaderData = material.shaderData;
5822
- for(var key in shaderData)_loop(key);
5823
- for(var i = 0, length = macros.length; i < length; i++){
5824
- var _macros_i = macros[i], name1 = _macros_i.name, value = _macros_i.value;
5825
- if (value == undefined) {
5826
- materialShaderData.enableMacro(name1);
5827
- } else {
5828
- materialShaderData.enableMacro(name1, value);
5829
- }
5830
- }
5831
- return Promise.all(texturePromises).then(function() {
5832
- return material;
5833
- }, function(error) {
5834
- material.destroy();
5835
- throw error;
5836
- });
5857
+ return [
5858
+ 2
5859
+ ];
5860
+ }
5861
+ });
5862
+ })();
5837
5863
  };
5838
5864
  return MaterialLoader;
5839
5865
  }(engineCore.Loader);
@@ -6390,11 +6416,7 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
6390
6416
  type: "text"
6391
6417
  })).then(function(code) {
6392
6418
  var source = code.trimStart();
6393
- var shader = source.startsWith("{") ? engineCore.Shader._createFromPrecompiled(JSON.parse(source)) : engineCore.Shader._createFromSource(code, undefined, sourceFileForShader(url, resourceManager.baseUrl));
6394
- if (!shader) {
6395
- throw new Error('ShaderLoader: failed to create shader "' + url + '".');
6396
- }
6397
- return shader;
6419
+ return source.startsWith("{") ? engineCore.Shader._createFromPrecompiled(JSON.parse(source)) : engineCore.Shader._createFromSource(code, undefined, sourceFileForShader(url, resourceManager.baseUrl));
6398
6420
  });
6399
6421
  };
6400
6422
  return ShaderLoader;