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

package/dist/module.js

@@ -4936,7 +4936,8 @@ __decorate([
             }
             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) {
@@ -4975,7 +4976,8 @@ __decorate([
             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);
@@ -16081,8 +16083,6 @@ var TextRenderData = /*#__PURE__*/ function(RenderData1) {
     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";
@@ -22124,9 +22124,10 @@ __decorate([
    */ _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);
         }
@@ -26948,13 +26949,71 @@ var AnimatorLayerBlendingMode;
 }();
 
 /**
- * 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;
+ * 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 = /*#__PURE__*/ function() {
+    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(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.
  */ var WrapMode;
@@ -27030,6 +27089,16 @@ var AnimatorLayerBlendingMode;
     this.eventHandlers = [];
 };
 
+var AnimatorConditionMode;
+(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";
+})(AnimatorConditionMode || (AnimatorConditionMode = {}));
+
 /**
  * The controller of the animation system.
  */ var Animator = /*#__PURE__*/ function(Component1) {
@@ -27082,26 +27151,29 @@ var AnimatorLayerBlendingMode;
         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);
         }
     };
@@ -27128,7 +27200,7 @@ var AnimatorLayerBlendingMode;
             return;
         }
         if ((_this__controllerUpdateFlag = this._controllerUpdateFlag) == null ? void 0 : _this__controllerUpdateFlag.flag) {
-            this._checkAutoPlay();
+            this._checkEntryState();
             return;
         }
         this._updateMark++;
@@ -27156,9 +27228,31 @@ var AnimatorLayerBlendingMode;
         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(Renderer, this._controlledRenderers);
     };
     /**
@@ -27232,20 +27326,19 @@ var AnimatorLayerBlendingMode;
             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;
@@ -27350,7 +27443,8 @@ var AnimatorLayerBlendingMode;
         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 === AnimatorLayerBlendingMode.Additive;
@@ -27375,6 +27469,7 @@ var AnimatorLayerBlendingMode;
         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);
@@ -27407,10 +27502,10 @@ var AnimatorLayerBlendingMode;
         } 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);
             }
         }
     };
@@ -27556,43 +27651,61 @@ var AnimatorLayerBlendingMode;
             }
         }
     };
-    _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--){
@@ -27601,14 +27714,76 @@ var AnimatorLayerBlendingMode;
             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 AnimatorConditionMode.Equals:
+                    if (parameter.value === threshold) {
+                        pass = true;
+                    }
+                    break;
+                case AnimatorConditionMode.Greater:
+                    if (parameter.value > threshold) {
+                        pass = true;
+                    }
+                    break;
+                case AnimatorConditionMode.Less:
+                    if (parameter.value < threshold) {
+                        pass = true;
+                    }
+                    break;
+                case AnimatorConditionMode.NotEquals:
+                    if (parameter.value !== threshold) {
+                        pass = true;
+                    }
+                    break;
+                case AnimatorConditionMode.If:
+                    if (parameter.value === true) {
+                        pass = true;
+                    }
+                    break;
+                case 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;
         }
@@ -27719,13 +27894,24 @@ var AnimatorLayerBlendingMode;
             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);
             }
         }
     };
@@ -27751,6 +27937,22 @@ var AnimatorLayerBlendingMode;
                     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;
@@ -27780,15 +27982,46 @@ __decorate([
     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() {
     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.
@@ -27834,6 +28067,14 @@ __decorate([
    */ function get() {
                 return this._layers;
             }
+        },
+        {
+            key: "parameters",
+            get: /**
+   * The parameters in the controller.
+   */ function get() {
+                return this._parameters;
+            }
         }
     ]);
     return AnimatorController;
@@ -27895,16 +28136,22 @@ __decorate([
         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 (_instanceof(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;
@@ -27916,6 +28163,10 @@ __decorate([
             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.
@@ -27923,6 +28174,7 @@ __decorate([
    */ _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.
@@ -27977,6 +28229,21 @@ __decorate([
    */ _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(AnimatorState, [
         {
             key: "transitions",
@@ -28007,10 +28274,26 @@ __decorate([
                 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;
             },
@@ -28021,7 +28304,7 @@ __decorate([
         {
             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;
             },
@@ -28038,6 +28321,8 @@ __decorate([
  */ var AnimatorStateMachine = /*#__PURE__*/ function() {
     function AnimatorStateMachine() {
         /** The list of states. */ this.states = [];
+        /** @internal */ this._entryTransitions = [];
+        /** @internal */ this._anyStateTransitions = [];
         /** @internal */ this._statesMap = {};
     }
     var _proto = AnimatorStateMachine.prototype;
@@ -28086,19 +28371,63 @@ __decorate([
         }
         return name;
     };
+    _proto.addEntryStateTransition = function addEntryStateTransition(transitionOrAnimatorState) {
+        var transition;
+        if (_instanceof(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 (_instanceof(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(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;
 }();
 
-var AnimatorConditionMode;
-(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";
-})(AnimatorConditionMode || (AnimatorConditionMode = {}));
-
 /**
  * Keyframe.
  * @typeParam V - Type of Keyframe value