@galacean/engine-loader 0.0.0-experimental-shaderlab.2 → 0.0.0-experimental-stateMachine.0

package/dist/main.js

@@ -1886,6 +1886,7 @@ var TextureWrapMode;
         this.resourceManager = resourceManager;
         this.params = params;
         this.accessorBufferCache = {};
+        this.needAnimatorController = false;
         this._resourceCache = new Map();
         this._progress = {
             taskDetail: {},
@@ -1913,16 +1914,15 @@ var TextureWrapMode;
             return Promise.resolve(null);
         }
         var cache = this._resourceCache;
-        var isOnlyOne = type === 0 || type === 1;
-        var cacheKey = isOnlyOne || index === undefined ? "" + type : type + ":" + index;
+        var cacheKey = index === undefined ? "" + type : type + ":" + index;
         var resource = cache.get(cacheKey);
         if (resource) {
             return resource;
         }
-        if (isOnlyOne) {
-            resource = parser.parse(this);
-        } else {
-            var glTFItems = this.glTF[glTFSchemaMap[type]];
+        var glTFSchemaKey = glTFSchemaMap[type];
+        var isSubAsset = !!glTFResourceMap[type];
+        if (glTFSchemaKey) {
+            var glTFItems = this.glTF[glTFSchemaKey];
             if (glTFItems && (index === undefined || glTFItems[index])) {
                 if (index === undefined) {
                     resource = type === 8 ? glTFItems.map(function(_, index) {
@@ -1932,11 +1932,14 @@ var TextureWrapMode;
                     }));
                 } else {
                     resource = parser.parse(this, index);
-                    this._handleSubAsset(resource, type, index);
+                    isSubAsset && this._handleSubAsset(resource, type, index);
                 }
             } else {
                 resource = Promise.resolve(null);
             }
+        } else {
+            resource = parser.parse(this, index);
+            isSubAsset && this._handleSubAsset(resource, type, index);
         }
         cache.set(cacheKey, resource);
         return resource;
@@ -1945,6 +1948,7 @@ var TextureWrapMode;
         var _this = this;
         var promise = this.get(0).then(function(json) {
             _this.glTF = json;
+            _this.needAnimatorController = !!(json.skins || json.animations);
             return Promise.all([
                 _this.get(1),
                 _this.get(5),
@@ -1952,11 +1956,14 @@ var TextureWrapMode;
                 _this.get(7),
                 _this.get(9),
                 _this.get(10),
+                _this.get(11),
                 _this.get(2)
             ]).then(function() {
                 var glTFResource = _this.glTFResource;
-                if (glTFResource.skins || glTFResource.animations) {
-                    _this._createAnimator(_this, glTFResource.animations);
+                var animatorController = glTFResource.animatorController;
+                if (animatorController) {
+                    var animator = glTFResource._defaultSceneRoot.addComponent(engineCore.Animator);
+                    animator.animatorController = animatorController;
                 }
                 _this.resourceManager.addContentRestorer(_this.contentRestorer);
                 return glTFResource;
@@ -1975,40 +1982,21 @@ var TextureWrapMode;
             _this._setTaskCompleteProgress(++task.loaded, task.total);
         });
     };
-    _proto._createAnimator = function _createAnimator(context, animations) {
-        var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
-        var animator = defaultSceneRoot.addComponent(engineCore.Animator);
-        var animatorController = new engineCore.AnimatorController();
-        var layer = new engineCore.AnimatorControllerLayer("layer");
-        var animatorStateMachine = new engineCore.AnimatorStateMachine();
-        animatorController.addLayer(layer);
-        animator.animatorController = animatorController;
-        layer.stateMachine = animatorStateMachine;
-        if (animations) {
-            for(var i = 0; i < animations.length; i++){
-                var animationClip = animations[i];
-                var name = animationClip.name;
-                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
-                if (uniqueName !== name) {
-                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
-                }
-                var animatorState = animatorStateMachine.addState(uniqueName);
-                animatorState.clip = animationClip;
-            }
-        }
-    };
     _proto._handleSubAsset = function _handleSubAsset(resource, type, index) {
         var _this = this;
         var glTFResourceKey = glTFResourceMap[type];
-        if (!glTFResourceKey) return;
         if (type === 8) {
             var _this_glTFResource, _glTFResourceKey;
             ((_this_glTFResource = this.glTFResource)[_glTFResourceKey = glTFResourceKey] || (_this_glTFResource[_glTFResourceKey] = []))[index] = resource;
         } else {
             var url = this.glTFResource.url;
             resource.then(function(item) {
-                var _this_glTFResource, _glTFResourceKey;
-                ((_this_glTFResource = _this.glTFResource)[_glTFResourceKey = glTFResourceKey] || (_this_glTFResource[_glTFResourceKey] = []))[index] = item;
+                if (index == undefined) {
+                    _this.glTFResource[glTFResourceKey] = item;
+                } else {
+                    var _this_glTFResource, _glTFResourceKey;
+                    ((_this_glTFResource = _this.glTFResource)[_glTFResourceKey = glTFResourceKey] || (_this_glTFResource[_glTFResourceKey] = []))[index] = item;
+                }
                 if (type === 7) {
                     for(var i = 0, length = item.length; i < length; i++){
                         var mesh = item[i];
@@ -2056,11 +2044,12 @@ exports.GLTFParserType = void 0;
     GLTFParserType[GLTFParserType["Entity"] = 8] = "Entity";
     GLTFParserType[GLTFParserType["Skin"] = 9] = "Skin";
     GLTFParserType[GLTFParserType["Animation"] = 10] = "Animation";
+    GLTFParserType[GLTFParserType["AnimatorController"] = 11] = "AnimatorController";
 })(exports.GLTFParserType || (exports.GLTFParserType = {}));
 var _obj;
 var glTFSchemaMap = (_obj = {}, _obj[2] = "scenes", _obj[3] = "buffers", _obj[5] = "textures", _obj[6] = "materials", _obj[7] = "meshes", _obj[8] = "nodes", _obj[9] = "skins", _obj[10] = "animations", _obj[4] = "bufferViews", _obj);
 var _obj1;
-var glTFResourceMap = (_obj1 = {}, _obj1[2] = "_sceneRoots", _obj1[5] = "textures", _obj1[6] = "materials", _obj1[7] = "meshes", _obj1[8] = "entities", _obj1[9] = "skins", _obj1[10] = "animations", _obj1);
+var glTFResourceMap = (_obj1 = {}, _obj1[2] = "_sceneRoots", _obj1[5] = "textures", _obj1[6] = "materials", _obj1[7] = "meshes", _obj1[8] = "entities", _obj1[9] = "skins", _obj1[10] = "animations", _obj1[11] = "animatorController", _obj1);
 function registerGLTFParser(pipeline) {
     return function(Parser) {
         var parser = new Parser();
@@ -4840,6 +4829,48 @@ exports.GLTFBufferViewParser = __decorate([
     registerGLTFParser(exports.GLTFParserType.BufferView)
 ], exports.GLTFBufferViewParser);
 
+exports.GLTFAnimatorControllerParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFAnimatorControllerParser, GLTFParser1);
+    function GLTFAnimatorControllerParser() {
+        return GLTFParser1.apply(this, arguments);
+    }
+    var _proto = GLTFAnimatorControllerParser.prototype;
+    _proto.parse = function parse(context) {
+        var _this = this;
+        if (!context.needAnimatorController) {
+            return Promise.resolve(null);
+        }
+        return context.get(exports.GLTFParserType.Animation).then(function(animations) {
+            var animatorController = _this._createAnimatorController(animations);
+            return Promise.resolve(animatorController);
+        });
+    };
+    _proto._createAnimatorController = function _createAnimatorController(animations) {
+        var animatorController = new engineCore.AnimatorController();
+        var layer = new engineCore.AnimatorControllerLayer("layer");
+        var animatorStateMachine = new engineCore.AnimatorStateMachine();
+        animatorController.addLayer(layer);
+        layer.stateMachine = animatorStateMachine;
+        if (animations) {
+            for(var i = 0; i < animations.length; i++){
+                var animationClip = animations[i];
+                var name = animationClip.name;
+                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
+                if (uniqueName !== name) {
+                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
+                }
+                var animatorState = animatorStateMachine.addState(uniqueName);
+                animatorState.clip = animationClip;
+            }
+        }
+        return animatorController;
+    };
+    return GLTFAnimatorControllerParser;
+}(GLTFParser);
+exports.GLTFAnimatorControllerParser = __decorate([
+    registerGLTFParser(exports.GLTFParserType.AnimatorController)
+], exports.GLTFAnimatorControllerParser);
+
 // Source: https://github.com/zeux/meshoptimizer/blob/master/js/meshopt_decoder.js
 var MeshoptDecoder = function() {
     var unpack = function unpack(data) {
@@ -5077,7 +5108,8 @@ exports.GLTFLoader = __decorate([
 
 var _HDRLoader;
 var PI = Math.PI;
-var HDRLoader = (_HDRLoader = /*#__PURE__*/ function(Loader1) {
+var HDRLoader = (_HDRLoader = // referenece: https://www.flipcode.com/archives/HDR_Image_Reader.shtml
+/*#__PURE__*/ function(Loader1) {
     _inherits(HDRLoader1, Loader1);
     function HDRLoader1() {
         return Loader1.apply(this, arguments);
@@ -5247,15 +5279,20 @@ var HDRLoader = (_HDRLoader = /*#__PURE__*/ function(Loader1) {
         var dataRGBA = new Uint8Array(4 * width * height);
         var offset = 0, pos = 0;
         var ptrEnd = 4 * scanLineWidth;
-        var rgbeStart = new Uint8Array(4);
         var scanLineBuffer = new Uint8Array(ptrEnd);
         var numScanLines = height; // read in each successive scanLine
         while(numScanLines > 0 && pos < byteLength){
-            rgbeStart[0] = buffer[pos++];
-            rgbeStart[1] = buffer[pos++];
-            rgbeStart[2] = buffer[pos++];
-            rgbeStart[3] = buffer[pos++];
-            if (2 != rgbeStart[0] || 2 != rgbeStart[1] || (rgbeStart[2] << 8 | rgbeStart[3]) != scanLineWidth) {
+            var a = buffer[pos++];
+            var b = buffer[pos++];
+            var c = buffer[pos++];
+            var d = buffer[pos++];
+            if (a != 2 || b != 2 || c & 0x80 || width < 8 || width > 32767) {
+                // this file is not run length encoded
+                // read values sequentially
+                return buffer;
+            }
+            if ((c << 8 | d) != scanLineWidth) {
+                // eslint-disable-next-line no-throw-literal
                 throw "HDR Bad header format, wrong scan line width";
             }
             // read each of the four channels for the scanline into the buffer
@@ -5687,73 +5724,60 @@ var MaterialLoader = /*#__PURE__*/ function(Loader1) {
             _this.request(item.url, _extends({}, item, {
                 type: "json"
             })).then(function(materialSchema) {
+                var _loop = function(key) {
+                    var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
+                    switch(type){
+                        case "Vector2":
+                            materialShaderData.setVector2(key, new engineMath.Vector2(value.x, value.y));
+                            break;
+                        case "Vector3":
+                            materialShaderData.setVector3(key, new engineMath.Vector3(value.x, value.y, value.z));
+                            break;
+                        case "Vector4":
+                            materialShaderData.setVector4(key, new engineMath.Vector4(value.x, value.y, value.z, value.w));
+                            break;
+                        case "Color":
+                            materialShaderData.setColor(key, new engineMath.Color(value.r, value.g, value.b, value.a));
+                            break;
+                        case "Float":
+                            materialShaderData.setFloat(key, value);
+                            break;
+                        case "Texture":
+                            texturePromises.push(// @ts-ignore
+                            resourceManager.getResourceByRef(value).then(function(texture) {
+                                materialShaderData.setTexture(key, texture);
+                            }));
+                            break;
+                        case "Boolean":
+                            materialShaderData.setInt(key, value ? 1 : 0);
+                            break;
+                        case "Integer":
+                            materialShaderData.setInt(key, Number(value));
+                            break;
+                    }
+                };
                 var engine = resourceManager.engine;
-                var shaderRef = materialSchema.shaderRef, shader = materialSchema.shader;
-                if (shaderRef) {
-                    resolve(resourceManager// @ts-ignore
-                    .getResourceByRef(shaderRef).then(function(shaderObject) {
-                        return _this.getMaterialByShader(materialSchema, shaderObject, engine);
-                    }));
-                } else {
-                    // compatible with 1.2-pre version material schema
-                    var shaderObject = engineCore.Shader.find(shader);
-                    resolve(_this.getMaterialByShader(materialSchema, shaderObject, engine));
+                var name = materialSchema.name, shader = materialSchema.shader, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
+                var material = new engineCore.Material(engine, engineCore.Shader.find(shader));
+                material.name = name;
+                var texturePromises = new Array();
+                var materialShaderData = material.shaderData;
+                for(var key in shaderData)_loop(key);
+                for(var i = 0, length = macros.length; i < length; i++){
+                    var _macros_i = macros[i], name1 = _macros_i.name, value = _macros_i.value;
+                    if (value == undefined) {
+                        materialShaderData.enableMacro(name1);
+                    } else {
+                        materialShaderData.enableMacro(name1, value);
+                    }
                 }
+                parseProperty(material, "renderState", renderState);
+                return Promise.all(texturePromises).then(function() {
+                    resolve(material);
+                });
             }).catch(reject);
         });
     };
-    _proto.getMaterialByShader = function getMaterialByShader(materialSchema, shader, engine) {
-        var _loop = function(key) {
-            var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
-            switch(type){
-                case "Vector2":
-                    materialShaderData.setVector2(key, new engineMath.Vector2(value.x, value.y));
-                    break;
-                case "Vector3":
-                    materialShaderData.setVector3(key, new engineMath.Vector3(value.x, value.y, value.z));
-                    break;
-                case "Vector4":
-                    materialShaderData.setVector4(key, new engineMath.Vector4(value.x, value.y, value.z, value.w));
-                    break;
-                case "Color":
-                    materialShaderData.setColor(key, new engineMath.Color(value.r, value.g, value.b, value.a));
-                    break;
-                case "Float":
-                    materialShaderData.setFloat(key, value);
-                    break;
-                case "Texture":
-                    texturePromises.push(// @ts-ignore
-                    engine.resourceManager.getResourceByRef(value).then(function(texture) {
-                        materialShaderData.setTexture(key, texture);
-                    }));
-                    break;
-                case "Boolean":
-                    materialShaderData.setInt(key, value ? 1 : 0);
-                    break;
-                case "Integer":
-                    materialShaderData.setInt(key, Number(value));
-                    break;
-            }
-        };
-        var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
-        var material = new engineCore.Material(engine, shader);
-        material.name = name;
-        var texturePromises = new Array();
-        var materialShaderData = material.shaderData;
-        for(var key in shaderData)_loop(key);
-        for(var i = 0, length = macros.length; i < length; i++){
-            var _macros_i = macros[i], name1 = _macros_i.name, value = _macros_i.value;
-            if (value == undefined) {
-                materialShaderData.enableMacro(name1);
-            } else {
-                materialShaderData.enableMacro(name1, value);
-            }
-        }
-        parseProperty(material, "renderState", renderState);
-        return Promise.all(texturePromises).then(function() {
-            return material;
-        });
-    };
     return MaterialLoader;
 }(engineCore.Loader);
 MaterialLoader = __decorate([
@@ -6203,106 +6227,6 @@ TextureCubeLoader = __decorate([
     ])
 ], TextureCubeLoader);
 
-var ShaderLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(ShaderLoader, Loader1);
-    function ShaderLoader() {
-        return Loader1.apply(this, arguments);
-    }
-    var _proto = ShaderLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _this = this;
-        return this.request(item.url, _extends({}, item, {
-            type: "text"
-        })).then(function(code) {
-            var builtinShader = _this.getBuiltinShader(code);
-            if (builtinShader) {
-                return engineCore.Shader.find(builtinShader);
-            }
-            var matches = code.matchAll(/^[ \t]*#include +"([^$\\"]+)"/gm);
-            return Promise.all(Array.from(matches).map(function(m) {
-                var path = m[1];
-                if (path) {
-                    // @ts-ignore
-                    var resource = resourceManager._virtualPathMap[path];
-                    if (!resource) return;
-                    return resourceManager.load({
-                        type: engineCore.AssetType.ShaderChunk,
-                        url: resource,
-                        params: {
-                            includeKey: path
-                        }
-                    });
-                }
-            })).then(function() {
-                return engineCore.Shader.create(code);
-            });
-        });
-    };
-    _proto.getBuiltinShader = function getBuiltinShader(code) {
-        var match = code.match(/^\s*\/\/\s*@builtin\s+(\w+)/);
-        if (match && match[1]) return match[1];
-    };
-    return ShaderLoader;
-}(engineCore.Loader);
-ShaderLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Shader, [
-        "gs",
-        "gsl"
-    ], false)
-], ShaderLoader);
-
-var ShaderChunkLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(ShaderChunkLoader, Loader1);
-    function ShaderChunkLoader() {
-        return Loader1.apply(this, arguments);
-    }
-    var _proto = ShaderChunkLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        return this.request(item.url, _extends({}, item, {
-            type: "text"
-        })).then(/*#__PURE__*/ _async_to_generator(function(code) {
-            var includeKey, matches;
-            return __generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        includeKey = item.params.includeKey;
-                        engineCore.ShaderFactory.registerInclude(includeKey, code);
-                        matches = code.matchAll(/^[ \t]*#include +"([^$\\"]+)"/gm);
-                        return [
-                            4,
-                            Promise.all(Array.from(matches).map(function(m) {
-                                var path = m[1];
-                                if (path) {
-                                    // @ts-ignore
-                                    var resource = resourceManager._virtualPathMap[path];
-                                    if (!resource) return;
-                                    return resourceManager.load({
-                                        type: engineCore.AssetType.ShaderChunk,
-                                        url: resource,
-                                        params: {
-                                            includeKey: path
-                                        }
-                                    });
-                                }
-                            }))
-                        ];
-                    case 1:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        }));
-    };
-    return ShaderChunkLoader;
-}(engineCore.Loader);
-ShaderChunkLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.ShaderChunk, [
-        "glsl"
-    ], false)
-], ShaderChunkLoader);
-
 var SceneLoader = /*#__PURE__*/ function(Loader1) {
     _inherits(SceneLoader, Loader1);
     function SceneLoader() {