private void CreateDriverBehaviorIfNotExists()
{
if (_driver != null)
{
return;
}
_driver = State.AddStateMachineBehaviour <VRCAvatarParameterDriver>();
_driver.parameters = new List <VRC_AvatarParameterDriver.Parameter>();
}
private static void ProcessState(AnimatorState state)
{
if (!ArrayUtility.Find(state.behaviours, x => x is AnimatorRelay))
{
state.AddStateMachineBehaviour <AnimatorRelay> ();
}
}
static void UpdateAnimator(Object obj)
{
string path = AssetDatabase.GetAssetPath(obj);
path = path.Remove(path.IndexOf("_fix"), ("_fix").Length);
AnimatorController srcController = AssetDatabase.LoadAssetAtPath(path, typeof(AnimatorController)) as AnimatorController;
AnimatorController dstController = obj as AnimatorController;
AnimatorStateMachine srcMachine = GetAnimatorStateMachine(srcController.layers[0].stateMachine, "attack");
AnimatorStateMachine dstMachine = GetAnimatorStateMachine(dstController.layers[0].stateMachine, "attack");
if (srcMachine != null && dstMachine != null)
{
for (int i = 0; i < srcMachine.states.Length; i++)
{
if (srcMachine.states[i].state.motion == null)
{
continue;
}
//Debug.LogError(srcMachine.states[i].state.name);
AnimatorState state = GetAnimatorState(dstMachine, srcMachine.states[i].state.name);
if (state != null)
{
EditorUtility.CopySerialized(srcMachine.states[i].state, state);
state.AddStateMachineBehaviour <PEAnimatorRunning>().running = "Attacking";
}
}
}
}
protected void PasteAsNew()
{
if (AnimatorStateEventBehaviourCopier.copiedBehaviours == null)
{
return;
}
StateMachineBehaviourContext[] contexts = AnimatorController.FindStateMachineBehaviourContext(this);
if (contexts == null)
{
return;
}
StateMachineBehaviour copiedTarget = null;
AnimatorState state = contexts[0].animatorObject as AnimatorState;
if (state != null)
{
copiedTarget = state.AddStateMachineBehaviour(AnimatorStateEventBehaviourCopier.copiedBehaviours.GetType());
}
else
{
AnimatorStateMachine subMachine = contexts[0].animatorObject as AnimatorStateMachine;
if (subMachine != null)
{
copiedTarget = subMachine.AddStateMachineBehaviour(AnimatorStateEventBehaviourCopier.copiedBehaviours.GetType());
}
}
if (copiedTarget != null)
{
EditorUtility.CopySerialized(AnimatorStateEventBehaviourCopier.copiedBehaviours, copiedTarget);
}
}
public static VRCAvatarParameterDriver AddVRCParameterDriver(AnimatorState persistedAnimatorState, string parameterName, float value, List <Object> dirtyAssets)
{
VRCAvatarParameterDriver parameterDriver = persistedAnimatorState.behaviours.OfType <VRCAvatarParameterDriver>().FirstOrDefault();
if (parameterDriver == null)
{
parameterDriver = persistedAnimatorState.AddStateMachineBehaviour <VRCAvatarParameterDriver>();
}
var parameter = parameterDriver.parameters.FirstOrDefault(p => p.name == parameterName);
if (parameter != null)
{
parameterDriver.parameters.Remove(parameter);
}
parameter = new VRC_AvatarParameterDriver.Parameter
{
type = VRC_AvatarParameterDriver.ChangeType.Set,
name = parameterName,
value = value,
};
parameterDriver.parameters.Add(parameter);
dirtyAssets.Add(persistedAnimatorState);
dirtyAssets.Add(parameterDriver);
return(parameterDriver);
}
static void AddToState()
{
if (Selection.activeObject == null)
{
return;
}
if (Selection.activeObject.GetType() != typeof(AnimatorState))
{
return;
}
AnimatorState aCurState = (AnimatorState)Selection.activeObject;
if (aCurState.behaviours.Length > 0)
{
return;
}
string aPath = GetStateBehaviourPath();
if (!File.Exists(aPath))
{
return;
}
string aAssetPath = aPath.Substring(aPath.IndexOf("Assets"));
aCurState.AddStateMachineBehaviour(((MonoScript)AssetDatabase.LoadAssetAtPath(aAssetPath, typeof(MonoScript))).GetClass());
}
//Cette fonction vérifie que la Behaviour spécifique à créer lorsqu'on utilise CreateChildrenStateAndTransitions ne soit pas déjà présente à l'origine. Si elle n'est pas présente, elle la crée.
void CheckBehaviourListAndCreateBehaviourOnState(AnimatorState state, System.Type type)
{
for (int i = 0; i < state.behaviours.Length; i++)
{
if (state.behaviours[i].GetType() == type)
{
Debug.Log("Origin State did not create a new Behaviour. He already had one with needed Type.");
return;
}
}
state.AddStateMachineBehaviour(type);
}
/// <summary>
/// Show how to add a basic state, And add a behaviour
/// </summary>
private void CreateIdle()
{
// Load Animation
AnimationClip idleClip = AnimatorFactoryUtil.LoadAnimClip(AnimationPath + "Idle.FBX");
// add tree state & set state motion
stateIdle = baseLayerMachine.AddState("Idle", new Vector3(300f, 0f));
stateIdle.motion = idleClip;
// Add behaviour to state
stateIdle.AddStateMachineBehaviour <CharacterIdleState>();
// set to default state
baseLayerMachine.defaultState = stateIdle;
}
private void AddEventsToState(AnimatorState state)
{
bool hasEvents = false;
foreach (var behaviour in state.behaviours)
{
if ((behaviour as AnimationEvents) != null)
{
hasEvents = true;
break;
}
}
if (!hasEvents)
{
state.AddStateMachineBehaviour <AnimationEvents>();
}
}
T getStateMachineBehaviour <T>(AnimatorState state) where T : StateMachineBehaviour
{
T retVal = null;
foreach (StateMachineBehaviour smb in state.behaviours)
{
if (smb.GetType() == typeof(T))
{
retVal = (T)smb;
break;
}
}
if (retVal == null)
{
retVal = (T)state.AddStateMachineBehaviour(typeof(T));
}
return(retVal);
}
public string Process()
{
this.rawClip = animatorState.motion as AnimationClip;
if (!rawClip)
{
return(null);
}
this.stateFlag = findStateFlag(animatorState);
//查找标记，检查是否可以跳过
if (stateFlag && stateFlag.skipCompressed)
{
return(null);
}
var size = UnityEngine.Profiler.GetRuntimeMemorySize(rawClip);
//小于16K 不压缩
if (size < 1024 * 16)
{
return(null);
}
string rawClipPath = AssetDatabase.GetAssetPath(rawClip);
if (string.IsNullOrEmpty(rawClipPath))
{
return(null);
}
string anim_gen_dir = Path.GetDirectoryName(rawClipPath) + "/_anim_gen_";
string dataDir = anim_gen_dir + "/datas";
string stubDir = anim_gen_dir + "/stubs";
Directory.CreateDirectory(anim_gen_dir);
Directory.CreateDirectory(dataDir);
Directory.CreateDirectory(stubDir);
this.shareData = getShareData(anim_gen_dir);
this.stubClip = new AnimationClip();
AnimationClipSettings settings = AnimationUtility.GetAnimationClipSettings(rawClip);
stubClip.SetCurve("", typeof(CompressedAnimationDirver), "stubAnimParam", AnimationCurve.Linear(0, 0, rawClip.length, 1));
stubClip.name = rawClip.name + "_stub";
this.clipData = CompressClipData();
AnimationUtility.SetAnimationClipSettings(stubClip, settings);
//*注意：这里是为了兼容通过AnimationClipSettings设置Loop而Wrap没设置
if (settings.loopTime)
{
clipData.wrapMode = (byte)WrapMode.Loop;
stubClip.wrapMode = WrapMode.Loop;
}
else
{
stubClip.wrapMode = rawClip.wrapMode;
}
animatorState.motion = stubClip;
AssetDatabase.CreateAsset(stubClip, stubDir + "/" + stubClip.name + ".anim");
string dataPath = dataDir + "/" + clipData.name + ".asset";
AssetDatabase.CreateAsset(clipData, dataPath);
var stateProxy = animatorState.AddStateMachineBehaviour <CompressionAnimatorStateProxy>();
stateProxy.data = clipData;
return(dataPath);
}
void BuildLayer(AnimationLayer layerType, string layerName, List <GestureAction> actions, MenuActions.MenuAction parentAction)
{
var controller = GetController(layerType);
//Add parameter
if (side == GestureSide.Left || side == GestureSide.Both)
{
AddParameter(controller, "GestureLeft", AnimatorControllerParameterType.Int, 0);
}
if (side == GestureSide.Right || side == GestureSide.Both)
{
AddParameter(controller, "GestureRight", AnimatorControllerParameterType.Int, 0);
}
//Prepare layer
var layer = GetControllerLayer(controller, layerName);
layer.stateMachine.entryTransitions = null;
layer.stateMachine.anyStateTransitions = null;
layer.stateMachine.states = null;
layer.stateMachine.entryPosition = StatePosition(-1, 0);
layer.stateMachine.anyStatePosition = StatePosition(-1, 1);
layer.stateMachine.exitPosition = StatePosition(-1, 2);
//Default state
AnimatorState defaultState = null;
GestureAction defaultAction = null;
var unusedGestures = new List <GestureEnum>();
unusedGestures.Add(GestureEnum.Neutral);
unusedGestures.Add(GestureEnum.Fist);
unusedGestures.Add(GestureEnum.OpenHand);
unusedGestures.Add(GestureEnum.FingerPoint);
unusedGestures.Add(GestureEnum.Victory);
unusedGestures.Add(GestureEnum.RockNRoll);
unusedGestures.Add(GestureEnum.HandGun);
unusedGestures.Add(GestureEnum.ThumbsUp);
//Build states
int actionIter = 0;
foreach (var action in this.actions)
{
//Check if valid
if (!action.gestureTable.IsModified())
{
EditorUtility.DisplayDialog("Build Warning", $"Simple Gesture {action.name} has no selected conditions.", "Okay");
continue;
}
//Build
var state = layer.stateMachine.AddState(action.name, StatePosition(0, actionIter + 1));
state.motion = action.GetAnimation(layerType, true);
actionIter += 1;
//Conditions
AddGestureCondition(GestureEnum.Neutral);
AddGestureCondition(GestureEnum.Fist);
AddGestureCondition(GestureEnum.OpenHand);
AddGestureCondition(GestureEnum.FingerPoint);
AddGestureCondition(GestureEnum.Victory);
AddGestureCondition(GestureEnum.RockNRoll);
AddGestureCondition(GestureEnum.HandGun);
AddGestureCondition(GestureEnum.ThumbsUp);
void AddGestureCondition(BaseActions.GestureEnum gesture)
{
if (!action.gestureTable.GetValue(gesture))
{
return;
}
//Transition
var transition = layer.stateMachine.AddAnyStateTransition(state);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = action.fadeIn;
if (side == GestureSide.Left || side == GestureSide.Both)
{
transition.AddCondition(AnimatorConditionMode.Equals, (int)gesture, "GestureLeft");
}
if (side == GestureSide.Right || side == GestureSide.Both)
{
transition.AddCondition(AnimatorConditionMode.Equals, (int)gesture, "GestureRight");
}
//Parent
if (parentAction != null && gesture != GestureEnum.Neutral)
{
parentAction.AddCondition(transition, true);
}
//Cleanup
unusedGestures.Remove(gesture);
}
//Default
if (action.gestureTable.neutral)
{
defaultState = state;
defaultAction = action;
}
}
//Default state
if (defaultState == null)
{
defaultState = layer.stateMachine.AddState("Neutral", StatePosition(0, 0));
}
layer.stateMachine.defaultState = defaultState;
//Animation Layer Weight
var layerWeight = defaultState.AddStateMachineBehaviour <VRC.SDK3.Avatars.Components.VRCAnimatorLayerControl>();
layerWeight.goalWeight = 1;
layerWeight.layer = GetLayerIndex(controller, layer);
layerWeight.blendDuration = 0;
layerWeight.playable = VRC.SDKBase.VRC_AnimatorLayerControl.BlendableLayer.FX;
//Default transitions
foreach (var gesture in unusedGestures)
{
//Transition
var transition = layer.stateMachine.AddAnyStateTransition(defaultState);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = defaultAction != null ? defaultAction.fadeIn : 0f;
if (side == GestureSide.Left || side == GestureSide.Both)
{
transition.AddCondition(AnimatorConditionMode.Equals, (int)gesture, "GestureLeft");
}
if (side == GestureSide.Right || side == GestureSide.Both)
{
transition.AddCondition(AnimatorConditionMode.Equals, (int)gesture, "GestureRight");
}
}
//Parent
if (parentAction != null)
{
var transition = layer.stateMachine.AddAnyStateTransition(defaultState);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = defaultAction != null ? defaultAction.fadeIn : 0f;
parentAction.AddCondition(transition, false);
}
}
static public Animator GenerateAnimator(GameObject target, params string[] clipsName)
{
UIManConfig config = Resources.Load <UIManConfig> ("UIManConfig");
Animator anim = target.GetComponent <Animator> ();
if (anim == null)
{
anim = target.AddComponent <Animator> ();
}
// Create folder
string assetPath = Application.dataPath.Substring(Application.dataPath.IndexOf("/Assets") + 1) + "/" + config.animRootFolder;
string rootFolderPath = string.Format("{0}{1}", assetPath, target.name);
EditorUtils.CreatePath(rootFolderPath);
// Create controller
string controllerFilePath = string.Format("{0}/{1}.controller", rootFolderPath, target.name);
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath(controllerFilePath);
// Change the name of the first layer.
AnimatorControllerLayer[] layers = controller.layers;
layers [0].name = "Base Layer";
controller.layers = layers;
// Get the root state machine .
AnimatorStateMachine rootStateMachine = controller.layers [0].stateMachine;
// Set the default state.
AnimatorState defaultState = rootStateMachine.AddState("Default");
defaultState.motion = null;
rootStateMachine.defaultState = defaultState;
// Add states and transitions
for (int i = 0; i < clipsName.Length; i++)
{
// Add parameters to the controller.
//string triggerName = string.Format("Do{0}", clipsName[i]);
//controller.AddParameter (triggerName, AnimatorControllerParameterType.Trigger);
// Create empty clip and add motion
AnimationClip clip = new AnimationClip();
string clipName = clipsName [i];
string clipPath = string.Format("{0}/{1}.anim", rootFolderPath, clipName);
clip.name = clipName;
AssetDatabase.CreateAsset(clip, clipPath);
// Add motion to controller
Motion motion = AssetDatabase.LoadAssetAtPath(clipPath, typeof(AnimationClip)) as Motion;
AnimatorState newState = rootStateMachine.AddState(clipName);
newState.motion = motion;
UIAnimationState smb = (UIAnimationState)newState.AddStateMachineBehaviour(typeof(UIAnimationState));
if (clipName == UIManDefine.ANIM_SHOW)
{
smb.Init(UIAnimationType.SHOW, true, false);
}
else if (clipName == UIManDefine.ANIM_HIDE)
{
smb.Init(UIAnimationType.HIDE, true, true);
}
else if (clipName == UIManDefine.ANIM_IDLE)
{
smb.Init(UIAnimationType.IDLE, true, false);
}
// Add trasition to controller
/*
* AnimatorStateTransition transition = rootStateMachine.AddAnyStateTransition(newState);
* transition.hasExitTime = false;
* transition.exitTime = 0.0f;
* transition.hasFixedDuration = true;
* transition.duration = 0.0f;
* transition.offset = 0.0f;
*/
// Add condition for transition
//transition.AddCondition(AnimatorConditionMode.If, 0, triggerName);
}
anim.runtimeAnimatorController = controller;
return(anim);
}
public static void Apply(this AnimatorState dest, AnimatorState source)
{
dest.cycleOffsetParameter = source.cycleOffsetParameter;
dest.cycleOffset = source.cycleOffset;
dest.cycleOffsetParameterActive = source.cycleOffsetParameterActive;
dest.iKOnFeet = source.iKOnFeet;
dest.mirror = source.mirror;
dest.mirrorParameter = source.mirrorParameter;
dest.mirrorParameterActive = source.mirrorParameterActive;
dest.motion = source.motion; // keep reference
dest.speed = source.speed;
dest.speedParameter = source.speedParameter;
dest.speedParameterActive = source.speedParameterActive;
dest.tag = source.tag;
dest.timeParameter = source.timeParameter;
dest.timeParameterActive = source.timeParameterActive;
dest.writeDefaultValues = source.writeDefaultValues;
dest.name = source.name;
dest.hideFlags = source.hideFlags;
foreach (var sourceTransition in source.transitions.Where(w => w.isExit))
{
var transition = dest.AddExitTransition(false);
sourceTransition.CloneTo(transition);
// should always false
if (InstanceCaches <AnimatorStateTransition> .Find(sourceTransition.GetInstanceID()) == null)
{
InstanceCaches <AnimatorStateTransition> .Register(sourceTransition.GetInstanceID(), transition);
}
}
foreach (var sourceTransition in source.transitions.Where(w => !w.isExit))
{
AnimatorStateTransition transition = null;
if (sourceTransition.destinationStateMachine != null)
{
transition = dest.AddTransition(InstanceCaches <AnimatorStateMachine> .FindOrCreate(sourceTransition.destinationStateMachine, w => w.CloneDeep()));
}
if (sourceTransition.destinationState != null)
{
transition = dest.AddTransition(InstanceCaches <AnimatorState> .FindOrCreate(sourceTransition.destinationState, CloneDeep));
}
if (transition == null)
{
throw new ArgumentNullException(nameof(transition));
}
sourceTransition.CloneTo(transition);
// should always false
if (InstanceCaches <AnimatorStateTransition> .Find(sourceTransition.GetInstanceID()) == null)
{
InstanceCaches <AnimatorStateTransition> .Register(sourceTransition.GetInstanceID(), transition);
}
}
foreach (var sourceBehaviour in source.behaviours)
{
var behaviour = dest.AddStateMachineBehaviour(sourceBehaviour.GetType());
sourceBehaviour.CloneDeepTo(behaviour);
// store
InstanceCaches <StateMachineBehaviour> .Register(behaviour.GetInstanceID(), behaviour);
}
}
public static AnimatorState CloneDeep(this AnimatorState source)
{
var dest = new AnimatorState
{
cycleOffset = source.cycleOffset,
cycleOffsetParameter = source.cycleOffsetParameter,
cycleOffsetParameterActive = source.cycleOffsetParameterActive,
iKOnFeet = source.iKOnFeet,
mirror = source.mirror,
mirrorParameter = source.mirrorParameter,
mirrorParameterActive = source.mirrorParameterActive,
motion = source.motion,
speed = source.speed,
speedParameter = source.speedParameter,
speedParameterActive = source.speedParameterActive,
tag = source.tag,
timeParameter = source.timeParameter,
timeParameterActive = source.timeParameterActive,
writeDefaultValues = source.writeDefaultValues,
name = source.name,
hideFlags = source.hideFlags
};
foreach (var sourceTransition in source.transitions.Where(w => w.isExit))
{
var transition = dest.AddExitTransition(false);
sourceTransition.ApplyTo(transition);
InstanceCache <AnimatorStateTransition> .SafeRegister(sourceTransition.GetInstanceID(), transition);
}
foreach (var sourceTransition in source.transitions.Where(w => !w.isExit))
{
AnimatorStateTransition transition = null;
if (sourceTransition.destinationStateMachine != null)
{
transition = dest.AddTransition(InstanceCache <AnimatorStateMachine> .FindOrCreate(sourceTransition.destinationStateMachine, w => w.CloneDeep()));
}
if (sourceTransition.destinationState != null)
{
transition = dest.AddTransition(InstanceCache <AnimatorState> .FindOrCreate(sourceTransition.destinationState, w => w.CloneDeep()));
}
if (transition == null)
{
throw new ArgumentNullException(nameof(transition));
}
sourceTransition.ApplyTo(transition);
InstanceCache <AnimatorStateTransition> .SafeRegister(sourceTransition.GetInstanceID(), transition);
}
foreach (var sourceBehaviour in source.behaviours)
{
var behaviour = dest.AddStateMachineBehaviour(sourceBehaviour.GetType());
sourceBehaviour.ApplyTo(behaviour);
InstanceCache <StateMachineBehaviour> .SafeRegister(behaviour.GetInstanceID(), behaviour);
}
return(dest);
}
public static Animator GenerateAnimator(GameObject target, params string[] clipsName)
{
var config = EditorHelper.GetOrCreateScriptableObject <UIManConfig>(false);
Animator anim = target.GetComponent <Animator>();
if (anim == null)
{
anim = target.AddComponent <Animator>();
}
// Create folder
var assetPath = Application.dataPath.Substring(Application.dataPath.IndexOf("/Assets") + 1) + "/" + config.animRootFolder;
var rootFolderPath = string.Format("{0}{1}", assetPath, target.name);
EditorUtils.CreatePath(rootFolderPath);
// Create controller
var controllerFilePath = string.Format("{0}/{1}.controller", rootFolderPath, target.name);
var controller = AnimatorController.CreateAnimatorControllerAtPath(controllerFilePath);
// Change the name of the first layer.
AnimatorControllerLayer[] layers = controller.layers;
layers[0].name = "Base Layer";
controller.layers = layers;
// Get the root state machine .
AnimatorStateMachine rootStateMachine = controller.layers[0].stateMachine;
// Set the default state.
AnimatorState defaultState = rootStateMachine.AddState("Default");
defaultState.motion = null;
rootStateMachine.defaultState = defaultState;
// Add states and transitions
for (var i = 0; i < clipsName.Length; i++)
{
// Create empty clip and add motion
var clip = new AnimationClip();
var clipName = clipsName[i];
var clipPath = string.Format("{0}/{1}.anim", rootFolderPath, clipName);
clip.name = clipName;
AssetDatabase.CreateAsset(clip, clipPath);
// Add motion to controller
var motion = AssetDatabase.LoadAssetAtPath(clipPath, typeof(AnimationClip)) as Motion;
AnimatorState newState = rootStateMachine.AddState(clipName);
newState.motion = motion;
var smb = (UIAnimationState)newState.AddStateMachineBehaviour(typeof(UIAnimationState));
if (clipName == UIManDefine.ANIM_SHOW)
{
smb.Init(UIAnimationType.Show, true, false);
}
else if (clipName == UIManDefine.ANIM_HIDE)
{
smb.Init(UIAnimationType.Hide, true, true);
}
else if (clipName == UIManDefine.ANIM_IDLE)
{
smb.Init(UIAnimationType.Idle, true, false);
}
}
anim.runtimeAnimatorController = controller;
return(anim);
}
void BuildLayer(AnimationLayer layerType, string layerName, List <VisemeAction> actions, MenuActions.MenuAction parentAction)
{
var controller = GetController(layerType);
var VisemeValues = System.Enum.GetValues(typeof(VisemeEnum)).Cast <VisemeEnum>();
//Add parameter
AddParameter(controller, "Viseme", AnimatorControllerParameterType.Int, 0);
//Prepare layer
var layer = GetControllerLayer(controller, layerName);
layer.stateMachine.entryTransitions = null;
layer.stateMachine.anyStateTransitions = null;
layer.stateMachine.states = null;
layer.stateMachine.entryPosition = StatePosition(-1, 0);
layer.stateMachine.anyStatePosition = StatePosition(-1, 1);
layer.stateMachine.exitPosition = StatePosition(-1, 2);
//Default
AnimatorState defaultState = null;
VisemeAction defaultAction = null;
var unusedValues = new List <VisemeEnum>();
foreach (var value in VisemeValues)
{
unusedValues.Add(value);
}
//Build states
int actionIter = 0;
foreach (var action in this.actions)
{
//Check if valid
if (!action.visimeTable.IsModified())
{
EditorUtility.DisplayDialog("Build Warning", $"Visemes {action.name} has no selected conditions.", "Okay");
continue;
}
//Build
var state = layer.stateMachine.AddState(action.name, StatePosition(0, actionIter + 1));
state.motion = action.GetAnimation(layerType, true);
actionIter += 1;
//Conditions
foreach (var value in VisemeValues)
{
AddCondition(value);
}
void AddCondition(BaseActions.VisemeEnum visime)
{
if (action.visimeTable.GetValue(visime))
{
//Transition
var transition = layer.stateMachine.AddAnyStateTransition(state);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = action.fadeIn;
transition.canTransitionToSelf = false;
transition.AddCondition(AnimatorConditionMode.Equals, (int)visime, "Viseme");
//Parent
if (parentAction != null)
{
parentAction.AddCondition(transition, true);
}
//Cleanup
unusedValues.Remove(visime);
}
}
//Store default
if (action.visimeTable.sil)
{
defaultState = state;
defaultAction = action;
}
}
//Default state
if (defaultState == null)
{
defaultState = layer.stateMachine.AddState("Default", StatePosition(0, 0));
}
layer.stateMachine.defaultState = defaultState;
//Animation Layer Weight
var layerWeight = defaultState.AddStateMachineBehaviour <VRC.SDK3.Avatars.Components.VRCAnimatorLayerControl>();
layerWeight.goalWeight = 1;
layerWeight.layer = GetLayerIndex(controller, layer);
layerWeight.blendDuration = 0;
layerWeight.playable = VRC.SDKBase.VRC_AnimatorLayerControl.BlendableLayer.FX;
//Default transitions
foreach (var visime in unusedValues)
{
//Transition
var transition = layer.stateMachine.AddAnyStateTransition(defaultState);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = defaultAction != null ? defaultAction.fadeIn : 0f;
transition.canTransitionToSelf = false;
transition.AddCondition(AnimatorConditionMode.Equals, (int)visime, "Viseme");
}
//Parent
if (parentAction != null)
{
var transition = layer.stateMachine.AddAnyStateTransition(defaultState);
transition.hasExitTime = false;
transition.exitTime = 0;
transition.duration = defaultAction != null ? defaultAction.fadeIn : 0f;
transition.canTransitionToSelf = false;
parentAction.AddCondition(transition, false);
}
}
public static RuntimeAnimatorController Create(SmwCharacterGenerics smwCharacterGenerics, SmwCharacter smwCharacter, Teams teamId)
{
string charName = smwCharacter.charName;
if (charName == "")
{
Debug.LogError("smwCharacter hat keinen namen gesetzt!");
charName = "unnamedChar";
}
Debug.Log("CharacterAnimator" + " Create () " + charName);
string createdCharacterFolderPath = "Animations/Characters/AutoGenerated/" + charName + "_" + teamId;
if (!AssetTools.TryCreateFolderWithAssetDatabase(createdCharacterFolderPath, out createdCharacterFolderPath))
{
Debug.LogError("Ordner existiert/existerieren nicht und kann/können nicht angelegt werden!\n" + createdCharacterFolderPath);
return(null);
}
/**
* AssetDatabase : All paths are relative to the project folder => paths always = "Assets/..../..." //TODO last folder no SLASH / !!!
**/
// string assetCreatedCharacterFolderPath = "Assets/" + createdCharacterFolderPath;
AnimatorController controller = AnimatorController.CreateAnimatorControllerAtPath(createdCharacterFolderPath + "/" + charName + "_" + teamId + "_scripted_AnimatorController.controller");
AddAnimatorControllerParameter(controller);
#region Layer 0 State Machine
// Layer 0 State Machine
AnimatorStateMachine rootStateMachine = controller.layers[0].stateMachine;
Vector3 anyStatePos = rootStateMachine.anyStatePosition;
//Vector3 entryStatePos = rootStateMachine.entryPosition;
Vector3 refStatePos = anyStatePos;
Vector3 tempStatePos;
tempStatePos = anyStatePos;
tempStatePos.x += 200;
rootStateMachine.anyStatePosition = tempStatePos;
/* Add states */
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y - 200;
AnimatorState idleState = rootStateMachine.AddState(HashID.s_Idle, tempStatePos);
// idleState.motion = idleAnim;
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y - 100;
AnimatorState jumpState = rootStateMachine.AddState(HashID.s_JumpAndFall, tempStatePos);
// jumpState.motion = jumpAnim;
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y - 300;
AnimatorState runState = rootStateMachine.AddState(HashID.s_Run, tempStatePos);
// runState.motion = runAnim;
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y - 400;
AnimatorState skidState = rootStateMachine.AddState(HashID.s_ChangeRunDirection, tempStatePos);
// skidState.motion = changeRunDirectionAnim;
tempStatePos.x = refStatePos.x + 600;
tempStatePos.y = refStatePos.y;
AnimatorState hittedState = rootStateMachine.AddState(HashID.s_Generic_Hitted, tempStatePos);
// hittedState.motion = idleAnim;
tempStatePos.x = refStatePos.x + 750;
tempStatePos.y = refStatePos.y - 100;
AnimatorState headJumpedState = rootStateMachine.AddState(HashID.s_HeadJumped, tempStatePos);
// headJumpedState.motion = headJumpedAnim;
tempStatePos.x = refStatePos.x + 450;
tempStatePos.y = refStatePos.y - 100;
AnimatorState gameOverState = rootStateMachine.AddState(HashID.s_GameOver, tempStatePos);
// gameOverState.motion = headJumpedAnim;
tempStatePos.x = refStatePos.x + 600;
tempStatePos.y = refStatePos.y - 200;
AnimatorState deadState = rootStateMachine.AddState(HashID.s_Dead, tempStatePos);
// deadState.motion = headJumpedAnim;
tempStatePos.x = refStatePos.x + 750;
tempStatePos.y = refStatePos.y - 300;
AnimatorState spawnState = rootStateMachine.AddState(HashID.s_Generic_Spawn, tempStatePos);
spawnState.AddStateMachineBehaviour(typeof(SpawnStateScript)); //TODO reference zu characterScript direct mitgeben???
// spawnState.AddStateMachineBehaviour(new SpawnStateScript());
tempStatePos.x = refStatePos.x + 800;
tempStatePos.y = refStatePos.y - 400;
AnimatorState spawnDelayState = rootStateMachine.AddState(HashID.s_Generic_SpawnDelay, tempStatePos);
spawnDelayState.AddStateMachineBehaviour(typeof(SpawnDelayStateScript)); //TODO reference zu characterScript direct mitgeben???
// spawnState.AddStateMachineBehaviour(new SpawnDelayStateScript());
// spawnState.motion = headJumpedAnim;
// AnimatorState spawnProtectionState = rootStateMachine.AddState(HashID.s_Generic_SpawnProtection);
// spawnProtectionState.motion = headJumpedAnim;
#endregion
#region Layer 1 State Machine - Overlay Layer
/**
* Layer 1 - Overlay Layer
**/
// FIX defaultWeight and blendingMode!!!!
// // Manual Creating Layer : http://forum.unity3d.com/threads/animatorcontroller-addlayer-doesnt-create-default-animatorstatemachine.307873/#post-2003218
AnimatorControllerLayer newLayer = new AnimatorControllerLayer();
newLayer.name = HashID.l_overlay;
newLayer.stateMachine = new AnimatorStateMachine();
newLayer.stateMachine.name = newLayer.name;
newLayer.stateMachine.hideFlags = HideFlags.HideInHierarchy;
if (AssetDatabase.GetAssetPath(controller) != "")
{
AssetDatabase.AddObjectToAsset(newLayer.stateMachine, AssetDatabase.GetAssetPath(controller));
}
//Custom
newLayer.blendingMode = AnimatorLayerBlendingMode.Override;
newLayer.defaultWeight = 1f;
controller.AddLayer(newLayer);
// Another Way:
//Animator anim;
//anim.SetLayerWeight (layerIndex, weight)
// // Auto Creating Layer & StateMachine AddLayer(string)!!!
// controller.AddLayer(HashID.l_overlay);
// controller.layers[1].blendingMode = AnimatorLayerBlendingMode.Additive; // setzt für die zeit die es aktiv ist die variablen und wenn deaktiviert wird variable auf vorherigen wert gesetzt
// controller.layers[1].defaultWeight = 1f;
if (controller.layers[1].stateMachine == null)
{
Debug.LogError("stateMachine == null");
// controller.layers[1].stateMachine = new AnimatorStateMachine();
}
// Layer 1 State Machine
// controller.layers[1].blendingMode = AnimatorLayerBlendingMode.Override; // setzt für die zeit die es aktiv ist die variablen und wenn deaktiviert wird variable auf vorherigen wert gesetzt
// controller.layers[1].defaultWeight = 1f;
AnimatorStateMachine overlayStateMachine = controller.layers[1].stateMachine;
refStatePos = overlayStateMachine.anyStatePosition;
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y;
AnimatorState defaultOverlayState = overlayStateMachine.AddState(HashID.s_l1_Generic_DefaultState, tempStatePos);
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y - 100;
AnimatorState invincibleOverlayState = overlayStateMachine.AddState(HashID.s_l1_Generic_Invincible, tempStatePos);
tempStatePos.x = refStatePos.x + 200;
tempStatePos.y = refStatePos.y + 100;
AnimatorState protectionOverlayState = overlayStateMachine.AddState(HashID.s_l1_Generic_Protection, tempStatePos);
#endregion
#region Layer 1 State Machine - Overlay Layer Transitions
AnimatorStateTransition leaveInvincibleEnterDefaultState = invincibleOverlayState.AddTransition(defaultOverlayState);
// leaveInvincibleEnterDefaultState.AddCondition(AnimatorConditionMode.If, 0, HashID.p_rageTrigger);
SetupAnimatorStateTransition(leaveInvincibleEnterDefaultState, 0f, true, 1f, false);
AnimatorStateTransition leaveProtectionEnterDefaultStateByTime = protectionOverlayState.AddTransition(defaultOverlayState);
// leaveInvincibleEnterDefaultState.AddCondition(AnimatorConditionMode.If, 0, HashID.p_rageTrigger);
SetupAnimatorStateTransition(leaveProtectionEnterDefaultStateByTime, 0f, true, 1f, false);
AnimatorStateTransition leaveProtectionEnterDefaultStateByTrigger = protectionOverlayState.AddTransition(defaultOverlayState);
SetupAnimatorStateTransition(leaveProtectionEnterDefaultStateByTrigger, 0f, false, 1f, false);
leaveProtectionEnterDefaultStateByTrigger.AddCondition(AnimatorConditionMode.If, 0, HashID.p_stopProtectionTrigger); //TODO defaultOverlayState muss kräfte invincible/spawnprotection entfernen??
// Overlay Layer : AnyState Transitions to InvincibleState
AnimatorStateTransition enterInvincibleOverlayerState = overlayStateMachine.AddAnyStateTransition(invincibleOverlayState);
SetupAnimatorStateTransition(enterInvincibleOverlayerState, 0f, false, 1f, false);
enterInvincibleOverlayerState.AddCondition(AnimatorConditionMode.If, 0, HashID.p_rageTrigger);
// Overlay Layer : AnyState Transitions to ProtectionState
AnimatorStateTransition enterProtectionOverlayerState = overlayStateMachine.AddAnyStateTransition(protectionOverlayState); //TODO rename SpawnProtection to Protection
SetupAnimatorStateTransition(enterProtectionOverlayerState, 0f, false, 1f, false);
enterProtectionOverlayerState.AddCondition(AnimatorConditionMode.If, 0, HashID.p_startProtectionTrigger);
#endregion
#region Layer 0 State Machine Transitions
// Layer 0 - Base Layer
float minHorizontalSpeed = 0.01f; // setze schwellwert (treshold)
AnimatorStateTransition leaveIdleEnterRunIfGreater = idleState.AddTransition(runState);
SetupAnimatorStateTransition(leaveIdleEnterRunIfGreater, 0f, false, 1f, false);
leaveIdleEnterRunIfGreater.AddCondition(AnimatorConditionMode.Greater, minHorizontalSpeed, HashID.p_hSpeed);
AnimatorStateTransition leaveIdleEnterRunIfLower = idleState.AddTransition(runState);
SetupAnimatorStateTransition(leaveIdleEnterRunIfLower, 0f, false, 1f, false);
leaveIdleEnterRunIfLower.AddCondition(AnimatorConditionMode.Less, -minHorizontalSpeed, HashID.p_hSpeed);
AnimatorStateTransition leaveRunEnterIdle = runState.AddTransition(idleState);
leaveRunEnterIdle.AddCondition(AnimatorConditionMode.Greater, -minHorizontalSpeed, HashID.p_hSpeed);
leaveRunEnterIdle.AddCondition(AnimatorConditionMode.Less, minHorizontalSpeed, HashID.p_hSpeed);
SetupAnimatorStateTransition(leaveRunEnterIdle, 0f, false, 1f, false);
AnimatorStateTransition leaveRunEnterJump = runState.AddTransition(jumpState);
leaveRunEnterJump.AddCondition(AnimatorConditionMode.IfNot, 0, HashID.p_grounded);
SetupAnimatorStateTransition(leaveRunEnterJump, 0f, false, 1f, false);
AnimatorStateTransition leaveIdleEnterJump = idleState.AddTransition(jumpState);
SetupAnimatorStateTransition(leaveIdleEnterJump, 0f, false, 1f, false);
leaveIdleEnterJump.AddCondition(AnimatorConditionMode.IfNot, 0, HashID.p_grounded);
AnimatorStateTransition leaveJumpEnterIdle = jumpState.AddTransition(idleState);
SetupAnimatorStateTransition(leaveJumpEnterIdle, 0f, false, 1f, false);
leaveJumpEnterIdle.AddCondition(AnimatorConditionMode.If, 0, HashID.p_grounded);
AnimatorStateTransition leaveRunEnterSkid = runState.AddTransition(skidState);
SetupAnimatorStateTransition(leaveRunEnterSkid, 0f, false, 1f, false);
leaveRunEnterSkid.AddCondition(AnimatorConditionMode.If, 0, HashID.p_changeRunDirectionTrigger);
AnimatorStateTransition leaveSkidEnterRun = skidState.AddTransition(runState);
SetupAnimatorStateTransition(leaveSkidEnterRun, 0f, true, 1f, false); //TODO achtung byTime!
//leaveSkidEnterRun.AddCondition(AnimatorConditionMode.IfNot, 0, HashID.p_changeRunDirectionTrigger);
// Any State Transistion
AnimatorStateTransition fallingTransition = rootStateMachine.AddAnyStateTransition(jumpState); //special TODO markt
SetupAnimatorStateTransition(fallingTransition, 0f, false, 1f, false);
fallingTransition.AddCondition(AnimatorConditionMode.IfNot, 0, HashID.p_grounded);
// Any State Transistion
AnimatorStateTransition hittedTransition = rootStateMachine.AddAnyStateTransition(hittedState); //special TODO markt
SetupAnimatorStateTransition(hittedTransition, 0f, false, 1f, false);
hittedTransition.AddCondition(AnimatorConditionMode.If, 0, HashID.p_hitTrigger);
AnimatorStateTransition leaveHittedEnterHeadJumped = hittedState.AddTransition(headJumpedState);
SetupAnimatorStateTransition(leaveHittedEnterHeadJumped, 0f, false, 1f, false);
leaveHittedEnterHeadJumped.AddCondition(AnimatorConditionMode.If, 0, HashID.p_headJumped); // TODO <-- change to Trigger? p_headJumpedTrigger
AnimatorStateTransition leaveHittedEnterDie = hittedState.AddTransition(deadState);
SetupAnimatorStateTransition(leaveHittedEnterDie, 0f, false, 1f, false);
leaveHittedEnterDie.AddCondition(AnimatorConditionMode.If, 0, HashID.p_dead); // TODO <-- change to name p_dieTrigger
AnimatorStateTransition leaveHittedEnterGameOver = hittedState.AddTransition(gameOverState);
SetupAnimatorStateTransition(leaveHittedEnterGameOver, 0f, false, 1f, false);
leaveHittedEnterGameOver.AddCondition(AnimatorConditionMode.If, 0, HashID.p_gameOver); // TODO <-- change to name p_gameOverTrigger
AnimatorStateTransition leaveHeadJumpedEnterSpawn = headJumpedState.AddTransition(spawnState);
SetupAnimatorStateTransition(leaveHeadJumpedEnterSpawn, 0f, false, 1f, false);
leaveHeadJumpedEnterSpawn.AddCondition(AnimatorConditionMode.If, 0, HashID.p_spawn); // TODO <-- change to name p_spawnTrigger
AnimatorStateTransition leaveDieEnterSpawn = deadState.AddTransition(spawnState);
SetupAnimatorStateTransition(leaveDieEnterSpawn, 0f, false, 1f, false);
leaveDieEnterSpawn.AddCondition(AnimatorConditionMode.If, 0, HashID.p_spawn); // TODO <-- change to name p_spawnTrigger
AnimatorStateTransition leaveSpawnEnterIdle = spawnState.AddTransition(idleState);
SetupAnimatorStateTransition(leaveSpawnEnterIdle, 0f, true, 1f, false); //TODO achtung byTime! //TODO <-- Achtung hasExitTime (nach Animation)
//leaveSpawnEnterIdle.AddCondition(AnimatorConditionMode.If, 0, HashID.p_spawn); //TODO add condition to enable controlls & enable gravity & & ...
#endregion
// init smwAnimations array
// int baseLayerStateCount = 0;
smwAnimations.Clear(); // BUG FIX!
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_Idle", 24, 1, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.Idle), WrapMode.Loop, idleState));
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_Run", 24, 2, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.Run), WrapMode.Loop, runState));
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_Jump", 24, 1, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.Jump), WrapMode.Loop, jumpState));
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_Skid", 24, 1, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.Skid), WrapMode.Loop, skidState));
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_Die", 24, 1, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.Die), WrapMode.Loop, deadState));
smwAnimations.Add(new SMWAnimation(charName + "_" + teamId + "_dynamic_HeadJumped", 24, 1, smwCharacter.GetSprites(teamId, SmwCharacterAnimation.HeadJumped), WrapMode.Loop, headJumpedState));
GenerateAnimationClipAssets(smwAnimations, createdCharacterFolderPath, true);
//TODO:: add Generic AnimationClips to characterAnimatorController
spawnState.motion = smwCharacterGenerics.spawnAnimClip;
protectionOverlayState.motion = smwCharacterGenerics.protectionAnimClip;
invincibleOverlayState.motion = smwCharacterGenerics.rageAnimClip;
//TODO
//smwCharacter.runtimeAnimatorController = controller;
smwCharacter.SetRuntimeAnimationController(teamId, controller);
EditorUtility.SetDirty(smwCharacter); // save ScriptableObject
return(controller);
}
public bool BurnTracks(List <AudioClip> libAssets)
{
if (null == fxAnimator)
{
throw new System.Exception("We need your FX Animator Controller");
}
if (null == AudioClip)
{
throw new System.Exception("We need an AudioClip from your Song Library");
}
if (null == _8TrackObject)
{
throw new System.Exception("8Track object was not set");
}
_8TrackObject.SetActive(false);
int childIndex = 0;
while (true)
{
if (0 == _8TrackObject.transform.childCount || childIndex >= _8TrackObject.transform.childCount)
{
break;
}
else if (_8TrackObject.transform.GetChild(childIndex).gameObject.name.StartsWith("Track"))
{
Debug.Log("deleting child " + _8TrackObject.transform.GetChild(childIndex).gameObject.name);
DestroyImmediate(_8TrackObject.transform.GetChild(childIndex).gameObject);
}
else
{
childIndex++;
}
}
RemoveExistingAnimatorLayer(fxAnimator, _8TrackObject.name);
HandleAnimatorParameters(fxAnimator, _8TrackObject.name);
//--- --- Volume Animation Controller --- ---
AnimationClip volumeSet = new AnimationClip {
name = VolumeEPName
};
//--- --- Track Animation Controller --- ---
AnimatorControllerLayer trackLayer = new AnimatorControllerLayer {
name = _8TrackObject.name,
defaultWeight = 1,
stateMachine = new AnimatorStateMachine()
{
name = _8TrackObject.name
}
};
fxAnimator.AddLayer(trackLayer);
AnimatorStateMachine stateMachine = trackLayer.stateMachine;
//--- --- No Track --- ---
int trackCount = 0;
AnimatorState defaultState = stateMachine.AddState("Stop");
defaultState.speed = 100;
AnimatorStateTransition anyToWait = stateMachine.AddAnyStateTransition(defaultState);
anyToWait.AddCondition(AnimatorConditionMode.Equals, trackCount, TrackEPName);
anyToWait.hasExitTime = true;
anyToWait.exitTime = 0;
anyToWait.duration = 0;
AnimatorState loopState = stateMachine.AddState("LoopOff");
loopState.speed = 100;
if (!PlayerLoops)
{
PersistAnimator(fxAnimator);
VRCAvatarParameterDriver driver = loopState.AddStateMachineBehaviour <VRCAvatarParameterDriver>();
driver.parameters.Add(new VRC.SDKBase.VRC_AvatarParameterDriver.Parameter()
{
name = TrackEPName,
value = 0,
type = VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Set
});
}
AnimatorStateTransition loopExit = loopState.AddExitTransition();
loopExit.hasExitTime = true;
loopExit.exitTime = 0;
loopExit.duration = 0;
//--- --- All Tracks --- ---
foreach (Object asset in libAssets)
{
if (asset is AudioClip)
{
//Animation setup
string trackName = "Track " + ++trackCount;
AnimationClip tracktoggle = new AnimationClip {
name = trackName
};
AudioClip clip = asset as AudioClip;
tracktoggle.SetCurve(_8TrackObject.name, typeof(GameObject), "m_IsActive", AnimationCurve.Linear(0.0f, 1f, clip.length, 1f));
tracktoggle.SetCurve(_8TrackObject.name + "/" + trackName, typeof(GameObject), "m_IsActive", AnimationCurve.Linear(0.0f, 1f, clip.length, 1f));
AnimatorState state = stateMachine.AddState(trackName);
state.motion = tracktoggle;
AnimatorStateTransition toTrack = defaultState.AddTransition(state);
toTrack.AddCondition(AnimatorConditionMode.Equals, trackCount, TrackEPName);
toTrack.hasExitTime = true;
toTrack.exitTime = 0;
toTrack.duration = 0;
AnimatorStateTransition trackOut = state.AddTransition(loopState);
trackOut.hasExitTime = true;
trackOut.exitTime = 1;
trackOut.duration = 0;
AnimatorStateTransition trackSwitch = state.AddTransition(defaultState);
trackSwitch.AddCondition(AnimatorConditionMode.NotEqual, trackCount, TrackEPName);
trackSwitch.duration = 0;
Avatar8Track.CreateAsset(AudioClip, tracktoggle, trackName + ".anim");
//volume
volumeSet.SetCurve(_8TrackObject.name + "/" + trackName, typeof(AudioSource), "m_Volume", AnimationCurve.Linear(0.0f, 0f, 0.033333335f, 1f));
//Object setup
GameObject trackObject = new GameObject(trackName, new System.Type[] { typeof(AudioSource) });
trackObject.transform.SetParent(_8TrackObject.transform);
trackObject.SetActive(false);
//trackObject.AddComponent<AudioSource>();
Avatar8Track.CopyComponent(_8TrackObject.GetComponent <AudioSource>(), trackObject.GetComponent <AudioSource>());
AudioSource source = trackObject.GetComponent <AudioSource>();
source.enabled = true;
source.clip = clip;
trackObject.name = trackName;
}
}
fxAnimator.AddLayer(CreateVolumeLayer(_8TrackObject.name, VolumeEPName, volumeSet));
PersistAnimator(fxAnimator);
return(true);
}
static void CreateAnimStates()
{
AnimatorStateMachine stateMachine = null;
List <AnimatorState> state_list = new List <AnimatorState>();
for (int i = 0; i < posterAnimationDatas.Count; i++)
{
string clip_Path = AnimatorClipPrefix + characterName + "/Set" + posterAnimationDatas[i].Set
+ AnimatorClipInfix + posterAnimationDatas[i].AnimationClip + ".anim";
AnimationClip clip = AssetDatabase.LoadAssetAtPath(clip_Path, typeof(AnimationClip)) as AnimationClip;
stateMachine = productController.layers[0].stateMachine;
Vector2 position = Vector2.zero;
if (posterAnimationDatas[i].AnimationClip.Contains("Idle"))
{
position = new Vector2(400, 600);
}
else if (posterAnimationDatas[i].AnimationClip.Contains("Touch"))
{
position = new Vector2(800, 80 * i);
}
else if (posterAnimationDatas[i].AnimationClip.Contains("MainInShow"))
{
position = new Vector2(400, 200);
}
else
{
position = new Vector2(0, 80 * i);
}
AnimatorState state = stateMachine.AddState(posterAnimationDatas[i].AnimationClip, position);
state.motion = clip;
if (posterAnimationDatas[i].NeedEndEvent)
{
state.AddStateMachineBehaviour <PosterStateExitBehaviour>();
}
if (posterAnimationDatas[i].IsDefaultIdle)
{
stateMachine.defaultState = state;
}
state_list.Add(state);
}
for (int i = 0; i < state_list.Count; i++)
{
for (int j = 0; j < posterAnimationDatas[i].ToStateArray.Length; j++)
{
int to_index = GetToStateRealIndex(posterAnimationDatas[i].ToStateArray[j]);
AnimatorStateTransition transition = state_list[i].AddTransition(state_list[to_index]);
if (!string.IsNullOrEmpty(posterAnimationDatas[to_index].Parameter))
{
transition.hasExitTime = false;
transition.AddCondition(AnimatorConditionMode.If, 0, posterAnimationDatas[to_index].Parameter);
}
else
{
transition.hasExitTime = true;
transition.exitTime = 0.75f;
}
}
}
EditorUtility.SetDirty(productController);
AssetDatabase.SaveAssets();
}