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

package/dist/browser.js

@@ -9794,7 +9794,8 @@
                 }
                 var shaderInfo = Shader._shaderLab.parseShader(nameOrShaderSource);
                 if (shaderMap[shaderInfo.name]) {
-                    throw 'Shader named "' + shaderInfo.name + '" already exists.';
+                    console.error('Shader named "' + shaderInfo.name + '" already exists.');
+                    return;
                 }
                 var subShaderList = shaderInfo.subShaders.map(function(subShaderInfo) {
                     var passList = subShaderInfo.passes.map(function(passInfo) {
@@ -9833,7 +9834,8 @@
                 return shader;
             } else {
                 if (shaderMap[nameOrShaderSource]) {
-                    throw 'Shader named "' + nameOrShaderSource + '" already exists.';
+                    console.error('Shader named "' + nameOrShaderSource + '" already exists.');
+                    return;
                 }
                 if (typeof vertexSourceOrShaderPassesOrSubShaders === "string") {
                     var shaderPass = new ShaderPass(vertexSourceOrShaderPassesOrSubShaders, fragmentSource);
@@ -20852,8 +20854,6 @@
         AssetType[/** 2D Texture. */ "Texture2D"] = "Texture2D";
         AssetType[/** Cube Texture. */ "TextureCube"] = "TextureCube";
         AssetType[/** Material. */ "Material"] = "Material";
-        AssetType[/** Shader */ "Shader"] = "Shader";
-        AssetType[/** Shader Chunk */ "ShaderChunk"] = "ShaderChunk";
         AssetType[/** Mesh. */ "Mesh"] = "Mesh";
         AssetType[/** AnimationClip. */ "AnimationClip"] = "AnimationClip";
         AssetType[/** AnimatorController. */ "AnimatorController"] = "AnimatorController";
@@ -26804,9 +26804,10 @@
        */ _proto._updateShaderData = function _updateShaderData(shaderData) {
             var _this = this, spotLight = _this._spotLights, pointLight = _this._pointLights, directLight = _this._directLights;
             var _this1 = this, spotData = _this1._spotData, pointData = _this1._pointData, directData = _this1._directData;
-            var spotLightCount = spotLight.length;
-            var pointLightCount = pointLight.length;
-            var directLightCount = directLight.length;
+            var maxLight = LightManager._maxLight;
+            var spotLightCount = Math.min(spotLight.length, maxLight);
+            var pointLightCount = Math.min(pointLight.length, maxLight);
+            var directLightCount = Math.min(directLight.length, maxLight);
             for(var i = 0; i < spotLightCount; i++){
                 spotLight.get(i)._appendData(i, spotData);
             }
@@ -31574,13 +31575,69 @@
         _proto.dispose = function dispose() {};
         return AnimationEventHandler;
     }();
+    /**
+     * Condition that is used to determine if a transition must be taken.
+     */ var AnimatorCondition = function AnimatorCondition() {};
     /**
      * Transitions define when and how the state machine switch from on state to another. AnimatorTransition always originate from a StateMachine or a StateMachine entry.
-     */ var AnimatorStateTransition = function AnimatorStateTransition() {
-        /** The duration of the transition. This is represented in normalized time. */ this.duration = 0;
-        /** The time at which the destination state will start. This is represented in normalized time. */ this.offset = 0;
-        /** ExitTime represents the exact time at which the transition can take effect. This is represented in normalized time. */ this.exitTime = 1;
-    };
+     */ var AnimatorStateTransition = /*#__PURE__*/ function() {
+        var AnimatorStateTransition = function AnimatorStateTransition() {
+            /** The duration of the transition. This is represented in normalized time. */ this.duration = 0;
+            /** The time at which the destination state will start. This is represented in normalized time. */ this.offset = 0;
+            /** ExitTime represents the exact time at which the transition can take effect. This is represented in normalized time. */ this.exitTime = 1;
+            /** Mutes the transition. The transition will never occur. */ this.mute = false;
+            /** Is the transition destination the exit of the current state machine. */ this.isExit = false;
+            this._conditions = [];
+            this._solo = false;
+        };
+        var _proto = AnimatorStateTransition.prototype;
+        _proto.addCondition = function addCondition(param, parameter, threshold) {
+            if (typeof param === "object") {
+                this._conditions.push(param);
+                return param;
+            } else {
+                var condition = new AnimatorCondition();
+                condition.mode = param;
+                condition.parameter = parameter;
+                condition.threshold = threshold;
+                this._conditions.push(condition);
+                return condition;
+            }
+        };
+        /**
+       * Remove a condition from the transition.
+       * @param condition - The condition to remove
+       */ _proto.removeCondition = function removeCondition(condition) {
+            var index = this._conditions.indexOf(condition);
+            index !== -1 && this._conditions.splice(index, 1);
+        };
+        _create_class$2(AnimatorStateTransition, [
+            {
+                key: "solo",
+                get: /** Mutes all other transitions in the source state. */ function get() {
+                    return this._solo;
+                },
+                set: function set(value) {
+                    if (this._solo === value) return;
+                    this._solo = value;
+                    if (value) {
+                        this._srcState && this._srcState._updateSoloTransition(true);
+                    } else {
+                        this._srcState && this._srcState._updateSoloTransition();
+                    }
+                }
+            },
+            {
+                key: "conditions",
+                get: /**
+       * The conditions in the transition.
+       */ function get() {
+                    return this._conditions;
+                }
+            }
+        ]);
+        return AnimatorStateTransition;
+    }();
     /**
      * Animation wrap mode.
      */ exports.WrapMode = void 0;
@@ -31652,6 +31709,15 @@
         this.curveLayerOwner = [];
         this.eventHandlers = [];
     };
+    exports.AnimatorConditionMode = void 0;
+    (function(AnimatorConditionMode) {
+        AnimatorConditionMode[AnimatorConditionMode["If"] = 0] = "If";
+        AnimatorConditionMode[AnimatorConditionMode["IfNot"] = 1] = "IfNot";
+        AnimatorConditionMode[AnimatorConditionMode["Greater"] = 2] = "Greater";
+        AnimatorConditionMode[AnimatorConditionMode["Less"] = 3] = "Less";
+        AnimatorConditionMode[AnimatorConditionMode["Equals"] = 4] = "Equals";
+        AnimatorConditionMode[AnimatorConditionMode["NotEquals"] = 5] = "NotEquals";
+    })(exports.AnimatorConditionMode || (exports.AnimatorConditionMode = {}));
     /**
      * The controller of the animation system.
      */ var Animator = /*#__PURE__*/ function(Component1) {
@@ -31704,26 +31770,29 @@
             animatorLayerData.srcPlayData.reset(state, animatorStateData, state._getDuration() * normalizedTimeOffset);
             this.update(0);
         };
-        /**
-       * Create a cross fade from the current state to another state.
-       * @param stateName - The state name
-       * @param normalizedTransitionDuration - The duration of the transition (normalized)
-       * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
-       * @param normalizedTimeOffset - The time offset between 0 and 1(default 0)
-       */ _proto.crossFade = function crossFade(stateName, normalizedTransitionDuration, layerIndex, normalizedTimeOffset) {
+        _proto.crossFade = function crossFade(stateNameOrTransition, normalizedTransitionDurationOrLayerIndex, layerIndex, normalizedTimeOffset) {
             if (layerIndex === void 0) layerIndex = -1;
             if (normalizedTimeOffset === void 0) normalizedTimeOffset = 0;
-            var _this__controllerUpdateFlag;
-            if ((_this__controllerUpdateFlag = this._controllerUpdateFlag) == null ? void 0 : _this__controllerUpdateFlag.flag) {
-                this._reset();
+            var state;
+            var playLayerIndex;
+            var normalizedTransitionDuration;
+            var transition;
+            if (typeof stateNameOrTransition === "string") {
+                var info = this._getAnimatorStateInfo(stateNameOrTransition, layerIndex);
+                state = info.state;
+                playLayerIndex = info.layerIndex;
+                normalizedTransitionDuration = normalizedTransitionDurationOrLayerIndex;
+                var manuallyTransition = this._getAnimatorLayerData(playLayerIndex).manuallyTransition;
+                manuallyTransition.duration = normalizedTransitionDuration;
+                manuallyTransition.offset = normalizedTimeOffset;
+                manuallyTransition.destinationState = state;
+                transition = manuallyTransition;
+            } else {
+                state = stateNameOrTransition.destinationState;
+                playLayerIndex = normalizedTransitionDurationOrLayerIndex != null ? normalizedTransitionDurationOrLayerIndex : this._getAnimatorStateInfo(state.name, playLayerIndex).layerIndex;
+                transition = stateNameOrTransition;
             }
-            this._playFrameCount = this.engine.time.frameCount;
-            var _this__getAnimatorStateInfo = this._getAnimatorStateInfo(stateName, layerIndex), state = _this__getAnimatorStateInfo.state, playLayerIndex = _this__getAnimatorStateInfo.layerIndex;
-            var manuallyTransition = this._getAnimatorLayerData(playLayerIndex).manuallyTransition;
-            manuallyTransition.duration = normalizedTransitionDuration;
-            manuallyTransition.offset = normalizedTimeOffset;
-            manuallyTransition.destinationState = state;
-            if (this._crossFadeByTransition(manuallyTransition, playLayerIndex)) {
+            if (this._crossFadeByTransition(transition, playLayerIndex)) {
                 this.update(0);
             }
         };
@@ -31750,7 +31819,7 @@
                 return;
             }
             if ((_this__controllerUpdateFlag = this._controllerUpdateFlag) == null ? void 0 : _this__controllerUpdateFlag.flag) {
-                this._checkAutoPlay();
+                this._checkEntryState();
                 return;
             }
             this._updateMark++;
@@ -31778,9 +31847,31 @@
             return this._getAnimatorStateInfo(stateName, layerIndex).state;
         };
         /**
+       * Get the layer by name.
+       * @param name - The layer's name.
+       */ _proto.findLayerByName = function findLayerByName(name1) {
+            return this._animatorController._layersMap[name1];
+        };
+        /**
+       * Get the parameter by name.
+       * @param name - The name of the parameter
+       */ _proto.getParameter = function getParameter(name1) {
+            return this._animatorController._parametersMap[name1] || null;
+        };
+        /**
+       * Set the value of the given parameter.
+       * @param name - The name of the parameter
+       */ _proto.setParameter = function setParameter(name1, value) {
+            var controller = this._animatorController;
+            var parameter = controller._parametersMap[name1];
+            if (parameter) {
+                parameter.value = value;
+            }
+        };
+        /**
        * @internal
        */ _proto._onEnable = function _onEnable() {
-            this.animatorController && this._checkAutoPlay();
+            this.animatorController && this._checkEntryState();
             this._entity.getComponentsIncludeChildren(exports.Renderer, this._controlledRenderers);
         };
         /**
@@ -31854,20 +31945,19 @@
                 var relativePath = curve.relativePath;
                 var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
                 if (targetEntity) {
-                    var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _propertyPath;
-                    var propertyPath = "" + curve.typeIndex + "." + curve.property;
+                    var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
                     var component = curve.typeIndex > 0 ? targetEntity.getComponents(curve.type, AnimationCurveOwner._components)[curve.typeIndex] : targetEntity.getComponent(curve.type);
                     if (!component) {
                         continue;
                     }
                     var property = curve.property;
-                    var instanceId = targetEntity.instanceId;
+                    var instanceId = component.instanceId;
                     // Get owner
                     var propertyOwners = (_curveOwnerPool = curveOwnerPool)[_instanceId = instanceId] || (_curveOwnerPool[_instanceId] = Object.create(null));
                     var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity, component));
                     // Get layer owner
                     var layerPropertyOwners = (_layerCurveOwnerPool = layerCurveOwnerPool)[_instanceId1 = instanceId] || (_layerCurveOwnerPool[_instanceId1] = Object.create(null));
-                    var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_propertyPath = propertyPath] || (_layerPropertyOwners[_propertyPath] = curve._createCurveLayerOwner(owner));
+                    var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property1 = property] || (_layerPropertyOwners[_property1] = curve._createCurveLayerOwner(owner));
                     if (mask && mask.pathMasks.length) {
                         var _mask_getPathMask;
                         var _mask_getPathMask_active;
@@ -31972,7 +32062,8 @@
             return animatorLayerData;
         };
         _proto._updateLayer = function _updateLayer(layerIndex, firstLayer, deltaTime, aniUpdate) {
-            var _this__animatorController_layers_layerIndex = this._animatorController.layers[layerIndex], blendingMode = _this__animatorController_layers_layerIndex.blendingMode, weight = _this__animatorController_layers_layerIndex.weight;
+            var _this__animatorController_layers_layerIndex = this._animatorController.layers[layerIndex], blendingMode = _this__animatorController_layers_layerIndex.blendingMode, weight = _this__animatorController_layers_layerIndex.weight, stateMachine = _this__animatorController_layers_layerIndex.stateMachine;
+            if (!stateMachine) return;
             var layerData = this._animatorLayersData[layerIndex];
             var srcPlayData = layerData.srcPlayData, destPlayData = layerData.destPlayData;
             var additive = blendingMode === exports.AnimatorLayerBlendingMode.Additive;
@@ -31997,6 +32088,7 @@
             var state = playData.state, lastPlayState = playData.playState, lastClipTime = playData.clipTime;
             var transitions = state.transitions;
             var _state_clip = state.clip, curveBindings = _state_clip._curveBindings;
+            var anyStateTransitions = this.layers[layerIndex].stateMachine.anyStateTransitions;
             var speed = state.speed * this.speed;
             playData.frameTime += speed * delta;
             playData.update(speed < 0);
@@ -32029,10 +32121,10 @@
             } else {
                 this._callAnimatorScriptOnUpdate(state, layerIndex);
             }
-            if (transitions.length) {
+            if (transitions.length || anyStateTransitions.length) {
                 var layerState = layerData.layerState;
                 if (layerState !== LayerState.CrossFading && layerState !== LayerState.FixedCrossFading) {
-                    this._checkTransition(playData, transitions, layerIndex, lastClipTime, clipTime);
+                    this._checkTransition(playData, transitions, anyStateTransitions, layerIndex, lastClipTime, clipTime);
                 }
             }
         };
@@ -32178,43 +32270,61 @@
                 }
             }
         };
-        _proto._checkTransition = function _checkTransition(playState, transitions, layerIndex, lastClipTime, clipTime) {
+        _proto._checkTransition = function _checkTransition(playState, transitions, anyStateTransitions, layerIndex, lastClipTime, clipTime) {
             var state = playState.state;
             var clipDuration = state.clip.length;
+            var targetTransition = null;
             if (this.speed * state.speed >= 0) {
                 if (clipTime < lastClipTime) {
-                    this._checkSubTransition(playState, transitions, layerIndex, lastClipTime, state.clipEndTime * clipDuration);
-                    playState.currentTransitionIndex = 0;
-                    this._checkSubTransition(playState, transitions, layerIndex, state.clipStartTime * clipDuration, clipTime);
+                    targetTransition = this._checkSubTransition(playState, transitions, layerIndex, lastClipTime, state.clipEndTime * clipDuration);
+                    if (!targetTransition) {
+                        playState.currentTransitionIndex = 0;
+                        targetTransition = this._checkSubTransition(playState, transitions, layerIndex, state.clipStartTime * clipDuration, clipTime);
+                    }
                 } else {
-                    this._checkSubTransition(playState, transitions, layerIndex, lastClipTime, clipTime);
+                    targetTransition = this._checkSubTransition(playState, transitions, layerIndex, lastClipTime, clipTime);
                 }
             } else {
                 if (clipTime > lastClipTime) {
-                    this._checkBackwardsSubTransition(playState, transitions, layerIndex, lastClipTime, state.clipStartTime * clipDuration);
-                    playState.currentTransitionIndex = transitions.length - 1;
-                    this._checkBackwardsSubTransition(playState, transitions, layerIndex, clipTime, state.clipEndTime * clipDuration);
+                    targetTransition = this._checkBackwardsSubTransition(playState, transitions, layerIndex, lastClipTime, state.clipStartTime * clipDuration);
+                    if (!targetTransition) {
+                        playState.currentTransitionIndex = transitions.length - 1;
+                        targetTransition = this._checkBackwardsSubTransition(playState, transitions, layerIndex, clipTime, state.clipEndTime * clipDuration);
+                    }
                 } else {
-                    this._checkBackwardsSubTransition(playState, transitions, layerIndex, lastClipTime, clipTime);
+                    targetTransition = this._checkBackwardsSubTransition(playState, transitions, layerIndex, lastClipTime, clipTime);
+                }
+            }
+            if (!targetTransition) {
+                for(var i = 0, n = anyStateTransitions.length; i < n; ++i){
+                    var transition = anyStateTransitions[i];
+                    if (this._checkConditions(state, transition)) {
+                        this._crossFadeByTransition(transition, layerIndex);
+                        break;
+                    }
                 }
             }
         };
         _proto._checkSubTransition = function _checkSubTransition(playState, transitions, layerIndex, lastClipTime, curClipTime) {
+            var state = playState.state;
             var transitionIndex = playState.currentTransitionIndex;
-            var duration = playState.state._getDuration();
+            var duration = state._getDuration();
             for(var n = transitions.length; transitionIndex < n; transitionIndex++){
                 var transition = transitions[transitionIndex];
                 var exitTime = transition.exitTime * duration;
                 if (exitTime > curClipTime) {
                     break;
                 }
-                if (exitTime >= lastClipTime) {
-                    this._crossFadeByTransition(transition, layerIndex);
+                if (exitTime >= lastClipTime && this._checkConditions(state, transition)) {
                     playState.currentTransitionIndex = Math.min(transitionIndex + 1, n - 1);
+                    this._applyTransition(transition, layerIndex);
+                    return transition;
                 }
             }
+            return null;
         };
         _proto._checkBackwardsSubTransition = function _checkBackwardsSubTransition(playState, transitions, layerIndex, lastClipTime, curClipTime) {
+            var state = playState.state;
             var transitionIndex = playState.currentTransitionIndex;
             var duration = playState.state._getDuration();
             for(; transitionIndex >= 0; transitionIndex--){
@@ -32223,14 +32333,76 @@
                 if (exitTime < curClipTime) {
                     break;
                 }
-                if (exitTime <= lastClipTime) {
-                    this._crossFadeByTransition(transition, layerIndex);
+                if (exitTime <= lastClipTime && this._checkConditions(state, transition)) {
                     playState.currentTransitionIndex = Math.max(transitionIndex - 1, 0);
+                    this._applyTransition(transition, layerIndex);
+                    return transition;
                 }
             }
+            return null;
+        };
+        _proto._applyTransition = function _applyTransition(transition, layerIndex) {
+            if (transition.isExit) {
+                this._checkEntryState();
+                return;
+            }
+            this._crossFadeByTransition(transition, layerIndex);
+        };
+        _proto._checkConditions = function _checkConditions(state, transition) {
+            var mute = transition.mute, conditions = transition.conditions, solo = transition.solo;
+            if (mute) return false;
+            if (state && state._hasSoloTransition && !solo) return false;
+            var allPass = true;
+            for(var i = 0, n = conditions.length; i < n; ++i){
+                var pass = false;
+                var _conditions_i = conditions[i], mode = _conditions_i.mode, name1 = _conditions_i.parameter, threshold = _conditions_i.threshold;
+                var parameter = this.getParameter(name1);
+                switch(mode){
+                    case exports.AnimatorConditionMode.Equals:
+                        if (parameter.value === threshold) {
+                            pass = true;
+                        }
+                        break;
+                    case exports.AnimatorConditionMode.Greater:
+                        if (parameter.value > threshold) {
+                            pass = true;
+                        }
+                        break;
+                    case exports.AnimatorConditionMode.Less:
+                        if (parameter.value < threshold) {
+                            pass = true;
+                        }
+                        break;
+                    case exports.AnimatorConditionMode.NotEquals:
+                        if (parameter.value !== threshold) {
+                            pass = true;
+                        }
+                        break;
+                    case exports.AnimatorConditionMode.If:
+                        if (parameter.value === true) {
+                            pass = true;
+                        }
+                        break;
+                    case exports.AnimatorConditionMode.IfNot:
+                        if (parameter.value === false) {
+                            pass = true;
+                        }
+                        break;
+                }
+                if (!pass) {
+                    allPass = false;
+                    break;
+                }
+            }
+            return allPass;
         };
         _proto._crossFadeByTransition = function _crossFadeByTransition(transition, layerIndex) {
+            var _this__controllerUpdateFlag;
             var crossState = transition.destinationState;
+            if ((_this__controllerUpdateFlag = this._controllerUpdateFlag) == null ? void 0 : _this__controllerUpdateFlag.flag) {
+                this._reset();
+            }
+            this._playFrameCount = this.engine.time.frameCount;
             if (!crossState) {
                 return false;
             }
@@ -32341,13 +32513,24 @@
                 scripts[i].onStateExit(this, state, layerIndex);
             }
         };
-        _proto._checkAutoPlay = function _checkAutoPlay() {
+        _proto._checkEntryState = function _checkEntryState() {
             var layers = this._animatorController.layers;
             for(var i = 0, n = layers.length; i < n; ++i){
-                var _stateMachine;
                 var stateMachine = layers[i].stateMachine;
-                if ((_stateMachine = stateMachine) == null ? void 0 : _stateMachine.defaultState) {
-                    this.play(stateMachine.defaultState.name, i);
+                if (!stateMachine) continue;
+                var entryTransitions = stateMachine._entryTransitions;
+                var length = entryTransitions.length;
+                if (length) {
+                    for(var j = 0, m = length; j < m; j++){
+                        var transition = entryTransitions[j];
+                        if (this._checkConditions(null, transition)) {
+                            this.crossFade(transition, i);
+                            break;
+                        }
+                    }
+                } else {
+                    var defaultState = stateMachine.defaultState;
+                    defaultState && this.play(defaultState.name, i);
                 }
             }
         };
@@ -32373,6 +32556,22 @@
                         this._animatorController = animatorController;
                     }
                 }
+            },
+            {
+                key: "layers",
+                get: /**
+       * The layers in the animator's controller.
+       */ function get() {
+                    return this._animatorController._layers;
+                }
+            },
+            {
+                key: "parameters",
+                get: /**
+       * The parameters in the animator's controller.
+       */ function get() {
+                    return this._animatorController._parameters;
+                }
             }
         ]);
         return Animator;
@@ -32401,15 +32600,44 @@
     __decorate$1([
         ignoreClone
     ], Animator.prototype, "_controlledRenderers", void 0);
+    /**
+     * Used to communicate between scripting and the controller, parameters can be set in scripting and used by the controller.
+     */ var AnimatorControllerParameter = function AnimatorControllerParameter() {};
     /**
      * Store the data for Animator playback.
      */ var AnimatorController = /*#__PURE__*/ function() {
         var AnimatorController = function AnimatorController() {
+            /** @internal */ this._parameters = [];
+            /** @internal */ this._parametersMap = {};
+            /** @internal */ this._layers = [];
+            /** @internal */ this._layersMap = {};
             this._updateFlagManager = new UpdateFlagManager();
-            this._layers = [];
-            this._layersMap = {};
         };
         var _proto = AnimatorController.prototype;
+        _proto.addParameter = function addParameter(param, defaultValue) {
+            if (typeof param === "string") {
+                var parameter = new AnimatorControllerParameter();
+                parameter.name = param;
+                parameter.value = defaultValue;
+                this._parametersMap[param] = parameter;
+                this._parameters.push(parameter);
+                return parameter;
+            } else {
+                this._parametersMap[param.name] = param;
+                this._parameters.push(param);
+                return param;
+            }
+        };
+        /**
+       * Remove a parameter from the controller.
+       * @param parameter - The parameter
+       */ _proto.removeParameter = function removeParameter(parameter) {
+            var index = this._parameters.indexOf(parameter);
+            if (index !== -1) {
+                this._parameters.splice(index, 1);
+                delete this._parametersMap[parameter.name];
+            }
+        };
         /**
        * Get the layer by name.
        * @param name - The layer's name.
@@ -32455,6 +32683,14 @@
        */ function get() {
                     return this._layers;
                 }
+            },
+            {
+                key: "parameters",
+                get: /**
+       * The parameters in the controller.
+       */ function get() {
+                    return this._parameters;
+                }
             }
         ]);
         return AnimatorController;
@@ -32513,16 +32749,22 @@
             this./** @internal */ _onStateUpdateScripts = [];
             this./** @internal */ _onStateExitScripts = [];
             this./** @internal */ _updateFlagManager = new UpdateFlagManager();
+            this./** @internal */ _hasSoloTransition = false;
             this._clipStartTime = 0;
             this._clipEndTime = 1;
             this._transitions = [];
             this._onClipChanged = this._onClipChanged.bind(this);
         };
         var _proto = AnimatorState.prototype;
-        /**
-       * Add an outgoing transition to the destination state.
-       * @param transition - The transition
-       */ _proto.addTransition = function addTransition(transition) {
+        _proto.addTransition = function addTransition(transitionOrAnimatorState) {
+            var transition;
+            if (_instanceof1$2(transitionOrAnimatorState, AnimatorState)) {
+                transition = new AnimatorStateTransition();
+                transition.destinationState = transitionOrAnimatorState;
+            } else {
+                transition = transitionOrAnimatorState;
+            }
+            transition._srcState = this;
             var transitions = this._transitions;
             var count = transitions.length;
             var time = transition.exitTime;
@@ -32534,6 +32776,10 @@
                 while(--index >= 0 && time < transitions[index].exitTime);
                 transitions.splice(index + 1, 0, transition);
             }
+            if (transition.solo) {
+                !this._hasSoloTransition && this._updateSoloTransition(true);
+            }
+            return transition;
         };
         /**
        * Remove a transition from the state.
@@ -32541,6 +32787,7 @@
        */ _proto.removeTransition = function removeTransition(transition) {
             var index = this._transitions.indexOf(transition);
             index !== -1 && this._transitions.splice(index, 1);
+            this._updateSoloTransition();
         };
         /**
        * Adds a state machine script class of type T to the AnimatorState.
@@ -32595,6 +32842,21 @@
        */ _proto._onClipChanged = function _onClipChanged() {
             this._updateFlagManager.dispatch();
         };
+        /**
+       * @internal
+       */ _proto._updateSoloTransition = function _updateSoloTransition(hasSolo) {
+            if (hasSolo !== undefined) {
+                this._hasSoloTransition = hasSolo;
+            } else {
+                this._hasSoloTransition = false;
+                for(var i = 0, n = this.transitions.length; i < n; ++i){
+                    if (this.transitions[i].solo) {
+                        this._hasSoloTransition = true;
+                        return;
+                    }
+                }
+            }
+        };
         _create_class$2(AnimatorState, [
             {
                 key: "transitions",
@@ -32625,10 +32887,26 @@
                     clip && clip._updateFlagManager.addListener(this._onClipChanged);
                 }
             },
+            {
+                key: "startTime",
+                get: /**
+       * The start time of this state's clip
+       */ function get() {
+                    return this._clip.length * this._clipStartTime;
+                }
+            },
+            {
+                key: "endTime",
+                get: /**
+       * The end time of this state's clip
+       */ function get() {
+                    return this._clip.length * this._clipEndTime;
+                }
+            },
             {
                 key: "clipStartTime",
                 get: /**
-       * The start time of the clip, the range is 0 to 1, default is 0.
+       * The normalized start time of the clip, the range is 0 to 1, default is 0.
        */ function get() {
                     return this._clipStartTime;
                 },
@@ -32639,7 +32917,7 @@
             {
                 key: "clipEndTime",
                 get: /**
-       * The end time of the clip, the range is 0 to 1, default is 1.
+       * The normalized end time of the clip, the range is 0 to 1, default is 1.
        */ function get() {
                     return this._clipEndTime;
                 },
@@ -32655,6 +32933,8 @@
      */ var AnimatorStateMachine = /*#__PURE__*/ function() {
         var AnimatorStateMachine = function AnimatorStateMachine() {
             /** The list of states. */ this.states = [];
+            /** @internal */ this._entryTransitions = [];
+            /** @internal */ this._anyStateTransitions = [];
             /** @internal */ this._statesMap = {};
         };
         var _proto = AnimatorStateMachine.prototype;
@@ -32703,17 +32983,62 @@
             }
             return name1;
         };
+        _proto.addEntryStateTransition = function addEntryStateTransition(transitionOrAnimatorState) {
+            var transition;
+            if (_instanceof1$2(transitionOrAnimatorState, AnimatorState)) {
+                transition = new AnimatorStateTransition();
+                transition.destinationState = transitionOrAnimatorState;
+            } else {
+                transition = transitionOrAnimatorState;
+            }
+            this._entryTransitions.push(transition);
+            return transition;
+        };
+        /**
+       * Remove an entry transition.
+       * @param transition - The transition
+       */ _proto.removeEntryStateTransition = function removeEntryStateTransition(transition) {
+            var index = this._entryTransitions.indexOf(transition);
+            index !== -1 && this._entryTransitions.splice(index, 1);
+        };
+        _proto.addAnyStateTransition = function addAnyStateTransition(transitionOrAnimatorState) {
+            var transition;
+            if (_instanceof1$2(transitionOrAnimatorState, AnimatorState)) {
+                transition = new AnimatorStateTransition();
+                transition.destinationState = transitionOrAnimatorState;
+            } else {
+                transition = transitionOrAnimatorState;
+            }
+            this._anyStateTransitions.push(transition);
+            return transition;
+        };
+        /**
+       * Remove an any transition.
+       * @param transition - The transition
+       */ _proto.removeAnyStateTransition = function removeAnyStateTransition(transition) {
+            var index = this._anyStateTransitions.indexOf(transition);
+            index !== -1 && this._anyStateTransitions.splice(index, 1);
+        };
+        _create_class$2(AnimatorStateMachine, [
+            {
+                key: "entryTransitions",
+                get: /**
+       * The list of entry transitions in the state machine.
+       */ function get() {
+                    return this._entryTransitions;
+                }
+            },
+            {
+                key: "anyStateTransitions",
+                get: /**
+       * The list of AnyState transitions.
+       */ function get() {
+                    return this._anyStateTransitions;
+                }
+            }
+        ]);
         return AnimatorStateMachine;
     }();
-    exports.AnimatorConditionMode = void 0;
-    (function(AnimatorConditionMode) {
-        AnimatorConditionMode[AnimatorConditionMode["If"] = 0] = "If";
-        AnimatorConditionMode[AnimatorConditionMode["IfNot"] = 1] = "IfNot";
-        AnimatorConditionMode[AnimatorConditionMode["Greater"] = 2] = "Greater";
-        AnimatorConditionMode[AnimatorConditionMode["Less"] = 3] = "Less";
-        AnimatorConditionMode[AnimatorConditionMode["Equals"] = 4] = "Equals";
-        AnimatorConditionMode[AnimatorConditionMode["NotEquals"] = 5] = "NotEquals";
-    })(exports.AnimatorConditionMode || (exports.AnimatorConditionMode = {}));
     /**
      * Keyframe.
      * @typeParam V - Type of Keyframe value
@@ -40214,6 +40539,7 @@
             this.resourceManager = resourceManager;
             this.params = params;
             this.accessorBufferCache = {};
+            this.needAnimatorController = false;
             this._resourceCache = new Map();
             this._progress = {
                 taskDetail: {},
@@ -40241,16 +40567,15 @@
                 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) {
@@ -40260,11 +40585,14 @@
                         }));
                     } 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;
@@ -40273,6 +40601,7 @@
             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),
@@ -40280,11 +40609,14 @@
                     _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(Animator);
+                        animator.animatorController = animatorController;
                     }
                     _this.resourceManager.addContentRestorer(_this.contentRestorer);
                     return glTFResource;
@@ -40303,40 +40635,21 @@
                 _this._setTaskCompleteProgress(++task.loaded, task.total);
             });
         };
-        _proto._createAnimator = function _createAnimator(context, animations) {
-            var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
-            var animator = defaultSceneRoot.addComponent(Animator);
-            var animatorController = new AnimatorController();
-            var layer = new AnimatorControllerLayer("layer");
-            var animatorStateMachine = new 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];
@@ -40384,11 +40697,12 @@
         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();
@@ -43141,6 +43455,47 @@
     exports.GLTFBufferViewParser = __decorate([
         registerGLTFParser(exports.GLTFParserType.BufferView)
     ], exports.GLTFBufferViewParser);
+    exports.GLTFAnimatorControllerParser = /*#__PURE__*/ function(GLTFParser1) {
+        var GLTFAnimatorControllerParser = function GLTFAnimatorControllerParser() {
+            return GLTFParser1.apply(this, arguments);
+        };
+        _inherits(GLTFAnimatorControllerParser, GLTFParser1);
+        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 AnimatorController();
+            var layer = new AnimatorControllerLayer("layer");
+            var animatorStateMachine = new 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) {
@@ -43546,15 +43901,20 @@
             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
@@ -43980,72 +44340,59 @@
                 _this.request(item.url, _extends({}, item, {
                     type: "json"
                 })).then(function(materialSchema) {
+                    var _loop = function _loop(key) {
+                        var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
+                        switch(type){
+                            case "Vector2":
+                                materialShaderData.setVector2(key, new Vector2(value.x, value.y));
+                                break;
+                            case "Vector3":
+                                materialShaderData.setVector3(key, new Vector3(value.x, value.y, value.z));
+                                break;
+                            case "Vector4":
+                                materialShaderData.setVector4(key, new Vector4(value.x, value.y, value.z, value.w));
+                                break;
+                            case "Color":
+                                materialShaderData.setColor(key, new Color(value.r, value.g, value.b, value.a));
+                                break;
+                            case "Float":
+                                materialShaderData.setFloat(key, value);
+                                break;
+                            case "Texture":
+                                texturePromises.push(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 = 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 Material(engine, 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 _loop(key) {
-                var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
-                switch(type){
-                    case "Vector2":
-                        materialShaderData.setVector2(key, new Vector2(value.x, value.y));
-                        break;
-                    case "Vector3":
-                        materialShaderData.setVector3(key, new Vector3(value.x, value.y, value.z));
-                        break;
-                    case "Vector4":
-                        materialShaderData.setVector4(key, new Vector4(value.x, value.y, value.z, value.w));
-                        break;
-                    case "Color":
-                        materialShaderData.setColor(key, new Color(value.r, value.g, value.b, value.a));
-                        break;
-                    case "Float":
-                        materialShaderData.setFloat(key, value);
-                        break;
-                    case "Texture":
-                        texturePromises.push(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 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;
     }(Loader);
     MaterialLoader = __decorate([
@@ -44484,104 +44831,6 @@
             ""
         ])
     ], TextureCubeLoader);
-    var ShaderLoader = /*#__PURE__*/ function(Loader1) {
-        var ShaderLoader = function ShaderLoader() {
-            return Loader1.apply(this, arguments);
-        };
-        _inherits(ShaderLoader, Loader1);
-        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 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: exports.AssetType.ShaderChunk,
-                            url: resource,
-                            params: {
-                                includeKey: path
-                            }
-                        });
-                    }
-                })).then(function() {
-                    return 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;
-    }(Loader);
-    ShaderLoader = __decorate([
-        resourceLoader(exports.AssetType.Shader, [
-            "gs",
-            "gsl"
-        ], false)
-    ], ShaderLoader);
-    var ShaderChunkLoader = /*#__PURE__*/ function(Loader1) {
-        var ShaderChunkLoader = function ShaderChunkLoader() {
-            return Loader1.apply(this, arguments);
-        };
-        _inherits(ShaderChunkLoader, Loader1);
-        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;
-                            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: exports.AssetType.ShaderChunk,
-                                            url: resource,
-                                            params: {
-                                                includeKey: path
-                                            }
-                                        });
-                                    }
-                                }))
-                            ];
-                        case 1:
-                            _state.sent();
-                            return [
-                                2
-                            ];
-                    }
-                });
-            }));
-        };
-        return ShaderChunkLoader;
-    }(Loader);
-    ShaderChunkLoader = __decorate([
-        resourceLoader(exports.AssetType.ShaderChunk, [
-            "glsl"
-        ], false)
-    ], ShaderChunkLoader);
     var SceneLoader = /*#__PURE__*/ function(Loader1) {
         var SceneLoader = function SceneLoader() {
             return Loader1.apply(this, arguments);
@@ -45071,7 +45320,7 @@
     ], KHR_materials_anisotropy);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-shaderlab.2";
+    var version = "0.0.0-experimental-stateMachine.0";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);