@galacean/engine-loader 2.0.0-alpha.43 → 2.0.0-alpha.44

package/dist/main.js

@@ -5780,6 +5780,7 @@ var KTXContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
     return KTXContentRestorer;
 }(engineCore.ContentRestorer);
 
+var materialLoaderTypes = new Set(Object.values(MaterialLoaderType));
 var MaterialLoader = /*#__PURE__*/ function(Loader) {
     _inherits(MaterialLoader, Loader);
     function MaterialLoader() {
@@ -5788,23 +5789,32 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
     var _proto = MaterialLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject) {
-            resourceManager// @ts-ignore
-            ._request(item.url, _extends({}, item, {
-                type: "json"
-            })).then(function(materialSchema) {
-                var engine = resourceManager.engine;
-                var shaderRef = materialSchema.shaderRef, shaderName = materialSchema.shader;
-                var shader = engineCore.Shader.find(shaderName);
-                if (shader) {
-                    resolve(_this._getMaterialByShader(materialSchema, shader, engine));
-                } else if (shaderRef) {
-                    resolve(resourceManager// @ts-ignore
-                    .getResourceByRef(shaderRef).then(function(shader) {
-                        return _this._getMaterialByShader(materialSchema, shader, engine);
-                    }));
+        // @ts-expect-error _request is @internal
+        return resourceManager._request(item.url, _extends({}, item, {
+            type: "json"
+        })).then(function(materialSchema) {
+            var shaderData = materialSchema.shaderData, shaderRef = materialSchema.shaderRef, shaderName = materialSchema.shader;
+            for(var key in shaderData){
+                var type = shaderData[key].type;
+                if (!materialLoaderTypes.has(type)) {
+                    throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
                 }
-            }).catch(reject);
+            }
+            var engine = resourceManager.engine;
+            var shader = engineCore.Shader.find(shaderName);
+            if (shader) {
+                return _this._getMaterialByShader(materialSchema, shader, engine);
+            }
+            if (!shaderRef) {
+                throw new Error('MaterialLoader: shader "' + shaderName + '" not found.');
+            }
+            // @ts-expect-error getResourceByRef is @internal
+            return resourceManager.getResourceByRef(shaderRef).then(function(shader) {
+                if (!_instanceof(shader, engineCore.Shader)) {
+                    throw new Error('MaterialLoader: shader reference "' + shaderRef.url + '" did not resolve to a Shader.');
+                }
+                return _this._getMaterialByShader(materialSchema, shader, engine);
+            });
         });
     };
     _proto._getMaterialByShader = function _getMaterialByShader(materialSchema, shader, engine) {
@@ -5827,8 +5837,11 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     materialShaderData.setFloat(key, value);
                     break;
                 case MaterialLoaderType.Texture:
-                    texturePromises.push(// @ts-ignore
+                    texturePromises.push(// @ts-expect-error getResourceByRef is @internal
                     engine.resourceManager.getResourceByRef(value).then(function(texture) {
+                        if (!_instanceof(texture, engineCore.Texture)) {
+                            throw new Error('MaterialLoader: texture reference "' + value.url + '" did not resolve to a Texture.');
+                        }
                         materialShaderData.setTexture(key, texture);
                     }));
                     break;
@@ -5838,6 +5851,8 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                 case MaterialLoaderType.Integer:
                     materialShaderData.setInt(key, Number(value));
                     break;
+                default:
+                    throw new Error('MaterialLoader: unsupported shader data type "' + type + '".');
             }
         };
         var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
@@ -5856,6 +5871,9 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
         }
         return Promise.all(texturePromises).then(function() {
             return material;
+        }, function(error) {
+            material.destroy();
+            throw error;
         });
     };
     return MaterialLoader;
@@ -6414,11 +6432,11 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
             type: "text"
         })).then(function(code) {
             var source = code.trimStart();
-            if (source.startsWith("{")) {
-                // @ts-expect-error _createFromPrecompiled is @internal
-                return engineCore.Shader._createFromPrecompiled(JSON.parse(source));
+            var shader = source.startsWith("{") ? engineCore.Shader._createFromPrecompiled(JSON.parse(source)) : engineCore.Shader.create(code, undefined, url);
+            if (!shader) {
+                throw new Error('ShaderLoader: failed to create shader "' + url + '".');
             }
-            return engineCore.Shader.create(code, undefined, url);
+            return shader;
         });
     };
     return ShaderLoader;