void OnGUI ()
{
EditorGUILayout.LabelField ("target clip");
EditorGUI.BeginChangeCheck ();
controller = EditorGUILayout.ObjectField (controller, typeof(UnityEditor.Animations.AnimatorController), false) as UnityEditor.Animations.AnimatorController;
if (EditorGUI.EndChangeCheck ()) {
RefleshClipList (controller);
}
if (controller == null)
return;
EditorGUILayout.Space ();
EditorGUILayout.HelpBox ("Type a new clip name", MessageType.None);
EditorGUILayout.BeginVertical ("box");
clipName = EditorGUILayout.TextField (clipName);
if (clipList.Exists (item => item.name == clipName) || string.IsNullOrEmpty (clipName)) {
//EditorGUILayout.LabelField ("can't create duplicate name or empty");
} else {
if (GUILayout.Button ("Add Clip")) {
AddClip (clipName);
clipName = string.Empty;
RefleshClipList (controller);
Repaint ();
}
}
EditorGUILayout.EndVertical ();
if (clipList.Count == 0)
return;
EditorGUILayout.Space ();
using (var scrollView = new EditorGUILayout.ScrollViewScope (scroll)) {
scroll = scrollView.scrollPosition;
EditorGUILayout.HelpBox ("clips", MessageType.None);
EditorGUILayout.BeginVertical ("box");
foreach (var removeClip in clipList.ToArray()) {
EditorGUILayout.BeginHorizontal ();
EditorGUILayout.LabelField (removeClip.name);
if (GUILayout.Button ("Remove Clip", GUILayout.Width (100))) {
RemoveClip (removeClip);
RefleshClipList (controller);
}
EditorGUILayout.EndHorizontal ();
}
EditorGUILayout.EndVertical ();
}
}
public static void BuildAnimation()
{
string imagePath = AssetDatabase.GetAssetPath(Selection.activeObject);
List <AnimationClip> clips = BatchBuildAnimationClip(imagePath, true, true);
DirectoryInfo dir = new DirectoryInfo(imagePath);
string name = dir.Name;
string path = Directory.GetParent(dir.FullName).Name + "/" + dir.Name;
string animatorPath = AnimationControllerPath + "/" + path + ".controller";
string prefabPath = PrefabPath + "/" + path + ".prefab";
//把所有的动画文件生成在一个AnimationController里
UnityEditor.Animations.AnimatorController controller = BuildAnimationController(clips, animatorPath);
string spritePath = dir.GetDirectories()[0].GetDirectories()[0].GetFiles("*.png")[0].FullName;
//最后生成程序用的Prefab文件
BuildPrefab(controller, name, prefabPath, spritePath);
}
public AnimationControlParamter GetAnimationParamter(string animationName)
{
AnimationControlParamter paramter = new AnimationControlParamter();
AnimationClip[] clips = animator.runtimeAnimatorController.animationClips;
for (int i = 0; i < clips.Length; i++)
{
if (clips[i].name == animationName)
{
if (clips[i].wrapMode == WrapMode.Loop)
{
paramter.bLoop = true;
}
else
{
paramter.bLoop = false;
}
break;
}
}
#if UNITY_EDITOR
UnityEditor.Animations.AnimatorController ac = animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
//获取状态机
UnityEditor.Animations.AnimatorStateMachine asm = ac.layers[0].stateMachine;
for (int i = 0; i < asm.states.Length; i++)
{
UnityEditor.Animations.ChildAnimatorState cs = asm.states[i];
if (cs.state.name == animationName)
{
paramter.timeScale = cs.state.speed;
break;
}
}
#endif
return(paramter);
}
/// <summary>
/// Gets the name of the animation state.
/// </summary>
/// <returns>The animation state name.</returns>
/// <param name="_animator">Animator.</param>
/// <param name="_name">Name.</param>
public static string GetAnimatorStateName(Animator _animator, string _name)
{
if (string.IsNullOrEmpty(_name) || _animator == null || _animator.runtimeAnimatorController == null)
{
return("");
}
#if UNITY_EDITOR
UnityEditor.Animations.AnimatorController _controller = _animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
foreach (UnityEditor.Animations.AnimatorControllerLayer _layer in _controller.layers)
{
UnityEditor.Animations.AnimatorStateMachine _state_machine = _layer.stateMachine;
foreach (UnityEditor.Animations.ChildAnimatorState _state in _state_machine.states)
{
if (_state.state != null && _state.state.motion != null && _state.state.motion.name == _name)
{
return(_state.state.name);
}
}
}
#endif
return("");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUI.BeginDisabledGroup(true);
script = (MonoScript)EditorGUILayout.ObjectField("Script", script, typeof(MonoScript), false);
EditorGUI.EndDisabledGroup();
SetOnInspectorGUI();
Animator anim = M.GetComponent <Animator>();
UnityEditor.Animations.AnimatorController controller = null;
if (anim)
{
controller = (UnityEditor.Animations.AnimatorController)anim.runtimeAnimatorController;
}
if (controller)
{
List <UnityEditor.Animations.AnimatorControllerLayer> layers = controller.layers.ToList();
if (layers.Find(layer => layer.name == "Mounted") == null)
//if (anim.GetLayerIndex("Mounted") == -1)
{
if (GUILayout.Button(new GUIContent("Add Mounted Layer", "Used this to add the Parameters and 'Mounted' Layer from the Mounted Animator to your custom TCP animator ")))
{
AddLayerMounted(controller);
}
}
}
serializedObject.ApplyModifiedProperties();
}
/// <summary>
/// Generates the code necessary to recreate the states/transitions that are affected by the ability.
/// </summary>
/// <param name="ability">The ability to generate the states/transitions for.</param>
/// <param name="animatorController">The Animator Controller to generate the states/transitions from.</param>
/// <param name="firstPersonAnimatorController">The first person Animator Controller to generate the states/transitions from.</param>
/// <param name="baseDirectory">The directory that the scripts are located.</param>
/// <returns>The file path of the generated code.</returns>
public string GenerateAnimatorCode(Ability ability, UnityEditor.Animations.AnimatorController animatorController, UnityEditor.Animations.AnimatorController firstPersonAnimatorController, string baseDirectory)
{
return(AnimatorBuilder.GenerateAnimatorCode(animatorController, firstPersonAnimatorController, "AbilityIndex", ability.AbilityIndexParameter, ability, baseDirectory));
}
public static void ReloadMecanimController(ActorBaseComponent actorComponent, UnityEditor.Animations.AnimatorController animatorController)
{
Nima.Actor actor = actorComponent.Asset.Actor;
string path = AssetDatabase.GetAssetPath(animatorController);
UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(path);
List <Nima.Animation.ActorAnimation> alreadyUsedAnimations = new List <Nima.Animation.ActorAnimation>();
foreach (UnityEngine.Object asset in assets)
{
AnimationClip clip = asset as AnimationClip;
if (clip == null)
{
continue;
}
bool exists = false;
foreach (Nima.Animation.ActorAnimation actorAnimation in actor.Animations)
{
if (actorAnimation.Name == clip.name)
{
exists = true;
alreadyUsedAnimations.Add(actorAnimation);
clip.SetCurve("", typeof(GameObject), "null", AnimationCurve.Linear(0, 0, actorAnimation.Duration, 0));
AnimationClipSettings clipSettings = AnimationUtility.GetAnimationClipSettings(clip);
clipSettings.stopTime = actorAnimation.Duration;
clipSettings.loopTime = actorAnimation.IsLooping;
AnimationUtility.SetAnimationClipSettings(clip, clipSettings);
EditorUtility.SetDirty(clip);
break;
}
}
if (!exists)
{
AnimationClip.DestroyImmediate(clip, true);
}
}
foreach (Nima.Animation.ActorAnimation actorAnimation in actor.Animations)
{
int idx = alreadyUsedAnimations.IndexOf(actorAnimation);
if (idx == -1)
{
AnimationClip animationClip = new AnimationClip();
animationClip.name = actorAnimation.Name;
animationClip.SetCurve("", typeof(GameObject), "null", AnimationCurve.Linear(0, 0, actorAnimation.Duration, 0));
AnimationClipSettings clipSettings = AnimationUtility.GetAnimationClipSettings(animationClip);
clipSettings.stopTime = actorAnimation.Duration;
clipSettings.loopTime = actorAnimation.IsLooping;
AnimationUtility.SetAnimationClipSettings(animationClip, clipSettings);
AssetDatabase.AddObjectToAsset(animationClip, animatorController);
EditorUtility.SetDirty(animationClip);
}
}
EditorUtility.SetDirty(animatorController);
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
}
/// <summary>
/// New way to create sub-state machines without destroying what exists first.
/// </summary>
protected override void CreateStateMachine()
{
int rLayerIndex = mMotionLayer._AnimatorLayerIndex;
MotionController rMotionController = mMotionController;
UnityEditor.Animations.AnimatorController lController = null;
Animator lAnimator = rMotionController.Animator;
if (lAnimator == null)
{
lAnimator = rMotionController.gameObject.GetComponent <Animator>();
}
if (lAnimator != null)
{
lController = lAnimator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
}
if (lController == null)
{
return;
}
while (lController.layers.Length <= rLayerIndex)
{
UnityEditor.Animations.AnimatorControllerLayer lNewLayer = new UnityEditor.Animations.AnimatorControllerLayer();
lNewLayer.name = "Layer " + (lController.layers.Length + 1);
lNewLayer.stateMachine = new UnityEditor.Animations.AnimatorStateMachine();
lController.AddLayer(lNewLayer);
}
UnityEditor.Animations.AnimatorControllerLayer lLayer = lController.layers[rLayerIndex];
UnityEditor.Animations.AnimatorStateMachine lLayerStateMachine = lLayer.stateMachine;
UnityEditor.Animations.AnimatorStateMachine lSSM_N1556694 = MotionControllerMotion.EditorFindSSM(lLayerStateMachine, "BasicInteraction-SM");
if (lSSM_N1556694 == null)
{
lSSM_N1556694 = lLayerStateMachine.AddStateMachine("BasicInteraction-SM", new Vector3(408, -960, 0));
}
UnityEditor.Animations.AnimatorState lState_N1565974 = MotionControllerMotion.EditorFindState(lSSM_N1556694, "Idle_GrabHighFront");
if (lState_N1565974 == null)
{
lState_N1565974 = lSSM_N1556694.AddState("Idle_GrabHighFront", new Vector3(337, 54, 0));
}
lState_N1565974.speed = 1.5f;
lState_N1565974.mirror = false;
lState_N1565974.tag = "";
lState_N1565974.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/MotionController/Content/Animations/Humanoid/Interacting/Unity_IdleGrab_FrontHigh.fbx", "Idle_GrabHighFront");
UnityEditor.Animations.AnimatorState lState_N1566382 = MotionControllerMotion.EditorFindState(lSSM_N1556694, "Idle_PickUp");
if (lState_N1566382 == null)
{
lState_N1566382 = lSSM_N1556694.AddState("Idle_PickUp", new Vector3(336, 168, 0));
}
lState_N1566382.speed = 1.5f;
lState_N1566382.mirror = false;
lState_N1566382.tag = "";
lState_N1566382.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/MotionController/Content/Animations/Humanoid/Interacting/unity_IdleGrab_LowFront.fbx", "Idle_PickUp");
UnityEditor.Animations.AnimatorState lState_N1567060 = MotionControllerMotion.EditorFindState(lSSM_N1556694, "Idle_PushButton");
if (lState_N1567060 == null)
{
lState_N1567060 = lSSM_N1556694.AddState("Idle_PushButton", new Vector3(336, -48, 0));
}
lState_N1567060.speed = 1.5f;
lState_N1567060.mirror = false;
lState_N1567060.tag = "";
lState_N1567060.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/MotionController/Content/Animations/Humanoid/Interacting/unity_IdleGrab_Neutral.fbx", "Idle_PushButton");
UnityEditor.Animations.AnimatorState lState_N1568354 = MotionControllerMotion.EditorFindState(lSSM_N1556694, "IdlePose");
if (lState_N1568354 == null)
{
lState_N1568354 = lSSM_N1556694.AddState("IdlePose", new Vector3(600, 48, 0));
}
lState_N1568354.speed = 1f;
lState_N1568354.mirror = false;
lState_N1568354.tag = "Exit";
lState_N1568354.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/MotionController/Content/Animations/Humanoid/Idling/unity_Idle_IdleToIdlesR.fbx", "IdlePose");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N1573638 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N1567060, 0);
if (lAnyTransition_N1573638 == null)
{
lAnyTransition_N1573638 = lLayerStateMachine.AddAnyStateTransition(lState_N1567060);
}
lAnyTransition_N1573638.isExit = false;
lAnyTransition_N1573638.hasExitTime = false;
lAnyTransition_N1573638.hasFixedDuration = true;
lAnyTransition_N1573638.exitTime = 0.75f;
lAnyTransition_N1573638.duration = 0.25f;
lAnyTransition_N1573638.offset = 0.1517324f;
lAnyTransition_N1573638.mute = false;
lAnyTransition_N1573638.solo = false;
lAnyTransition_N1573638.canTransitionToSelf = true;
lAnyTransition_N1573638.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N1573638.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N1573638.RemoveCondition(lAnyTransition_N1573638.conditions[i]);
}
lAnyTransition_N1573638.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3450f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N1573638.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 0f, "L" + rLayerIndex + "MotionForm");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N1574214 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N1565974, 0);
if (lAnyTransition_N1574214 == null)
{
lAnyTransition_N1574214 = lLayerStateMachine.AddAnyStateTransition(lState_N1565974);
}
lAnyTransition_N1574214.isExit = false;
lAnyTransition_N1574214.hasExitTime = false;
lAnyTransition_N1574214.hasFixedDuration = true;
lAnyTransition_N1574214.exitTime = 0.75f;
lAnyTransition_N1574214.duration = 0.25f;
lAnyTransition_N1574214.offset = 0.07021895f;
lAnyTransition_N1574214.mute = false;
lAnyTransition_N1574214.solo = false;
lAnyTransition_N1574214.canTransitionToSelf = true;
lAnyTransition_N1574214.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N1574214.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N1574214.RemoveCondition(lAnyTransition_N1574214.conditions[i]);
}
lAnyTransition_N1574214.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3450f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N1574214.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 1f, "L" + rLayerIndex + "MotionForm");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N1574786 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N1566382, 0);
if (lAnyTransition_N1574786 == null)
{
lAnyTransition_N1574786 = lLayerStateMachine.AddAnyStateTransition(lState_N1566382);
}
lAnyTransition_N1574786.isExit = false;
lAnyTransition_N1574786.hasExitTime = false;
lAnyTransition_N1574786.hasFixedDuration = true;
lAnyTransition_N1574786.exitTime = 0.75f;
lAnyTransition_N1574786.duration = 0.25f;
lAnyTransition_N1574786.offset = 0f;
lAnyTransition_N1574786.mute = false;
lAnyTransition_N1574786.solo = false;
lAnyTransition_N1574786.canTransitionToSelf = true;
lAnyTransition_N1574786.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N1574786.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N1574786.RemoveCondition(lAnyTransition_N1574786.conditions[i]);
}
lAnyTransition_N1574786.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3450f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N1574786.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 2f, "L" + rLayerIndex + "MotionForm");
UnityEditor.Animations.AnimatorStateTransition lTransition_N1569370 = MotionControllerMotion.EditorFindTransition(lState_N1565974, lState_N1568354, 0);
if (lTransition_N1569370 == null)
{
lTransition_N1569370 = lState_N1565974.AddTransition(lState_N1568354);
}
lTransition_N1569370.isExit = false;
lTransition_N1569370.hasExitTime = true;
lTransition_N1569370.hasFixedDuration = true;
lTransition_N1569370.exitTime = 0.9285715f;
lTransition_N1569370.duration = 0.25f;
lTransition_N1569370.offset = 0f;
lTransition_N1569370.mute = false;
lTransition_N1569370.solo = false;
lTransition_N1569370.canTransitionToSelf = true;
lTransition_N1569370.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lTransition_N1569370.conditions.Length - 1; i >= 0; i--)
{
lTransition_N1569370.RemoveCondition(lTransition_N1569370.conditions[i]);
}
UnityEditor.Animations.AnimatorStateTransition lTransition_N1569788 = MotionControllerMotion.EditorFindTransition(lState_N1566382, lState_N1568354, 0);
if (lTransition_N1569788 == null)
{
lTransition_N1569788 = lState_N1566382.AddTransition(lState_N1568354);
}
lTransition_N1569788.isExit = false;
lTransition_N1569788.hasExitTime = true;
lTransition_N1569788.hasFixedDuration = true;
lTransition_N1569788.exitTime = 0.90625f;
lTransition_N1569788.duration = 0.25f;
lTransition_N1569788.offset = 0f;
lTransition_N1569788.mute = false;
lTransition_N1569788.solo = false;
lTransition_N1569788.canTransitionToSelf = true;
lTransition_N1569788.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lTransition_N1569788.conditions.Length - 1; i >= 0; i--)
{
lTransition_N1569788.RemoveCondition(lTransition_N1569788.conditions[i]);
}
UnityEditor.Animations.AnimatorStateTransition lTransition_N1569000 = MotionControllerMotion.EditorFindTransition(lState_N1567060, lState_N1568354, 0);
if (lTransition_N1569000 == null)
{
lTransition_N1569000 = lState_N1567060.AddTransition(lState_N1568354);
}
lTransition_N1569000.isExit = false;
lTransition_N1569000.hasExitTime = true;
lTransition_N1569000.hasFixedDuration = true;
lTransition_N1569000.exitTime = 0.7673402f;
lTransition_N1569000.duration = 0.2499998f;
lTransition_N1569000.offset = 0f;
lTransition_N1569000.mute = false;
lTransition_N1569000.solo = false;
lTransition_N1569000.canTransitionToSelf = true;
lTransition_N1569000.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lTransition_N1569000.conditions.Length - 1; i >= 0; i--)
{
lTransition_N1569000.RemoveCondition(lTransition_N1569000.conditions[i]);
}
// Run any post processing after creating the state machine
OnStateMachineCreated();
}
public override void OnInspectorGUI()
{
//return;
//base.OnInspectorGUI();
apPortrait targetPortrait = target as apPortrait;
if (targetPortrait != _targetPortrait)
{
_targetPortrait = targetPortrait;
Init();
}
if (_targetPortrait == null)
{
//Profiler.EndSample();
return;
}
//Profiler.BeginSample("anyPortrait Inspector GUI");
//return;
if (apEditor.IsOpen())
{
//에디터가 작동중에는 안보이도록 하자
EditorGUILayout.LabelField("Editor is opened");
//Profiler.EndSample();
return;
}
try
{
bool request_OpenEditor = false;
bool request_QuickBake = false;
bool request_RefreshMeshes = false;
bool prevImportant = _targetPortrait._isImportant;
MonoBehaviour prevAnimEventListener = _targetPortrait._optAnimEventListener;
int prevSortingLayerID = _targetPortrait._sortingLayerID;
int prevSortingOrder = _targetPortrait._sortingOrder;
if (!EditorApplication.isPlaying)
{
if (!_targetPortrait._isOptimizedPortrait)
{
GUILayout.Space(10);
if (GUILayout.Button("Open Editor and Select", GUILayout.Height(30)))
{
request_OpenEditor = true;
}
if (GUILayout.Button("Quick Bake", GUILayout.Height(25)))
{
request_QuickBake = true;
}
}
else
{
GUILayout.Space(10);
if (GUILayout.Button("Open Editor (Not Selectable)", GUILayout.Height(30)))
{
//열기만 하고 선택은 못함
request_OpenEditor = true;
}
}
//추가 12.18 : Mesh를 리프레시 하자
if (GUILayout.Button("Refresh Meshes", GUILayout.Height(25)))
{
request_RefreshMeshes = true;
}
}
GUILayout.Space(10);
_targetPortrait._isImportant = EditorGUILayout.Toggle("Is Important", _targetPortrait._isImportant);
_targetPortrait._optAnimEventListener = (MonoBehaviour)EditorGUILayout.ObjectField("Event Listener", _targetPortrait._optAnimEventListener, typeof(MonoBehaviour), true);
GUILayout.Space(5);
//추가3.22
//Sorting Layer
string[] sortingLayerName = new string[SortingLayer.layers.Length];
int layerIndex = -1;
for (int i = 0; i < SortingLayer.layers.Length; i++)
{
sortingLayerName[i] = SortingLayer.layers[i].name;
if (SortingLayer.layers[i].id == _targetPortrait._sortingLayerID)
{
layerIndex = i;
}
}
int nextLayerIndex = EditorGUILayout.Popup("Sorting Layer", layerIndex, sortingLayerName);
int nextLayerOrder = EditorGUILayout.IntField("Sorting Order", _targetPortrait._sortingOrder);
if (nextLayerIndex != layerIndex)
{
//Sorting Layer를 바꾸자
if (nextLayerIndex >= 0 && nextLayerIndex < SortingLayer.layers.Length)
{
string nextLayerName = SortingLayer.layers[nextLayerIndex].name;
_targetPortrait.SetSortingLayer(nextLayerName);
}
}
if (nextLayerOrder != _targetPortrait._sortingOrder)
{
_targetPortrait.SetSortingOrder(nextLayerOrder);
}
if (prevImportant != _targetPortrait._isImportant ||
prevAnimEventListener != _targetPortrait._optAnimEventListener ||
prevSortingLayerID != _targetPortrait._sortingLayerID ||
prevSortingOrder != _targetPortrait._sortingOrder)
{
apEditorUtil.SetEditorDirty();
}
GUILayout.Space(5);
//빌보드
apPortrait.BILLBOARD_TYPE nextBillboard = (apPortrait.BILLBOARD_TYPE)EditorGUILayout.EnumPopup("Billboard Type", _targetPortrait._billboardType);
if (nextBillboard != _targetPortrait._billboardType)
{
_targetPortrait._billboardType = nextBillboard;
apEditorUtil.SetEditorDirty();
}
GUILayout.Space(5);
_isFold_RootPortraits = EditorGUILayout.Foldout(_isFold_RootPortraits, "Root Portraits");
if (_isFold_RootPortraits)
{
string strRootPortrait = "";
if (_targetPortrait._optRootUnitList.Count == 0)
{
strRootPortrait = "No Baked Portrait";
}
else if (_targetPortrait._optRootUnitList.Count == 1)
{
strRootPortrait = "1 Baked Portrait";
}
else
{
strRootPortrait = _targetPortrait._optRootUnitList.Count + " Baked Portraits";
}
EditorGUILayout.LabelField(strRootPortrait);
GUILayout.Space(5);
for (int i = 0; i < _targetPortrait._optRootUnitList.Count; i++)
{
apOptRootUnit rootUnit = _targetPortrait._optRootUnitList[i];
EditorGUILayout.ObjectField("[" + i + "]", rootUnit, typeof(apOptRootUnit), true);
}
GUILayout.Space(20);
}
_isFold_AnimationClips = EditorGUILayout.Foldout(_isFold_AnimationClips, "Animation Settings");
if (_isFold_AnimationClips)
{
EditorGUILayout.LabelField("Animation Clips");
string strAnimClips = "";
if (_targetPortrait._animClips.Count == 0)
{
strAnimClips = "No Animation Clip";
}
else if (_targetPortrait._animClips.Count == 1)
{
strAnimClips = "1 Animation Clip";
}
else
{
strAnimClips = _targetPortrait._animClips.Count + " Animation Clips";
}
EditorGUILayout.LabelField(strAnimClips);
GUILayout.Space(5);
for (int i = 0; i < _targetPortrait._animClips.Count; i++)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(5);
apAnimClip animClip = _targetPortrait._animClips[i];
if (animClip._uniqueID == _targetPortrait._autoPlayAnimClipID)
{
EditorGUILayout.LabelField("[" + i + "] (Auto)", GUILayout.Width(80));
}
else
{
EditorGUILayout.LabelField("[" + i + "]", GUILayout.Width(80));
}
EditorGUILayout.TextField(animClip._name);
try
{
AnimationClip nextAnimationClip = EditorGUILayout.ObjectField(animClip._animationClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
if (nextAnimationClip != animClip._animationClipForMecanim)
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");
animClip._animationClipForMecanim = nextAnimationClip;
}
}
catch (Exception)
{ }
EditorGUILayout.EndHorizontal();
}
GUILayout.Space(10);
AnimationClip nextEmptyAnimClip = EditorGUILayout.ObjectField("Empty Animation Clip", _targetPortrait._emptyAnimClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
if (nextEmptyAnimClip != _targetPortrait._emptyAnimClipForMecanim)
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");
_targetPortrait._emptyAnimClipForMecanim = nextEmptyAnimClip;
}
GUILayout.Space(10);
EditorGUILayout.LabelField("Mecanim Settings");
bool isNextUsingMecanim = EditorGUILayout.Toggle("Use Mecanim", _targetPortrait._isUsingMecanim);
if (_targetPortrait._isUsingMecanim != isNextUsingMecanim)
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");
_targetPortrait._isUsingMecanim = isNextUsingMecanim;
}
if (_targetPortrait._isUsingMecanim)
{
GUILayout.Space(10);
try
{
Animator nextAnimator = EditorGUILayout.ObjectField("Animator", _targetPortrait._animator, typeof(Animator), true) as Animator;
if (nextAnimator != _targetPortrait._animator)
{
//하위에 있는 Component일 때에만 변동 가능
if (nextAnimator == null)
{
_targetPortrait._animator = null;
}
else
{
if (nextAnimator == _targetPortrait.GetComponent <Animator>())
{
_targetPortrait._animator = nextAnimator;
}
else
{
EditorUtility.DisplayDialog("Invalid Animator", "Invalid Animator. Only the Animator, which is its own component, is valid.", "Okay");
}
}
}
}
catch (Exception)
{
}
if (_targetPortrait._animator == null)
{
//1. Animator가 없다면
// > 생성하기
// > 생성되어 있다면 다시 링크
GUIStyle guiStyle_WarningText = new GUIStyle(GUI.skin.label);
guiStyle_WarningText.normal.textColor = Color.red;
EditorGUILayout.LabelField("Warning : No Animator!", guiStyle_WarningText);
GUILayout.Space(5);
if (GUILayout.Button("Add / Check Animator", GUILayout.Height(25)))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");
Animator animator = _targetPortrait.gameObject.GetComponent <Animator>();
if (animator == null)
{
animator = _targetPortrait.gameObject.AddComponent <Animator>();
}
_targetPortrait._animator = animator;
}
}
else
{
//2. Animator가 있다면
if (GUILayout.Button("Refresh Layers", GUILayout.Height(25)))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");
//Animator의 Controller가 있는지 체크해야한다.
if (_targetPortrait._animator.runtimeAnimatorController == null)
{
//AnimatorController가 없다면 Layer는 초기화
_targetPortrait._animatorLayerBakedData.Clear();
}
else
{
//AnimatorController가 있다면 레이어에 맞게 설정
_targetPortrait._animatorLayerBakedData.Clear();
UnityEditor.Animations.AnimatorController animatorController = _targetPortrait._animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
if (animatorController != null && animatorController.layers.Length > 0)
{
for (int iLayer = 0; iLayer < animatorController.layers.Length; iLayer++)
{
apAnimMecanimData_Layer newLayerData = new apAnimMecanimData_Layer();
newLayerData._layerIndex = iLayer;
newLayerData._layerName = animatorController.layers[iLayer].name;
newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Unknown;
switch (animatorController.layers[iLayer].blendingMode)
{
case UnityEditor.Animations.AnimatorLayerBlendingMode.Override:
newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Override;
break;
case UnityEditor.Animations.AnimatorLayerBlendingMode.Additive:
newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Additive;
break;
}
_targetPortrait._animatorLayerBakedData.Add(newLayerData);
}
}
}
}
GUILayout.Space(5);
EditorGUILayout.LabelField("Animator Controller Layers");
for (int i = 0; i < _targetPortrait._animatorLayerBakedData.Count; i++)
{
apAnimMecanimData_Layer layer = _targetPortrait._animatorLayerBakedData[i];
EditorGUILayout.BeginHorizontal();
GUILayout.Space(5);
EditorGUILayout.LabelField("[" + layer._layerIndex + "]", GUILayout.Width(50));
EditorGUILayout.TextField(layer._layerName);
apAnimMecanimData_Layer.MecanimLayerBlendType nextBlendType = (apAnimMecanimData_Layer.MecanimLayerBlendType)EditorGUILayout.EnumPopup(layer._blendType);
EditorGUILayout.EndHorizontal();
if (nextBlendType != layer._blendType)
{
UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
Undo.IncrementCurrentGroup();
Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");
_targetPortrait._animatorLayerBakedData[i]._blendType = nextBlendType;
}
}
}
}
GUILayout.Space(20);
}
bool isChanged = false;
_isFold_ConrolParameters = EditorGUILayout.Foldout(_isFold_ConrolParameters, "Control Parameters");
if (_isFold_ConrolParameters)
{
#if UNITY_2017_3_OR_NEWER
_curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumFlagsField(new GUIContent("Category"), _curControlCategory);
#else
_curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumMaskPopup(new GUIContent("Category"), _curControlCategory);
#endif
EditorGUILayout.Space();
//1. 컨르롤러를 제어할 수 있도록 하자
if (_controlParams != null)
{
for (int i = 0; i < _controlParams.Count; i++)
{
if ((int)(_controlParams[i]._category & _curControlCategory) != 0)
{
if (GUI_ControlParam(_controlParams[i]))
{
isChanged = true;
}
}
}
}
GUILayout.Space(20);
}
GUILayout.Space(10);
//2. 토글 버튼을 두어서 기본 Inspector 출력 여부를 결정하자.
string strBaseButton = "Show All Properties";
if (_showBaseInspector)
{
strBaseButton = "Hide Properties";
}
if (GUILayout.Button(strBaseButton, GUILayout.Height(20)))
{
_showBaseInspector = !_showBaseInspector;
}
if (_showBaseInspector)
{
base.OnInspectorGUI();
}
if (!Application.isPlaying && isChanged)
{
//플레이 중이라면 자동으로 업데이트 될 것이다.
_targetPortrait.UpdateForce();
}
if (_targetPortrait != null)
{
if (request_OpenEditor)
{
if (_targetPortrait._isOptimizedPortrait)
{
RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.Open);
}
else
{
RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.OpenAndSet);
}
//apEditor anyPortraitEditor = apEditor.ShowWindow();
//if (anyPortraitEditor != null && !_targetPortrait._isOptimizedPortrait)
//{
// anyPortraitEditor.SetPortraitByInspector(_targetPortrait, false);
//}
}
else if (request_QuickBake)
{
RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.QuickBake);
//apEditor anyPortraitEditor = apEditor.ShowWindow();
//if (anyPortraitEditor != null)
//{
// anyPortraitEditor.SetPortraitByInspector(_targetPortrait, true);
// Selection.activeObject = _targetPortrait.gameObject;
//}
}
else if (request_RefreshMeshes)
{
_targetPortrait.OnMeshResetInEditor();
}
}
}
catch (Exception ex)
{
Debug.LogError("apInspector_Portrait Exception : " + ex);
}
//Profiler.EndSample();
}
/////////////////////////// OnGUI ////////////////////////
/// <summary>
/// Raises the GU event.
/// </summary>
void OnGUI ()
{
int numLayers;
int numStates;
int i = 0;
int j = 0;
UnityEditor.Animations.AnimatorStateMachine stateMachine;
UnityEditor.Animations.AnimatorState state;
UnityEditor.Animations.AnimatorControllerLayer layer;
UnityEditor.Animations.AnimatorController ac;
if (_deleteStateWithHash != 0) {
_stateInputCombinations.Remove (_deleteStateWithHash);
_deleteStateWithHash = 0;
}
if (_spaceDesignator != null) {
EditorGUILayout.LabelField ("Settings");
EditorGUILayout.Separator ();
////// MAX NUM COMBOS /////
maxCombosNum = EditorGUILayout.IntField ("Combos per input:", maxCombosNum, _settingsStyle);
EditorGUILayout.Separator ();
////// DESIGNATORS /////
EditorGUILayout.LabelField ("Click Designators");
///////// DOUBLE ////////////
_doubleClickDesignator = EditorGUILayout.TextField ("Double click designator", _doubleClickDesignator, _settingsStyle);
InputManager.Settings.doubleDesignator = _doubleClickDesignator.Length > 0 ? _doubleClickDesignator : _prevlongClickDesignator;
if (_prevdoubleClickDesignator != null && _doubleClickDesignator.Length > 0 && _prevdoubleClickDesignator != _doubleClickDesignator) {
replaceDesignator (_prevdoubleClickDesignator, _doubleClickDesignator);
}
_prevdoubleClickDesignator = _doubleClickDesignator;
////////////// LONG //////////
_longClickDesignator = EditorGUILayout.TextField ("Long click designator", _longClickDesignator, _settingsStyle);
InputManager.Settings.longDesignator = _longClickDesignator.Length > 0 ? _longClickDesignator : _prevlongClickDesignator;
if (_prevlongClickDesignator != null && _longClickDesignator.Length > 0 && _prevlongClickDesignator != _longClickDesignator) {
replaceDesignator (_prevlongClickDesignator, _longClickDesignator);
}
_prevlongClickDesignator = _longClickDesignator;
///////////// SPACE /////////////
_spaceDesignator = EditorGUILayout.TextField ("Combination separator", _spaceDesignator, _settingsStyle);
if (_spaceDesignator.Length > 1)
_spaceDesignator = _spaceDesignator [0].ToString ();//restrict to 1 char
InputManager.Settings.spaceDesignator = _spaceDesignator.Length > 0 ? _spaceDesignator : _prevSpaceDesinator.ToString ();
if (_spaceDesignator.Length > 0 && _prevSpaceDesinator != _spaceDesignator [0]) {
replaceDesignator (_prevSpaceDesinator.ToString (), _spaceDesignator [0].ToString ());
}
_prevSpaceDesinator = _spaceDesignator [0];
EditorGUILayout.Separator ();
///// SENSITIVITY ////
EditorGUILayout.LabelField ("Sensitivity");
InputManager.Settings.singleClickSensitivity = _singleClickSensitivity = EditorGUILayout.FloatField ("Single click sensitivity", _singleClickSensitivity, _settingsStyle);
InputManager.Settings.doubleClickSensitivity = _doubleClickSensitivity = EditorGUILayout.FloatField ("Double click sensitivity", _doubleClickSensitivity, _settingsStyle);
InputManager.Settings.longClickSensitivity = _longClickSensitivity = EditorGUILayout.FloatField ("Long click sensitivity", _longClickSensitivity, _settingsStyle);
InputManager.Settings.combinationsClickSensitivity = _combosClickSensitivity = EditorGUILayout.FloatField ("Combos click sensitivity", _combosClickSensitivity, _settingsStyle);
EditorGUILayout.Separator ();
//////////// PLAYERS //////////////
EditorGUILayout.BeginHorizontal ();
InputPlayer player = null;
_playerNumber = EditorGUILayout.IntField ("Number of Players", _playerNumber);
if (_playerNumber < 1)
_playerNumber = 1;
//create Players
if (settings.Players == null || _playerNumber != settings.Players.Length) {
InputPlayer[] players = new InputPlayer[_playerNumber];
for (i=0; i<_playerNumber; i++) {
//don't delete previous players just add new
if (settings.Players != null && settings.Players.Length > i)
players [i] = settings.Players [i];
else
players [i] = new InputPlayer ();
}
settings.Players = players;
//set last player as current
_playerIndexSelected = _playerNumber - 1;
//reset profile to default
_profileSelectedIndex = 0;
}
//create player display options
if (_playerDisplayOptions == null || _playerNumber != _playerDisplayOptions.Length) {
_playerDisplayOptions = new string [_playerNumber];
for (i=0; i<_playerNumber; i++) {
_playerDisplayOptions [i] = "Player" + i;
}
}
_playerIndexSelected = EditorGUILayout.Popup (_playerIndexSelected, _playerDisplayOptions);
if (_playerNumber > 1 && GUILayout.Button ("Clone To All")) {
if (EditorUtility.DisplayDialog ("Clone to All!",
"Are you sure to clone selected player overwriting other player's settings?", "Yes", "Cancel")) {
InputPlayer sample = settings.Players [_playerIndexSelected];
for (i = 0; i < _playerNumber; i++) {
if (i != _playerIndexSelected)
settings.Players [i] = sample.Clone ();
}
}
}
EditorGUILayout.EndHorizontal ();
//////////// Profiles /////////////
EditorGUILayout.BeginHorizontal ();
EditorGUILayout.LabelField ("Profiles");
List<IDevice> devices = InputManager.GetDevices<IDevice> ();
if (devices.Count > 0) {
List<string> pList = devices.Where (item => item.profile != null).Select (item => item.profile.Name).Distinct ().ToList ();
pList.Insert (0, "default");
_profilesDevicesDisplayOptions = pList.ToArray ();
} else {
_profileSelectedIndex = 0;
_profilesDevicesDisplayOptions = new string[] { "default" };
}
_profileSelectedIndex = EditorGUILayout.Popup (_profileSelectedIndex, _profilesDevicesDisplayOptions);
//by selecting profile we are setting Device type expectation
_deviceByProfile = devices.Where (item => item.profile != null).FirstOrDefault (item => item.profile.Name == _profilesDevicesDisplayOptions [_profileSelectedIndex]);
player = settings.Players [_playerIndexSelected];
Dictionary<int,InputState> stateInputsCurrent = null;
//init stateInput Dictionary if player numbers is increased
if (_profilesDevicesDisplayOptions.Length > _profileSelectedIndex) {
if (!player.DeviceProfileStateInputs.ContainsKey (_profilesDevicesDisplayOptions [_profileSelectedIndex])) {
player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]] = new Dictionary<int, InputState> ();
}
stateInputsCurrent = player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]];
} else {
_profileSelectedIndex = 0;
stateInputsCurrent = player.DeviceProfileStateInputs ["default"];
}
if (_profileSelectedIndex > 0) {
if (GUILayout.Button ("Clone default")
&& EditorUtility.DisplayDialog ("Clone Default!",
"Are you sure to clone Default input settings to " + _profilesDevicesDisplayOptions [_profileSelectedIndex] + " device specific settings?", "Yes", "Cancel")
) {
Dictionary<int,InputState> stateInputsDefault = player.DeviceProfileStateInputs ["default"];
foreach (var HashInputStatePair in stateInputsDefault) {
if (!stateInputsCurrent.ContainsKey (HashInputStatePair.Key))
stateInputsCurrent.Add (HashInputStatePair.Key, HashInputStatePair.Value.Clone ());
}
}
}
_stateInputCombinations = stateInputsCurrent;
EditorGUILayout.EndHorizontal ();
EditorGUILayout.Separator ();
////////// ANY/Complex Action Types(doubles,long...) /FULL AXIS Checkers ///////
EditorGUILayout.BeginHorizontal ();
// _isDeviceAny = GUILayout.Toggle (_isDeviceAny, "Any(Uncheck 4Testing Only");
_isComplexActionTypesAllowed = GUILayout.Toggle (_isComplexActionTypesAllowed, "Allow DOUBLE/LONG(HOLD)");
_isDeviceAxisPositionFull = GUILayout.Toggle (_isDeviceAxisPositionFull, "Full Axis");
EditorGUILayout.EndHorizontal ();
EditorGUILayout.Separator ();
}
/////////////// GENERATING ENUM SETTINGS ///////////
_enumSettingsFoldout = EditorGUILayout.Foldout (_enumSettingsFoldout, "States Enum Properties");
if (_enumSettingsFoldout) {
EditorGUILayout.BeginVertical ();
//settingsXML = EditorGUILayout.ObjectField (settingsXML, typeof(TextAsset), true) as TextAsset;
_namespace = EditorGUILayout.TextField ("Namespace:", _namespace);
_enumName = EditorGUILayout.TextField ("Enum:", _enumName);
_enumFileName = EditorGUILayout.TextField ("File name:", _enumFileName);
EditorGUILayout.EndVertical ();
}
EditorGUILayout.Separator ();
///////////////// XML ////////////////////
EditorGUILayout.LabelField ("Input XML/BIN");
EditorGUILayout.BeginHorizontal ();
settingsFile = EditorGUILayout.ObjectField (settingsFile, typeof(UnityEngine.Object), true);
//reload if xml changed
if (_lastSettingsFile != settingsFile) {
_settingsLoaded = false;
}
_lastSettingsFile = settingsFile;
if (_selectedStateHash == 0 && GUILayout.Button ("Open")) {
string path;
if (_isBinary)
path = EditorUtility.OpenFilePanel ("Open XML Input Settings file", "", "bin");
else
path = EditorUtility.OpenFilePanel ("Open XML Input Settings file", "", "xml");
if (path.Length > 0) {
loadAsset (path);
}
return;
}
/////////////// SAVE ////////////////////
if (_selectedStateHash == 0 && GUILayout.Button ("Save")) {
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (!Directory.Exists (Application.streamingAssetsPath)) {
Directory.CreateDirectory (Application.streamingAssetsPath);
}
if (settingsFile != null) {
string path = AssetDatabase.GetAssetPath (settingsFile);
if (Path.GetExtension (path) == ".xml") {
saveInputSettings (Path.Combine (Application.streamingAssetsPath, settingsFile.name + ".xml"));
} else {
saveInputSettings (Path.Combine (Application.streamingAssetsPath, settingsFile.name + ".bin"));
}
} else {
if (_isBinary)
saveInputSettings (EditorUtility.SaveFilePanel ("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "bin"));
else
saveInputSettings (EditorUtility.SaveFilePanel ("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "xml"));
return;
}
}
if (settingsFile == null)
_isBinary = GUILayout.Toggle (_isBinary, "Binary");
/////////// RELOAD ////////////////
if (GUILayout.Button ("Reload")) {
_settingsLoaded = false;
}
EditorGUILayout.EndHorizontal ();
EditorGUILayout.Separator ();
//loadingSettings selected thru ObjectField browser or drag and drop
if ((!_settingsLoaded && settingsFile != null)) {
_settingsLoaded=loadInputSettings (settingsFile);
}
///////// ANIMATOR CONTROLER //////////
_lastController = controller;
EditorGUILayout.LabelField ("Animator Controller States");
EditorGUILayout.BeginHorizontal ();
controller = EditorGUILayout.ObjectField (controller, typeof(UnityEditor.Animations.AnimatorController), true) as UnityEditor.Animations.AnimatorController;
EditorGUILayout.EndHorizontal ();
EditorGUILayout.Separator ();
///////// Create AnimaitonController states GUI //////////
if (controller != null) {
ac = controller as UnityEditor.Animations.AnimatorController;
numLayers = ac.layers.Length;
if (_showLayer == null || _showLayer.Length != numLayers)
_showLayer = new bool[controller.layers.Length];
for (i=0; i<numLayers; i++) {
layer = ac.layers [i];
_showLayer [i] = EditorGUILayout.Foldout (_showLayer [i], layer.name);
if (_showLayer [i]) {
stateMachine = layer.stateMachine;
numStates = stateMachine.states.Length;
scrollPosition = GUILayout.BeginScrollView (scrollPosition, false, false);
for (j=0; j<numStates; j++) {
state = stateMachine.states [j].state;
createInputStateGUI (state.name, Animator.StringToHash (state.name));
//createInputStateGUI (state.name, state.uniqueNameHash);
}
GUILayout.EndScrollView ();
}
}
EditorGUILayout.Separator ();
}
///////////////////// NEW CUSTOM STATE STATE //////////////////////
EditorGUILayout.LabelField ("Custom States");
EditorGUILayout.BeginHorizontal ();
EditorGUILayout.LabelField ("New state name:", _stateNameLabelStyle);
_newCustomStateName = EditorGUILayout.TextField (_newCustomStateName, _stateNameLabelStyle);
if (_newCustomStateName != _prevNewCustomStateName)
_warrningAddStateLabel = "";
_prevNewCustomStateName = _newCustomStateName;
if (GUILayout.Button ("+", _addRemoveButtonStyle)) {
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (_newCustomStateName != null && _newCustomStateName.Length > 0) {
int hash = Animator.StringToHash (_newCustomStateName);
if (!_stateInputCombinations.ContainsKey (hash)) {//not already there
_stateInputCombinations [hash] = new InputState (_newCustomStateName, hash);// string[]{"None","None"};
_stateInputCombinations [hash].Add (new InputCombination ("None"));
_stateInputCombinations [hash].Add (new InputCombination ("None"));
_newCustomStateName = "";//reset
} else
_warrningAddStateLabel = "Already exist!";
} else {
_warrningAddStateLabel = "Empty state name!";
}
}
GUI.color = Color.red;
EditorGUILayout.LabelField (_warrningAddStateLabel);
EditorGUILayout.EndHorizontal ();
GUI.color = Color.white;
EditorGUILayout.BeginHorizontal ();
scrollPosition2 = EditorGUILayout.BeginScrollView (scrollPosition2, false, false);
//Debug.Log ("Loop..." + _stateInputCombinations.Count+" inputmngr "+InputManager.Settings.stateInputs.Count);
if (_stateInputCombinations != null)
foreach (var KeyValuePair in _stateInputCombinations) {
if (!existInController (KeyValuePair.Key)) {
createInputStateGUI (KeyValuePair.Value.name, KeyValuePair.Key);
}
}
GUILayout.EndScrollView ();
EditorGUILayout.EndHorizontal ();
//}
//if event is of key or mouse
if (Event.current.isKey) {
if (Event.current.keyCode == KeyCode.Return) {
_selectedStateHash = 0;
_previousStateInput = null;
this.Repaint ();
} else if (Event.current.keyCode == KeyCode.Escape) {
if (_selectedStateHash != 0) {
_stateInputCombinations [_selectedStateHash].combinations [_isPrimary] = _previousStateInput;
_previousStateInput = null;
_selectedStateHash = 0;
}
}
}
if (_selectedStateHash != 0)
InputManager.processGUIEvent (Event.current);//process input from keyboard & mouses
}
/////////////////////////// OnGUI ////////////////////////
/// <summary>
/// Raises the GU event.
/// </summary>
void OnGUI()
{
int numLayers;
int numStates;
int i = 0;
int j = 0;
UnityEditor.Animations.AnimatorStateMachine stateMachine;
UnityEditor.Animations.AnimatorState state;
UnityEditor.Animations.AnimatorControllerLayer layer;
UnityEditor.Animations.AnimatorController ac;
if (_deleteStateWithHash != 0)
{
_stateInputCombinations.Remove(_deleteStateWithHash);
_deleteStateWithHash = 0;
}
if (_spaceDesignator != null)
{
EditorGUILayout.LabelField("Settings");
EditorGUILayout.Separator();
////// MAX NUM COMBOS /////
maxCombosNum = EditorGUILayout.IntField("Combos per input:", maxCombosNum, _settingsStyle);
EditorGUILayout.Separator();
////// DESIGNATORS /////
EditorGUILayout.LabelField("Click Designators");
///////// DOUBLE ////////////
_doubleClickDesignator = EditorGUILayout.TextField("Double click designator", _doubleClickDesignator, _settingsStyle);
InputManager.Settings.doubleDesignator = _doubleClickDesignator.Length > 0 ? _doubleClickDesignator : _prevlongClickDesignator;
if (_prevdoubleClickDesignator != null && _doubleClickDesignator.Length > 0 && _prevdoubleClickDesignator != _doubleClickDesignator)
{
replaceDesignator(_prevdoubleClickDesignator, _doubleClickDesignator);
}
_prevdoubleClickDesignator = _doubleClickDesignator;
////////////// LONG //////////
_longClickDesignator = EditorGUILayout.TextField("Long click designator", _longClickDesignator, _settingsStyle);
InputManager.Settings.longDesignator = _longClickDesignator.Length > 0 ? _longClickDesignator : _prevlongClickDesignator;
if (_prevlongClickDesignator != null && _longClickDesignator.Length > 0 && _prevlongClickDesignator != _longClickDesignator)
{
replaceDesignator(_prevlongClickDesignator, _longClickDesignator);
}
_prevlongClickDesignator = _longClickDesignator;
///////////// SPACE /////////////
_spaceDesignator = EditorGUILayout.TextField("Combination separator", _spaceDesignator, _settingsStyle);
if (_spaceDesignator.Length > 1)
{
_spaceDesignator = _spaceDesignator [0].ToString(); //restrict to 1 char
}
InputManager.Settings.spaceDesignator = _spaceDesignator.Length > 0 ? _spaceDesignator : _prevSpaceDesinator.ToString();
if (_spaceDesignator.Length > 0 && _prevSpaceDesinator != _spaceDesignator [0])
{
replaceDesignator(_prevSpaceDesinator.ToString(), _spaceDesignator [0].ToString());
}
_prevSpaceDesinator = _spaceDesignator [0];
EditorGUILayout.Separator();
///// SENSITIVITY ////
EditorGUILayout.LabelField("Sensitivity");
InputManager.Settings.singleClickSensitivity = _singleClickSensitivity = EditorGUILayout.FloatField("Single click sensitivity", _singleClickSensitivity, _settingsStyle);
InputManager.Settings.doubleClickSensitivity = _doubleClickSensitivity = EditorGUILayout.FloatField("Double click sensitivity", _doubleClickSensitivity, _settingsStyle);
InputManager.Settings.longClickSensitivity = _longClickSensitivity = EditorGUILayout.FloatField("Long click sensitivity", _longClickSensitivity, _settingsStyle);
InputManager.Settings.combinationsClickSensitivity = _combosClickSensitivity = EditorGUILayout.FloatField("Combos click sensitivity", _combosClickSensitivity, _settingsStyle);
EditorGUILayout.Separator();
//////////// PLAYERS //////////////
EditorGUILayout.BeginHorizontal();
InputPlayer player = null;
_playerNumber = EditorGUILayout.IntField("Number of Players", _playerNumber);
if (_playerNumber < 1)
{
_playerNumber = 1;
}
//create Players
if (settings.Players == null || _playerNumber != settings.Players.Length)
{
InputPlayer[] players = new InputPlayer[_playerNumber];
for (i = 0; i < _playerNumber; i++)
{
//don't delete previous players just add new
if (settings.Players != null && settings.Players.Length > i)
{
players [i] = settings.Players [i];
}
else
{
players [i] = new InputPlayer();
}
}
settings.Players = players;
//set last player as current
_playerIndexSelected = _playerNumber - 1;
//reset profile to default
_profileSelectedIndex = 0;
}
//create player display options
if (_playerDisplayOptions == null || _playerNumber != _playerDisplayOptions.Length)
{
_playerDisplayOptions = new string [_playerNumber];
for (i = 0; i < _playerNumber; i++)
{
_playerDisplayOptions [i] = "Player" + i;
}
}
_playerIndexSelected = EditorGUILayout.Popup(_playerIndexSelected, _playerDisplayOptions);
if (_playerNumber > 1 && GUILayout.Button("Clone To All"))
{
if (EditorUtility.DisplayDialog("Clone to All!",
"Are you sure to clone selected player overwriting other player's settings?", "Yes", "Cancel"))
{
InputPlayer sample = settings.Players [_playerIndexSelected];
for (i = 0; i < _playerNumber; i++)
{
if (i != _playerIndexSelected)
{
settings.Players [i] = sample.Clone();
}
}
}
}
EditorGUILayout.EndHorizontal();
//////////// Profiles /////////////
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Profiles");
List <IDevice> devices = InputManager.GetDevices <IDevice> ();
if (devices.Count > 0)
{
List <string> pList = devices.Where(item => item.profile != null).Select(item => item.profile.Name).Distinct().ToList();
pList.Insert(0, "default");
_profilesDevicesDisplayOptions = pList.ToArray();
}
else
{
_profileSelectedIndex = 0;
_profilesDevicesDisplayOptions = new string[] { "default" };
}
_profileSelectedIndex = EditorGUILayout.Popup(_profileSelectedIndex, _profilesDevicesDisplayOptions);
//by selecting profile we are setting Device type expectation
_deviceByProfile = devices.Where(item => item.profile != null).FirstOrDefault(item => item.profile.Name == _profilesDevicesDisplayOptions [_profileSelectedIndex]);
player = settings.Players [_playerIndexSelected];
Dictionary <int, InputState> stateInputsCurrent = null;
//init stateInput Dictionary if player numbers is increased
if (_profilesDevicesDisplayOptions.Length > _profileSelectedIndex)
{
if (!player.DeviceProfileStateInputs.ContainsKey(_profilesDevicesDisplayOptions [_profileSelectedIndex]))
{
player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]] = new Dictionary <int, InputState> ();
}
stateInputsCurrent = player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]];
}
else
{
_profileSelectedIndex = 0;
stateInputsCurrent = player.DeviceProfileStateInputs ["default"];
}
if (_profileSelectedIndex > 0)
{
if (GUILayout.Button("Clone default") &&
EditorUtility.DisplayDialog("Clone Default!",
"Are you sure to clone Default input settings to " + _profilesDevicesDisplayOptions [_profileSelectedIndex] + " device specific settings?", "Yes", "Cancel")
)
{
Dictionary <int, InputState> stateInputsDefault = player.DeviceProfileStateInputs ["default"];
foreach (var HashInputStatePair in stateInputsDefault)
{
if (!stateInputsCurrent.ContainsKey(HashInputStatePair.Key))
{
stateInputsCurrent.Add(HashInputStatePair.Key, HashInputStatePair.Value.Clone());
}
}
}
}
_stateInputCombinations = stateInputsCurrent;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
////////// ANY/Complex Action Types(doubles,long...) /FULL AXIS Checkers ///////
EditorGUILayout.BeginHorizontal();
// _isDeviceAny = GUILayout.Toggle (_isDeviceAny, "Any(Uncheck 4Testing Only");
_isComplexActionTypesAllowed = GUILayout.Toggle(_isComplexActionTypesAllowed, "Allow DOUBLE/LONG(HOLD)");
_isDeviceAxisPositionFull = GUILayout.Toggle(_isDeviceAxisPositionFull, "Full Axis");
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
}
/////////////// GENERATING ENUM SETTINGS ///////////
_enumSettingsFoldout = EditorGUILayout.Foldout(_enumSettingsFoldout, "States Enum Properties");
if (_enumSettingsFoldout)
{
EditorGUILayout.BeginVertical();
//settingsXML = EditorGUILayout.ObjectField (settingsXML, typeof(TextAsset), true) as TextAsset;
_namespace = EditorGUILayout.TextField("Namespace:", _namespace);
_enumName = EditorGUILayout.TextField("Enum:", _enumName);
_enumFileName = EditorGUILayout.TextField("File name:", _enumFileName);
EditorGUILayout.EndVertical();
}
EditorGUILayout.Separator();
///////////////// XML ////////////////////
EditorGUILayout.LabelField("Input XML/BIN");
EditorGUILayout.BeginHorizontal();
settingsFile = EditorGUILayout.ObjectField(settingsFile, typeof(UnityEngine.Object), true);
//reload if xml changed
if (_lastSettingsFile != settingsFile)
{
_settingsLoaded = false;
}
_lastSettingsFile = settingsFile;
if (_selectedStateHash == 0 && GUILayout.Button("Open"))
{
string path;
if (_isBinary)
{
path = EditorUtility.OpenFilePanel("Open XML Input Settings file", "", "bin");
}
else
{
path = EditorUtility.OpenFilePanel("Open XML Input Settings file", "", "xml");
}
if (path.Length > 0)
{
loadAsset(path);
}
return;
}
/////////////// SAVE ////////////////////
if (_selectedStateHash == 0 && GUILayout.Button("Save"))
{
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (!Directory.Exists(Application.streamingAssetsPath))
{
Directory.CreateDirectory(Application.streamingAssetsPath);
}
if (settingsFile != null)
{
string path = AssetDatabase.GetAssetPath(settingsFile);
if (Path.GetExtension(path) == ".xml")
{
saveInputSettings(Path.Combine(Application.streamingAssetsPath, settingsFile.name + ".xml"));
}
else
{
saveInputSettings(Path.Combine(Application.streamingAssetsPath, settingsFile.name + ".bin"));
}
}
else
{
if (_isBinary)
{
saveInputSettings(EditorUtility.SaveFilePanel("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "bin"));
}
else
{
saveInputSettings(EditorUtility.SaveFilePanel("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "xml"));
}
return;
}
}
if (settingsFile == null)
{
_isBinary = GUILayout.Toggle(_isBinary, "Binary");
}
/////////// RELOAD ////////////////
if (GUILayout.Button("Reload"))
{
_settingsLoaded = false;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
//loadingSettings selected thru ObjectField browser or drag and drop
if ((!_settingsLoaded && settingsFile != null))
{
_settingsLoaded = loadInputSettings(settingsFile);
}
///////// ANIMATOR CONTROLER //////////
_lastController = controller;
EditorGUILayout.LabelField("Animator Controller States");
EditorGUILayout.BeginHorizontal();
controller = EditorGUILayout.ObjectField(controller, typeof(UnityEditor.Animations.AnimatorController), true) as UnityEditor.Animations.AnimatorController;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
///////// Create AnimaitonController states GUI //////////
if (controller != null)
{
ac = controller as UnityEditor.Animations.AnimatorController;
numLayers = ac.layers.Length;
if (_showLayer == null || _showLayer.Length != numLayers)
{
_showLayer = new bool[controller.layers.Length];
}
for (i = 0; i < numLayers; i++)
{
layer = ac.layers [i];
_showLayer [i] = EditorGUILayout.Foldout(_showLayer [i], layer.name);
if (_showLayer [i])
{
stateMachine = layer.stateMachine;
numStates = stateMachine.states.Length;
scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, false);
for (j = 0; j < numStates; j++)
{
state = stateMachine.states [j].state;
createInputStateGUI(state.name, Animator.StringToHash(state.name));
//createInputStateGUI (state.name, state.uniqueNameHash);
}
GUILayout.EndScrollView();
}
}
EditorGUILayout.Separator();
}
///////////////////// NEW CUSTOM STATE STATE //////////////////////
EditorGUILayout.LabelField("Custom States");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("New state name:", _stateNameLabelStyle);
_newCustomStateName = EditorGUILayout.TextField(_newCustomStateName, _stateNameLabelStyle);
if (_newCustomStateName != _prevNewCustomStateName)
{
_warrningAddStateLabel = "";
}
_prevNewCustomStateName = _newCustomStateName;
if (GUILayout.Button("+", _addRemoveButtonStyle))
{
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (_newCustomStateName != null && _newCustomStateName.Length > 0)
{
int hash = Animator.StringToHash(_newCustomStateName);
if (!_stateInputCombinations.ContainsKey(hash)) //not already there
{
_stateInputCombinations [hash] = new InputState(_newCustomStateName, hash); // string[]{"None","None"};
_stateInputCombinations [hash].Add(new InputCombination("None"));
_stateInputCombinations [hash].Add(new InputCombination("None"));
_newCustomStateName = ""; //reset
}
else
{
_warrningAddStateLabel = "Already exist!";
}
}
else
{
_warrningAddStateLabel = "Empty state name!";
}
}
GUI.color = Color.red;
EditorGUILayout.LabelField(_warrningAddStateLabel);
EditorGUILayout.EndHorizontal();
GUI.color = Color.white;
EditorGUILayout.BeginHorizontal();
scrollPosition2 = EditorGUILayout.BeginScrollView(scrollPosition2, false, false);
//Debug.Log ("Loop..." + _stateInputCombinations.Count+" inputmngr "+InputManager.Settings.stateInputs.Count);
if (_stateInputCombinations != null)
{
foreach (var KeyValuePair in _stateInputCombinations)
{
if (!existInController(KeyValuePair.Key))
{
createInputStateGUI(KeyValuePair.Value.name, KeyValuePair.Key);
}
}
}
GUILayout.EndScrollView();
EditorGUILayout.EndHorizontal();
//}
//if event is of key or mouse
if (Event.current.isKey)
{
if (Event.current.keyCode == KeyCode.Return)
{
_selectedStateHash = 0;
_previousStateInput = null;
this.Repaint();
}
else if (Event.current.keyCode == KeyCode.Escape)
{
if (_selectedStateHash != 0)
{
_stateInputCombinations [_selectedStateHash].combinations [_isPrimary] = _previousStateInput;
_previousStateInput = null;
_selectedStateHash = 0;
}
}
}
if (_selectedStateHash != 0)
{
InputManager.processGUIEvent(Event.current); //process input from keyboard & mouses
}
}
/// <summary>
/// Draws the select field layot properties.
/// </summary>
public void DrawSelectFieldLayotProperties()
{
EditorGUILayout.LabelField("Select Field Layout", EditorStyles.boldLabel);
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_TransitionProperty, new GUIContent("Transition"));
Graphic graphic = this.m_TargetGraphicProperty.objectReferenceValue as Graphic;
Selectable.Transition transition = (Selectable.Transition) this.m_TransitionProperty.enumValueIndex;
// Check if the transition requires a graphic
if (transition == Selectable.Transition.ColorTint || transition == Selectable.Transition.SpriteSwap)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_TargetGraphicProperty);
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
// Check if we have a transition set
if (transition != Selectable.Transition.None)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
if (transition == Selectable.Transition.ColorTint)
{
if (graphic == null)
{
EditorGUILayout.HelpBox("You must have a Graphic target in order to use a color transition.", MessageType.Info);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_ColorBlockProperty, true);
if (EditorGUI.EndChangeCheck())
{
graphic.canvasRenderer.SetColor(this.m_ColorBlockProperty.FindPropertyRelative("m_NormalColor").colorValue);
}
}
}
else if (transition == Selectable.Transition.SpriteSwap)
{
if (graphic as Image == null)
{
EditorGUILayout.HelpBox("You must have a Image target in order to use a sprite swap transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.m_SpriteStateProperty, true);
}
}
else if (transition == Selectable.Transition.Animation)
{
EditorGUILayout.PropertyField(this.m_AnimTriggerProperty, true);
Animator animator = (target as UISelectField).animator;
if (animator == null || animator.runtimeAnimatorController == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = UIAnimatorControllerGenerator.GenerateAnimatorContoller(this.m_AnimTriggerProperty, target.name);
if (animatorController != null)
{
if (animator == null)
{
animator = (target as UISelectField).gameObject.AddComponent <Animator>();
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, animatorController);
}
}
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
/// <summary>
/// Draws the option background layout properties.
/// </summary>
public void DrawOptionBackgroundLayoutProperties()
{
bool newState = EditorGUILayout.Foldout(this.showOptionBackgroundLayout, "Option Background Layout", this.m_FoldoutStyle);
if (newState != this.showOptionBackgroundLayout)
{
EditorPrefs.SetBool(PREFS_KEY + "5", newState);
this.showOptionBackgroundLayout = newState;
}
if (this.showOptionBackgroundLayout)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_OptionBackgroundSpriteProperty, new GUIContent("Sprite"));
if (this.m_OptionBackgroundSpriteProperty.objectReferenceValue != null)
{
EditorGUILayout.PropertyField(this.m_OptionBackgroundSpriteTypeProperty, new GUIContent("Sprite Type"));
EditorGUILayout.PropertyField(this.m_OptionBackgroundSpriteColorProperty, new GUIContent("Sprite Color"));
EditorGUILayout.PropertyField(this.m_OptionBackgroundTransitionTypeProperty, new GUIContent("Transition"));
Selectable.Transition optionBgTransition = (Selectable.Transition) this.m_OptionBackgroundTransitionTypeProperty.enumValueIndex;
if (optionBgTransition != Selectable.Transition.None)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
if (optionBgTransition == Selectable.Transition.ColorTint)
{
EditorGUILayout.PropertyField(this.m_OptionBackgroundTransColorsProperty, true);
}
else if (optionBgTransition == Selectable.Transition.SpriteSwap)
{
EditorGUILayout.PropertyField(this.m_OptionBackgroundSpriteStatesProperty, true);
}
else if (optionBgTransition == Selectable.Transition.Animation)
{
EditorGUILayout.PropertyField(this.m_OptionBackgroundAnimatorControllerProperty, new GUIContent("Animator Controller"));
EditorGUILayout.PropertyField(this.m_OptionBackgroundAnimationTriggersProperty, true);
if (this.m_OptionBackgroundAnimatorControllerProperty.objectReferenceValue == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = UIAnimatorControllerGenerator.GenerateAnimatorContoller(this.m_OptionBackgroundAnimationTriggersProperty, target.name + " - Option Background");
// Apply the controller to the property
if (animatorController != null)
{
this.m_OptionBackgroundAnimatorControllerProperty.objectReferenceValue = animatorController;
}
}
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
EditorGUILayout.Separator();
bool newState2 = EditorGUILayout.Foldout(this.showOptionHover, "Option Hover Overlay", this.m_FoldoutStyle);
if (newState2 != this.showOptionHover)
{
EditorPrefs.SetBool(PREFS_KEY + "6", newState2);
this.showOptionHover = newState2;
}
if (this.showOptionHover)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_OptionHoverOverlayProperty, new GUIContent("Sprite"));
if (this.m_OptionHoverOverlayProperty.objectReferenceValue != null)
{
EditorGUILayout.PropertyField(this.m_OptionHoverOverlayColorBlockProperty, new GUIContent("Colors"), true);
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
EditorGUILayout.Separator();
bool newState3 = EditorGUILayout.Foldout(this.showOptionPress, "Option Press Overlay", this.m_FoldoutStyle);
if (newState3 != this.showOptionPress)
{
EditorPrefs.SetBool(PREFS_KEY + "7", newState3);
this.showOptionPress = newState3;
}
if (this.showOptionPress)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_OptionPressOverlayProperty, new GUIContent("Sprite"));
if (this.m_OptionPressOverlayProperty.objectReferenceValue != null)
{
EditorGUILayout.PropertyField(this.m_OptionPressOverlayColorBlockProperty, new GUIContent("Colors"), true);
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
}
/// <summary>
/// Draws the list layout properties.
/// </summary>
public void DrawListLayoutProperties()
{
bool newState = EditorGUILayout.Foldout(this.showListLayout, "List Layout", this.m_FoldoutStyle);
if (newState != this.showListLayout)
{
EditorPrefs.SetBool(PREFS_KEY + "2", newState);
this.showListLayout = newState;
}
if (this.showListLayout)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_ListBackgroundSpriteProperty, new GUIContent("Sprite"));
if (this.m_ListBackgroundSpriteProperty.objectReferenceValue != null)
{
EditorGUILayout.PropertyField(this.m_ListBackgroundSpriteTypeProperty, new GUIContent("Sprite Type"));
EditorGUILayout.PropertyField(this.m_ListBackgroundColorProperty, new GUIContent("Sprite Color"));
}
EditorGUILayout.PropertyField(this.m_ListMarginsProperty, new GUIContent("Margin"), true);
EditorGUILayout.PropertyField(this.m_ListPaddingProperty, new GUIContent("Padding"), true);
EditorGUILayout.PropertyField(this.m_ListSpacingProperty, new GUIContent("Spacing"), true);
EditorGUILayout.PropertyField(this.m_ListAnimationTypeProperty, new GUIContent("Transition"), true);
UISelectField.ListAnimationType animationType = (UISelectField.ListAnimationType) this.m_ListAnimationTypeProperty.enumValueIndex;
if (animationType == UISelectField.ListAnimationType.Fade)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_ListAnimationDurationProperty, new GUIContent("Duration"), true);
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
else if (animationType == UISelectField.ListAnimationType.Animation)
{
EditorGUILayout.PropertyField(this.m_ListAnimatorControllerProperty, new GUIContent("Animator Controller"));
EditorGUILayout.PropertyField(this.m_ListlistAnimationOpenTriggerProperty, new GUIContent("Open Trigger"));
EditorGUILayout.PropertyField(this.m_ListlistAnimationCloseTriggerProperty, new GUIContent("Close Trigger"));
if (this.m_ListAnimatorControllerProperty.objectReferenceValue == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Prepare the triggers list
List <string> triggers = new List <string>();
triggers.Add(!string.IsNullOrEmpty(this.m_ListlistAnimationOpenTriggerProperty.stringValue) ? this.m_ListlistAnimationOpenTriggerProperty.stringValue : "Open");
triggers.Add(!string.IsNullOrEmpty(this.m_ListlistAnimationCloseTriggerProperty.stringValue) ? this.m_ListlistAnimationCloseTriggerProperty.stringValue : "Close");
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = UIAnimatorControllerGenerator.GenerateAnimatorContoller(triggers, target.name + " - List");
// Apply the controller to the property
if (animatorController != null)
{
this.m_ListAnimatorControllerProperty.objectReferenceValue = animatorController;
}
}
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
}
/// <summary>
/// Creates a Unity sprite animation from the given <see cref="Layer"/> that is a group layer. It grabs all of the children art
/// layers and uses them as the frames of the animation.
/// </summary>
/// <param name="layer">The group <see cref="Layer"/> to use to create the sprite animation.</param>
private static void CreateAnimation(Layer layer)
{
float fps = 30;
string[] args = layer.Name.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string arg in args)
{
if (arg.ContainsIgnoreCase("FPS="))
{
layer.Name = layer.Name.Replace("|" + arg, string.Empty);
string[] fpsArgs = arg.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
if (!float.TryParse(fpsArgs[1], out fps))
{
Debug.LogError(string.Format("Unable to parse FPS: \"{0}\"", arg));
}
}
}
List<Sprite> frames = new List<Sprite>();
Layer firstChild = layer.Children.First();
SpriteRenderer spriteRenderer = CreateSpriteGameObject(firstChild);
spriteRenderer.name = layer.Name;
foreach (Layer child in layer.Children)
{
frames.Add(CreateSprite(child, layer.Name));
}
spriteRenderer.sprite = frames[0];
#if UNITY_5
// Create Animator Controller with an Animation Clip
UnityEditor.Animations.AnimatorController controller = new UnityEditor.Animations.AnimatorController();
controller.AddLayer("Base Layer");
UnityEditor.Animations.AnimatorControllerLayer controllerLayer = controller.layers[0];
UnityEditor.Animations.AnimatorState state = controllerLayer.stateMachine.AddState(layer.Name);
state.motion = CreateSpriteAnimationClip(layer.Name, frames, fps);
AssetDatabase.CreateAsset(controller, GetRelativePath(currentPath) + "/" + layer.Name + ".controller");
#else // Unity 4
// Create Animator Controller with an Animation Clip
AnimatorController controller = new AnimatorController();
AnimatorControllerLayer controllerLayer = controller.AddLayer("Base Layer");
State state = controllerLayer.stateMachine.AddState(layer.Name);
state.SetAnimationClip(CreateSpriteAnimationClip(layer.Name, frames, fps));
AssetDatabase.CreateAsset(controller, GetRelativePath(currentPath) + "/" + layer.Name + ".controller");
#endif
// Add an Animator and assign it the controller
Animator animator = spriteRenderer.gameObject.AddComponent<Animator>();
animator.runtimeAnimatorController = controller;
}
/// <summary>
/// Creates the preview state machine.
/// </summary>
/// <param name="motion">Motion.</param>
private void CreatePreviewStateMachine(Motion motion)
{
if (this.Animator == null)
return;
//Debug.Log ("CreateStateMachine");
if (_previewAnimatorController == null) {
_previewAnimatorController = new UnityEditor.Animations.AnimatorController ();
_previewAnimatorController.AddLayer ("previewLayer");
_previewAnimatorController.hideFlags = HideFlags.DontSave;
_previewStateMachine = _previewAnimatorController.layers [0].stateMachine;
CreateParameters (motion);
_previewState = _previewStateMachine.AddState ("previewState");
_previewState.motion = motion;
_previewState.iKOnFeet = this.IKOnFeet;
_previewState.hideFlags = HideFlags.DontSave;
UnityEditor.Animations.AnimatorController.SetAnimatorController (this.Animator, _previewAnimatorController);
//Debug.Log ("Setting avatarPreview.Animator " + this.Animator.name + " to temp controller");
}
// if (AnimatorController.GetEffectiveAnimatorController (this.Animator) != this._previewAnimatorController) {
// AnimatorController.SetAnimatorController (this.Animator, this._previewAnimatorController);
//
// Debug.Log ("Getting Effective Animator and set avatarPreview.Animator " + this.Animator.name + " to temp controller");
// }
}
/// <summary>
/// Clears the state machine.
/// </summary>
private void ClearPreviewStateMachine()
{
if (this.Animator != null) {
UnityEditor.Animations.AnimatorController.SetAnimatorController (this.Animator, null);
}
UnityEngine.Object.DestroyImmediate (this._previewAnimatorController);
UnityEngine.Object.DestroyImmediate (this._previewStateMachine);
UnityEngine.Object.DestroyImmediate (this._previewState);
_previewStateMachine = null;
_previewAnimatorController = null;
_previewState = null;
}
public ResId findAnimatorControllerId(UnityEditor.Animations.AnimatorController obj, Animator animator)
{
return(animatorControllers.getId(new AnimatorControllerKey(obj, animator), false));
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
UIHighlightTransition.Transition transition = (UIHighlightTransition.Transition) this.m_TransitionProperty.enumValueIndex;
Graphic graphic = this.m_TargetGraphicProperty.objectReferenceValue as Graphic;
GameObject targetGameObject = this.m_TargetGameObjectProperty.objectReferenceValue as GameObject;
EditorGUILayout.Space();
EditorGUILayout.PropertyField(this.m_TransitionProperty, new GUIContent("Transition"));
EditorGUI.indentLevel++;
// Check if the transition requires a graphic
if (transition == UIHighlightTransition.Transition.ColorTint || transition == UIHighlightTransition.Transition.SpriteSwap || transition == UIHighlightTransition.Transition.TextColor)
{
EditorGUILayout.PropertyField(this.m_TargetGraphicProperty, new GUIContent("Target Graphic"));
if (transition == UIHighlightTransition.Transition.ColorTint)
{
if (graphic == null)
{
EditorGUILayout.HelpBox("You must have a Graphic target in order to use a color transition.", MessageType.Info);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_NormalColorProperty, true);
if (EditorGUI.EndChangeCheck())
{
graphic.canvasRenderer.SetColor(this.m_NormalColorProperty.colorValue);
}
EditorGUILayout.PropertyField(this.m_PressedColorProperty, true);
EditorGUILayout.PropertyField(this.m_ColorMultiplierProperty, true);
EditorGUILayout.PropertyField(this.m_DurationProperty, true);
}
}
else if (transition == UIHighlightTransition.Transition.TextColor)
{
if ((graphic is Text) == false)
{
EditorGUILayout.HelpBox("You must have a Text target in order to use a text color transition.", MessageType.Info);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_NormalColorProperty, true);
if (EditorGUI.EndChangeCheck())
{
(graphic as Text).color = this.m_NormalColorProperty.colorValue;
}
EditorGUILayout.PropertyField(this.m_PressedColorProperty, true);
EditorGUILayout.PropertyField(this.m_DurationProperty, true);
}
}
else if (transition == UIHighlightTransition.Transition.SpriteSwap)
{
if (graphic as Image == null)
{
EditorGUILayout.HelpBox("You must have a Image target in order to use a sprite swap transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.m_PressedSpriteProperty, true);
}
}
}
else if (transition == UIHighlightTransition.Transition.Animation)
{
EditorGUILayout.PropertyField(this.m_TargetGameObjectProperty, new GUIContent("Target GameObject"));
if (targetGameObject == null)
{
EditorGUILayout.HelpBox("You must have a Game Object target in order to use a animation transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.m_NormalTriggerProperty, true);
EditorGUILayout.PropertyField(this.m_PressedTriggerProperty, true);
Animator animator = targetGameObject.GetComponent <Animator>();
if (animator == null || animator.runtimeAnimatorController == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = this.GenerateAnimatorController();
if (animatorController != null)
{
if (animator == null)
{
animator = targetGameObject.AddComponent <Animator>();
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, animatorController);
}
}
}
}
}
this.serializedObject.ApplyModifiedProperties();
}
/// <summary>
/// New way to create sub-state machines without destroying what exists first.
/// </summary>
protected override void CreateStateMachine()
{
int rLayerIndex = mMotionLayer._AnimatorLayerIndex;
MotionController rMotionController = mMotionController;
UnityEditor.Animations.AnimatorController lController = null;
Animator lAnimator = rMotionController.Animator;
if (lAnimator == null)
{
lAnimator = rMotionController.gameObject.GetComponent <Animator>();
}
if (lAnimator != null)
{
lController = lAnimator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
}
if (lController == null)
{
return;
}
while (lController.layers.Length <= rLayerIndex)
{
UnityEditor.Animations.AnimatorControllerLayer lNewLayer = new UnityEditor.Animations.AnimatorControllerLayer();
lNewLayer.name = "Layer " + (lController.layers.Length + 1);
lNewLayer.stateMachine = new UnityEditor.Animations.AnimatorStateMachine();
lController.AddLayer(lNewLayer);
}
UnityEditor.Animations.AnimatorControllerLayer lLayer = lController.layers[rLayerIndex];
UnityEditor.Animations.AnimatorStateMachine lLayerStateMachine = lLayer.stateMachine;
UnityEditor.Animations.AnimatorStateMachine lSSM_37924 = MotionControllerMotion.EditorFindSSM(lLayerStateMachine, "BasicWalkRunPivot-SM");
if (lSSM_37924 == null)
{
lSSM_37924 = lLayerStateMachine.AddStateMachine("BasicWalkRunPivot-SM", new Vector3(408, -1056, 0));
}
UnityEditor.Animations.AnimatorState lState_38400 = MotionControllerMotion.EditorFindState(lSSM_37924, "Unarmed BlendTree");
if (lState_38400 == null)
{
lState_38400 = lSSM_37924.AddState("Unarmed BlendTree", new Vector3(312, 72, 0));
}
lState_38400.speed = 1f;
lState_38400.mirror = false;
lState_38400.tag = "";
UnityEditor.Animations.BlendTree lM_25576 = MotionControllerMotion.EditorCreateBlendTree("Blend Tree", lController, rLayerIndex);
lM_25576.blendType = UnityEditor.Animations.BlendTreeType.Simple1D;
lM_25576.blendParameter = "InputMagnitude";
lM_25576.blendParameterY = "InputX";
#if !(UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3)
lM_25576.useAutomaticThresholds = false;
#endif
lM_25576.AddChild(MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/Assets/MotionController/Content/Animations/Humanoid/Idling/unity_Idle_IdleToIdlesR.fbx", "IdlePose"), 0f);
lM_25576.AddChild(MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/Assets/MotionController/Content/Animations/Humanoid/Walking/unity_WalkFWD_v2.fbx", "WalkForward"), 0.5f);
lM_25576.AddChild(MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/Assets/MotionController/Content/Animations/Humanoid/Running/RunForward_v2.fbx", "RunForward"), 1f);
lState_38400.motion = lM_25576;
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_38110 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_38400, 0);
if (lAnyTransition_38110 == null)
{
lAnyTransition_38110 = lLayerStateMachine.AddAnyStateTransition(lState_38400);
}
lAnyTransition_38110.isExit = false;
lAnyTransition_38110.hasExitTime = false;
lAnyTransition_38110.hasFixedDuration = true;
lAnyTransition_38110.exitTime = 0.75f;
lAnyTransition_38110.duration = 0.25f;
lAnyTransition_38110.offset = 0f;
lAnyTransition_38110.mute = false;
lAnyTransition_38110.solo = false;
lAnyTransition_38110.canTransitionToSelf = true;
lAnyTransition_38110.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_38110.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_38110.RemoveCondition(lAnyTransition_38110.conditions[i]);
}
lAnyTransition_38110.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3050f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_38110.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 0f, "L" + rLayerIndex + "MotionForm");
#if USE_ARCHERY_MP || OOTII_AYMP
ArcheryPackDefinition.ExtendBasicWalkRunPivot(rMotionController, rLayerIndex);
#endif
#if USE_SWORD_SHIELD_MP || OOTII_SSMP
SwordShieldPackDefinition.ExtendBasicWalkRunPivot(rMotionController, rLayerIndex);
#endif
#if USE_SPELL_CASTING_MP || OOTII_SCMP
SpellCastingPackDefinition.ExtendBasicWalkRunPivot(rMotionController, rLayerIndex);
#endif
#if USE_SHOOTER_MP || OOTII_SHMP
ShooterPackDefinition.ExtendBasicWalkRunPivot(rMotionController, rLayerIndex);
#endif
// Run any post processing after creating the state machine
OnStateMachineCreated();
}
/// <summary>
/// Draws the inspector for the pack
/// </summary>
/// <returns></returns>
public static bool OnPackInspector(MotionController rMotionController)
{
EditorHelper.DrawSmallTitle(GroupName());
EditorHelper.DrawLink("Mixamo Pro Magic Pack Animations", "http://www.ootii.com/Unity/MotionPacks/SpellCasting/SpellCastingUsersGuide.pdf");
GUILayout.Space(5f);
EditorGUILayout.LabelField("See included documentation:", EditorHelper.SmallBoldLabel);
EditorGUILayout.LabelField("1. Download and import animations.", EditorHelper.SmallLabel);
EditorGUILayout.LabelField("2. Unzip and replace animation meta files.", EditorHelper.SmallLabel);
EditorGUILayout.LabelField("3. Select options and create motions.", EditorHelper.SmallLabel);
EditorHelper.DrawLine();
EditorHelper.BoolField("Create Mecanim States", "Determines if we create/override the existing sub-state machine", sCreateSubStateMachines);
sCreateSubStateMachines = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Input Aliases", "Determines if we create input aliases", sCreateInputAliases);
sCreateInputAliases = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Inventory", "Determines if we create/override the existing inventory", sCreateInventory);
sCreateInventory = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Attributes", "Determines if we create/override the existing attributes", sCreateAttributes);
sCreateAttributes = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Spell Inventory", "Create the spell inventory for the caster", sCreateSpellInventory);
sCreateSpellInventory = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Combatant", "Determines if we create/override the existing core", sCreateCore);
sCreateCore = EditorHelper.FieldBoolValue;
EditorHelper.BoolField("Create Motions", "Determines if we create the archery motions", sCreateMotions);
sCreateMotions = EditorHelper.FieldBoolValue;
GUILayout.Space(5f);
if (GUILayout.Button(new GUIContent("Setup Pack", "Create and setup the motion pack."), EditorStyles.miniButton))
{
if (sCreateInventory)
{
BasicInventory lInventory = rMotionController.gameObject.GetComponent <BasicInventory>();
if (lInventory == null)
{
lInventory = rMotionController.gameObject.AddComponent <BasicInventory>();
}
BasicInventoryItem lItem = lInventory.GetInventoryItem("Spell_01");
if (lItem != null)
{
lInventory.Items.Remove(lItem);
}
lInventory.Items.Add(new BasicInventoryItem());
lInventory.Items[lInventory.Items.Count - 1].ID = "Spell_01";
lInventory.Items[lInventory.Items.Count - 1].EquipMotion = "PMP_EquipSpell";
lInventory.Items[lInventory.Items.Count - 1].StoreMotion = "PMP_StoreSpell";
BasicInventorySlot lSlot = lInventory.GetInventorySlot("RIGHT_HAND");
if (lSlot == null)
{
lInventory.Slots.Add(new BasicInventorySlot());
lInventory.Slots[lInventory.Slots.Count - 1].ID = "RIGHT_HAND";
lInventory.Slots[lInventory.Slots.Count - 1].ItemID = "";
}
if (lInventory.GetInventorySlot("LEFT_HAND") == null)
{
lInventory.Slots.Add(new BasicInventorySlot());
lInventory.Slots[lInventory.Slots.Count - 1].ID = "LEFT_HAND";
lInventory.Slots[lInventory.Slots.Count - 1].ItemID = "";
}
lSlot = lInventory.GetInventorySlot("LEFT_LOWER_ARM");
if (lSlot == null)
{
lInventory.Slots.Add(new BasicInventorySlot());
lInventory.Slots[lInventory.Slots.Count - 1].ID = "LEFT_LOWER_ARM";
lInventory.Slots[lInventory.Slots.Count - 1].ItemID = "";
}
if (lInventory.GetInventorySlot("READY_PROJECTILE") == null)
{
lInventory.Slots.Add(new BasicInventorySlot());
lInventory.Slots[lInventory.Slots.Count - 1].ID = "READY_PROJECTILE";
lInventory.Slots[lInventory.Slots.Count - 1].ItemID = "";
}
BasicInventorySet lWeaponSet = lInventory.GetWeaponSet("Spell Casting");
if (lWeaponSet != null)
{
lInventory.WeaponSets.Remove(lWeaponSet);
}
lWeaponSet = new BasicInventorySet();
lWeaponSet.ID = "Spell Casting";
BasicInventorySetItem lWeaponSetItem = new BasicInventorySetItem();
lWeaponSetItem.ItemID = "";
lWeaponSetItem.SlotID = "LEFT_HAND";
lWeaponSetItem.Instantiate = true;
lWeaponSet.Items.Add(lWeaponSetItem);
lWeaponSetItem = new BasicInventorySetItem();
lWeaponSetItem.ItemID = "";
lWeaponSetItem.SlotID = "READY_PROJECTILE";
lWeaponSetItem.Instantiate = false;
lWeaponSet.Items.Add(lWeaponSetItem);
lWeaponSetItem = new BasicInventorySetItem();
lWeaponSetItem.ItemID = "Spell_01";
lWeaponSetItem.SlotID = "RIGHT_HAND";
lWeaponSetItem.Instantiate = false;
lWeaponSet.Items.Add(lWeaponSetItem);
lWeaponSetItem = new BasicInventorySetItem();
lWeaponSetItem.ItemID = "";
lWeaponSetItem.SlotID = "LEFT_LOWER_ARM";
lWeaponSetItem.Instantiate = false;
lWeaponSet.Items.Add(lWeaponSetItem);
if (lInventory.WeaponSets.Count == 0)
{
BasicInventorySet lFirstWeaponSet = new BasicInventorySet();
lFirstWeaponSet.ID = "Sword and Shield";
lInventory.WeaponSets.Add(lFirstWeaponSet);
}
if (lInventory.WeaponSets.Count == 1)
{
BasicInventorySet lSecondWeaponSet = new BasicInventorySet();
lSecondWeaponSet.ID = "Longbow";
lInventory.WeaponSets.Add(lSecondWeaponSet);
}
lInventory.WeaponSets.Insert(2, lWeaponSet);
}
if (sCreateAttributes)
{
BasicAttributes lAttributes = rMotionController.gameObject.GetComponent <BasicAttributes>();
if (lAttributes == null)
{
lAttributes = rMotionController.gameObject.AddComponent <BasicAttributes>();
}
BasicAttribute lAttribute = lAttributes.GetAttribute("Health");
if (lAttribute != null)
{
lAttributes.Items.Remove(lAttribute);
}
lAttributes.Items.Add(new BasicAttribute());
lAttributes.Items[lAttributes.Items.Count - 1].ID = "Health";
lAttributes.Items[lAttributes.Items.Count - 1].SetValue <float>(100f);
}
if (sCreateSpellInventory)
{
SpellInventory lAttributes = rMotionController.gameObject.GetComponent <SpellInventory>();
if (lAttributes == null)
{
lAttributes = rMotionController.gameObject.AddComponent <SpellInventory>();
}
}
if (sCreateCore)
{
Combatant lCombatant = rMotionController.gameObject.GetComponent <Combatant>();
if (lCombatant == null)
{
lCombatant = rMotionController.gameObject.AddComponent <Combatant>();
}
if (rMotionController._ActorController == null || !rMotionController._ActorController.UseTransformPosition)
{
lCombatant.IsLockingEnabled = true;
lCombatant.TargetLockedIcon = AssetDatabase.LoadAssetAtPath <Texture>("Assets/ootii/Framework_v1/Content/Textures/UI/TargetIcon_2.png");
}
ActorCore lCore = rMotionController.gameObject.GetComponent <ActorCore>();
if (lCore == null)
{
lCore = rMotionController.gameObject.AddComponent <ActorCore>();
}
lCore.IsAlive = true;
}
if (sCreateInputAliases)
{
// Sheathe
if (!InputManagerHelper.IsDefined("Spell Casting Equip"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Equip";
lEntry.PositiveButton = "3"; // "3" key
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Equip";
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.JoyNum = 0;
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
lEntry.PositiveButton = "joystick button 8";
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON; // D-pad Y
lEntry.Axis = 0;
#else
lEntry.PositiveButton = "";
lEntry.Type = InputManagerEntryType.JOYSTICK_AXIS; // D-pad Y
lEntry.Axis = 7;
#endif
InputManagerHelper.AddEntry(lEntry, true);
}
// Fire
if (!InputManagerHelper.IsDefined("Spell Casting Cast"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Cast";
lEntry.PositiveButton = "left ctrl";
lEntry.AltPositiveButton = "mouse 0"; // Left mouse button
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Cast";
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
lEntry.PositiveButton = "joystick button 16"; // Green A
#else
lEntry.PositiveButton = "joystick button 0"; // Green A
#endif
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
}
// Continue
if (!InputManagerHelper.IsDefined("Spell Casting Continue"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Continue";
lEntry.PositiveButton = "left ctrl";
lEntry.AltPositiveButton = "mouse 0"; // Left mouse button
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Continue";
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
lEntry.PositiveButton = "joystick button 16"; // Green A
#else
lEntry.PositiveButton = "joystick button 0"; // Green A
#endif
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
}
// Cancel
if (!InputManagerHelper.IsDefined("Spell Casting Cancel"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Cancel";
lEntry.PositiveButton = "escape";
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
lEntry = new InputManagerEntry();
lEntry.Name = "Spell Casting Cancel";
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
lEntry.PositiveButton = "joystick button 19"; // Yellow Y
#else
lEntry.PositiveButton = "joystick button 3"; // Yellow Y
#endif
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
}
// Move Up
if (!InputManagerHelper.IsDefined("Move Up"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Move Up";
lEntry.PositiveButton = "e";
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
}
// Move down
if (!InputManagerHelper.IsDefined("Move Down"))
{
InputManagerEntry lEntry = new InputManagerEntry();
lEntry.Name = "Move Down";
lEntry.PositiveButton = "q";
lEntry.Gravity = 1000;
lEntry.Dead = 0.001f;
lEntry.Sensitivity = 1000;
lEntry.Type = InputManagerEntryType.KEY_MOUSE_BUTTON;
lEntry.Axis = 0;
lEntry.JoyNum = 0;
InputManagerHelper.AddEntry(lEntry, true);
}
}
if (sCreateMotions || sCreateSubStateMachines)
{
IBaseCameraRig lCameraRig = rMotionController.CameraRig;
if (lCameraRig == null)
{
lCameraRig = rMotionController.ExtractCameraRig(rMotionController.CameraTransform);
}
if (rMotionController.MotionLayers.Count == 0)
{
MotionControllerLayer lMotionLayer = new MotionControllerLayer();
rMotionController.MotionLayers.Add(lMotionLayer);
}
PMP_Idle lIdle = rMotionController.GetMotion <PMP_Idle>();
if (lIdle == null)
{
lIdle = rMotionController.CreateMotion <PMP_Idle>(0);
}
PMP_EquipSpell lEquip = rMotionController.GetMotion <PMP_EquipSpell>(0);
if (lEquip == null)
{
lEquip = rMotionController.CreateMotion <PMP_EquipSpell>(0);
}
PMP_StoreSpell lStore = rMotionController.GetMotion <PMP_StoreSpell>(0);
if (lStore == null)
{
lStore = rMotionController.CreateMotion <PMP_StoreSpell>(0);
}
PMP_WalkRunPivot lPivot = rMotionController.GetMotion <PMP_WalkRunPivot>(0);
if (lPivot == null)
{
lPivot = rMotionController.CreateMotion <PMP_WalkRunPivot>(0);
}
PMP_WalkRunStrafe lStrafe = rMotionController.GetMotion <PMP_WalkRunStrafe>(0);
if (lStrafe == null)
{
lStrafe = rMotionController.CreateMotion <PMP_WalkRunStrafe>(0);
}
PMP_BasicSpellCastings lCast = rMotionController.GetMotion <PMP_BasicSpellCastings>(0);
if (lCast == null)
{
lCast = rMotionController.CreateMotion <PMP_BasicSpellCastings>(0);
}
Cower lCower = rMotionController.GetMotion <Cower>(0);
if (lCower == null)
{
lCower = rMotionController.CreateMotion <Cower>(0);
}
Death lDeath = rMotionController.GetMotion <Death>(0);
if (lDeath == null)
{
lDeath = rMotionController.CreateMotion <Death>(0);
}
Damaged lDamaged = rMotionController.GetMotion <Damaged>(0);
if (lDamaged == null)
{
lDamaged = rMotionController.CreateMotion <Damaged>(0);
}
Frozen lFrozen = rMotionController.GetMotion <Frozen>(0);
if (lFrozen == null)
{
lFrozen = rMotionController.CreateMotion <Frozen>(0);
}
KnockedDown lKnockedDown = rMotionController.GetMotion <KnockedDown>(0);
if (lKnockedDown == null)
{
lKnockedDown = rMotionController.CreateMotion <KnockedDown>(0);
}
Levitate lLevitate = rMotionController.GetMotion <Levitate>(0);
if (lLevitate == null)
{
lLevitate = rMotionController.CreateMotion <Levitate>(0);
}
PushedBack lPushedBack = rMotionController.GetMotion <PushedBack>(0);
if (lPushedBack == null)
{
lPushedBack = rMotionController.CreateMotion <PushedBack>(0);
}
Sleep lSleep = rMotionController.GetMotion <Sleep>(0);
if (lSleep == null)
{
lSleep = rMotionController.CreateMotion <Sleep>(0);
}
Stunned lStunned = rMotionController.GetMotion <Stunned>(0);
if (lStunned == null)
{
lStunned = rMotionController.CreateMotion <Stunned>(0);
}
if (sCreateSubStateMachines)
{
Animator lAnimator = rMotionController.Animator;
if (lAnimator == null)
{
lAnimator = rMotionController.gameObject.GetComponent <Animator>();
}
if (lAnimator != null)
{
UnityEditor.Animations.AnimatorController lAnimatorController = lAnimator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
lIdle.CreateStateMachine(lAnimatorController);
lEquip.CreateStateMachine(lAnimatorController);
lPivot.CreateStateMachine(lAnimatorController);
lStrafe.CreateStateMachine(lAnimatorController);
lCast.CreateStateMachine(lAnimatorController);
lDeath.CreateStateMachine(lAnimatorController);
lLevitate.CreateStateMachine(lAnimatorController);
}
}
}
EditorUtility.DisplayDialog("Motion Pack: " + GroupName(), "Motion pack imported.", "ok");
return(true);
}
return(false);
}
public static void BakeToPrefab (SkeletonDataAsset skeletonDataAsset, ExposedList<Skin> skins, string outputPath = "", bool bakeAnimations = true, bool bakeIK = true, SendMessageOptions eventOptions = SendMessageOptions.DontRequireReceiver) {
if (skeletonDataAsset == null || skeletonDataAsset.GetSkeletonData(true) == null) {
Debug.LogError("Could not export Spine Skeleton because SkeletonDataAsset is null or invalid!");
return;
}
#if !NEW_PREFAB_SYSTEM
if (outputPath == "") {
outputPath = System.IO.Path.GetDirectoryName(AssetDatabase.GetAssetPath(skeletonDataAsset)) + "/Baked";
System.IO.Directory.CreateDirectory(outputPath);
}
var skeletonData = skeletonDataAsset.GetSkeletonData(true);
bool hasAnimations = bakeAnimations && skeletonData.Animations.Count > 0;
UnityEditor.Animations.AnimatorController controller = null;
if (hasAnimations) {
string controllerPath = outputPath + "/" + skeletonDataAsset.skeletonJSON.name + " Controller.controller";
bool newAnimContainer = false;
var runtimeController = AssetDatabase.LoadAssetAtPath(controllerPath, typeof(RuntimeAnimatorController));
if (runtimeController != null) {
controller = (UnityEditor.Animations.AnimatorController)runtimeController;
} else {
controller = UnityEditor.Animations.AnimatorController.CreateAnimatorControllerAtPath(controllerPath);
newAnimContainer = true;
}
var existingClipTable = new Dictionary<string, AnimationClip>();
var unusedClipNames = new List<string>();
Object[] animObjs = AssetDatabase.LoadAllAssetsAtPath(controllerPath);
foreach (Object o in animObjs) {
if (o is AnimationClip) {
var clip = (AnimationClip)o;
existingClipTable.Add(clip.name, clip);
unusedClipNames.Add(clip.name);
}
}
Dictionary<int, List<string>> slotLookup = new Dictionary<int, List<string>>();
int skinCount = skins.Count;
for (int s = 0; s < skeletonData.Slots.Count; s++) {
List<string> attachmentNames = new List<string>();
for (int i = 0; i < skinCount; i++) {
var skin = skins.Items[i];
List<string> temp = new List<string>();
skin.FindNamesForSlot(s, temp);
foreach (string str in temp) {
if (!attachmentNames.Contains(str))
attachmentNames.Add(str);
}
}
slotLookup.Add(s, attachmentNames);
}
foreach (var anim in skeletonData.Animations) {
AnimationClip clip = null;
if (existingClipTable.ContainsKey(anim.Name)) {
clip = existingClipTable[anim.Name];
}
clip = ExtractAnimation(anim.Name, skeletonData, slotLookup, bakeIK, eventOptions, clip);
if (unusedClipNames.Contains(clip.name)) {
unusedClipNames.Remove(clip.name);
} else {
AssetDatabase.AddObjectToAsset(clip, controller);
controller.AddMotion(clip);
}
}
if (newAnimContainer) {
EditorUtility.SetDirty(controller);
AssetDatabase.SaveAssets();
AssetDatabase.ImportAsset(controllerPath, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
} else {
foreach (string str in unusedClipNames) {
AnimationClip.DestroyImmediate(existingClipTable[str], true);
}
EditorUtility.SetDirty(controller);
AssetDatabase.SaveAssets();
AssetDatabase.ImportAsset(controllerPath, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
}
foreach (var skin in skins) {
bool newPrefab = false;
string prefabPath = outputPath + "/" + skeletonDataAsset.skeletonJSON.name + " (" + skin.Name + ").prefab";
Object prefab = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject));
if (prefab == null) {
prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
newPrefab = true;
}
Dictionary<string, Mesh> meshTable = new Dictionary<string, Mesh>();
List<string> unusedMeshNames = new List<string>();
Object[] assets = AssetDatabase.LoadAllAssetsAtPath(prefabPath);
foreach (var obj in assets) {
if (obj is Mesh) {
meshTable.Add(obj.name, (Mesh)obj);
unusedMeshNames.Add(obj.name);
}
}
GameObject prefabRoot = SpineEditorUtilities.EditorInstantiation.NewGameObject("root");
Dictionary<string, Transform> slotTable = new Dictionary<string, Transform>();
Dictionary<string, Transform> boneTable = new Dictionary<string, Transform>();
List<Transform> boneList = new List<Transform>();
//create bones
for (int i = 0; i < skeletonData.Bones.Count; i++) {
var boneData = skeletonData.Bones.Items[i];
Transform boneTransform = SpineEditorUtilities.EditorInstantiation.NewGameObject(boneData.Name).transform;
boneTransform.parent = prefabRoot.transform;
boneTable.Add(boneTransform.name, boneTransform);
boneList.Add(boneTransform);
}
for (int i = 0; i < skeletonData.Bones.Count; i++) {
var boneData = skeletonData.Bones.Items[i];
Transform boneTransform = boneTable[boneData.Name];
Transform parentTransform = null;
if (i > 0)
parentTransform = boneTable[boneData.Parent.Name];
else
parentTransform = boneTransform.parent;
boneTransform.parent = parentTransform;
boneTransform.localPosition = new Vector3(boneData.X, boneData.Y, 0);
var tm = boneData.TransformMode;
if (tm.InheritsRotation())
boneTransform.localRotation = Quaternion.Euler(0, 0, boneData.Rotation);
else
boneTransform.rotation = Quaternion.Euler(0, 0, boneData.Rotation);
if (tm.InheritsScale())
boneTransform.localScale = new Vector3(boneData.ScaleX, boneData.ScaleY, 1);
}
//create slots and attachments
for (int i = 0; i < skeletonData.Slots.Count; i++) {
var slotData = skeletonData.Slots.Items[i];
Transform slotTransform = SpineEditorUtilities.EditorInstantiation.NewGameObject(slotData.Name).transform;
slotTransform.parent = prefabRoot.transform;
slotTable.Add(slotData.Name, slotTransform);
List<Attachment> attachments = new List<Attachment>();
List<string> attachmentNames = new List<string>();
skin.FindAttachmentsForSlot(i, attachments);
skin.FindNamesForSlot(i, attachmentNames);
if (skin != skeletonData.DefaultSkin) {
skeletonData.DefaultSkin.FindAttachmentsForSlot(i, attachments);
skeletonData.DefaultSkin.FindNamesForSlot(i, attachmentNames);
}
for (int a = 0; a < attachments.Count; a++) {
var attachment = attachments[a];
string attachmentName = attachmentNames[a];
string attachmentMeshName = "[" + slotData.Name + "] " + attachmentName;
Vector3 offset = Vector3.zero;
float rotation = 0;
Mesh mesh = null;
Material material = null;
bool isWeightedMesh = false;
if (meshTable.ContainsKey(attachmentMeshName))
mesh = meshTable[attachmentMeshName];
if (attachment is RegionAttachment) {
var regionAttachment = (RegionAttachment)attachment;
offset.x = regionAttachment.X;
offset.y = regionAttachment.Y;
rotation = regionAttachment.Rotation;
mesh = ExtractRegionAttachment(attachmentMeshName, regionAttachment, mesh);
material = attachment.GetMaterial();
unusedMeshNames.Remove(attachmentMeshName);
if (newPrefab || meshTable.ContainsKey(attachmentMeshName) == false)
AssetDatabase.AddObjectToAsset(mesh, prefab);
} else if (attachment is MeshAttachment) {
var meshAttachment = (MeshAttachment)attachment;
isWeightedMesh = (meshAttachment.Bones != null);
offset.x = 0;
offset.y = 0;
rotation = 0;
if (isWeightedMesh)
mesh = ExtractWeightedMeshAttachment(attachmentMeshName, meshAttachment, i, skeletonData, boneList, mesh);
else
mesh = ExtractMeshAttachment(attachmentMeshName, meshAttachment, mesh);
material = attachment.GetMaterial();
unusedMeshNames.Remove(attachmentMeshName);
if (newPrefab || meshTable.ContainsKey(attachmentMeshName) == false)
AssetDatabase.AddObjectToAsset(mesh, prefab);
} else
continue;
Transform attachmentTransform = SpineEditorUtilities.EditorInstantiation.NewGameObject(attachmentName).transform;
attachmentTransform.parent = slotTransform;
attachmentTransform.localPosition = offset;
attachmentTransform.localRotation = Quaternion.Euler(0, 0, rotation);
if (isWeightedMesh) {
attachmentTransform.position = Vector3.zero;
attachmentTransform.rotation = Quaternion.identity;
var skinnedMeshRenderer = attachmentTransform.gameObject.AddComponent<SkinnedMeshRenderer>();
skinnedMeshRenderer.rootBone = boneList[0];
skinnedMeshRenderer.bones = boneList.ToArray();
skinnedMeshRenderer.sharedMesh = mesh;
} else {
attachmentTransform.gameObject.AddComponent<MeshFilter>().sharedMesh = mesh;
attachmentTransform.gameObject.AddComponent<MeshRenderer>();
}
attachmentTransform.GetComponent<Renderer>().sharedMaterial = material;
attachmentTransform.GetComponent<Renderer>().sortingOrder = i;
if (attachmentName != slotData.AttachmentName)
attachmentTransform.gameObject.SetActive(false);
}
}
foreach (var slotData in skeletonData.Slots) {
Transform slotTransform = slotTable[slotData.Name];
slotTransform.parent = boneTable[slotData.BoneData.Name];
slotTransform.localPosition = Vector3.zero;
slotTransform.localRotation = Quaternion.identity;
slotTransform.localScale = Vector3.one;
}
if (hasAnimations) {
var animator = prefabRoot.AddComponent<Animator>();
animator.applyRootMotion = false;
animator.runtimeAnimatorController = (RuntimeAnimatorController)controller;
EditorGUIUtility.PingObject(controller);
}
if (newPrefab) {
PrefabUtility.ReplacePrefab(prefabRoot, prefab, ReplacePrefabOptions.ConnectToPrefab);
} else {
foreach (string str in unusedMeshNames) {
Mesh.DestroyImmediate(meshTable[str], true);
}
PrefabUtility.ReplacePrefab(prefabRoot, prefab, ReplacePrefabOptions.ReplaceNameBased);
}
EditorGUIUtility.PingObject(prefab);
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
GameObject.DestroyImmediate(prefabRoot);
}
#endif
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
EditorGUILayout.Separator();
EditorGUILayout.PropertyField(this.serializedObject.FindProperty("transitionType"), new GUIContent("Transition"));
Selectable.Transition transition = (Selectable.Transition) this.serializedObject.FindProperty("transitionType").enumValueIndex;
Graphic graphic = this.serializedObject.FindProperty("targetGraphic").objectReferenceValue as Graphic;
// Check if the transition requires a graphic
if (transition == Selectable.Transition.ColorTint || transition == Selectable.Transition.SpriteSwap)
{
EditorGUILayout.PropertyField(this.serializedObject.FindProperty("targetGraphic"), new GUIContent("Target Graphic"));
if (transition == Selectable.Transition.ColorTint)
{
if (graphic == null)
{
EditorGUILayout.HelpBox("You must have a Graphic target in order to use a color transition.", MessageType.Info);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(serializedObject.FindProperty("colors"), new GUIContent("Colors"), true);
if (EditorGUI.EndChangeCheck())
{
graphic.canvasRenderer.SetColor(this.serializedObject.FindProperty("colors").FindPropertyRelative("m_NormalColor").colorValue);
}
}
}
else if (transition == Selectable.Transition.SpriteSwap)
{
if (graphic as Image == null)
{
EditorGUILayout.HelpBox("You must have a Image target in order to use a sprite swap transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.serializedObject.FindProperty("spriteState"), new GUIContent("Sprites"), true);
}
}
}
else if (transition == Selectable.Transition.Animation)
{
EditorGUILayout.PropertyField(this.serializedObject.FindProperty("animationTriggers"), true);
Animator animator = (target as UISelectField_Arrow).gameObject.GetComponent <Animator>();
if (animator == null || animator.runtimeAnimatorController == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = UIAnimatorControllerGenerator.GenerateAnimatorContoller(this.serializedObject.FindProperty("animationTriggers"), this.target.name);
if (animatorController != null)
{
if (animator == null)
{
animator = (target as UISelectField_Arrow).gameObject.AddComponent <Animator>();
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, animatorController);
}
}
}
}
this.serializedObject.ApplyModifiedProperties();
}
void OnGUI()
{
EditorGUILayout.LabelField("target clip");
controller = EditorGUILayout.ObjectField(controller, typeof(UnityEditor.Animations.AnimatorController), false) as UnityEditor.Animations.AnimatorController;
if( controller == null )
return;
List<AnimationClip> clipList = new List<AnimationClip>();
var allAsset = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(controller));
foreach( var asset in allAsset )
{
if( asset is AnimationClip)
{
var removeClip = asset as AnimationClip;
if(! clipList.Contains(removeClip ) ){
clipList.Add(removeClip);
}
}
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Add new clip");
EditorGUILayout.BeginVertical("box");
clipName = EditorGUILayout.TextField(clipName);
if( clipList.Exists(item=> item.name == clipName ) || string.IsNullOrEmpty(clipName) )
{
EditorGUILayout.LabelField("can't create duplicate names or empty");
}else{
if( GUILayout.Button("create"))
{
AnimationClip animationClip = UnityEditor.Animations.AnimatorController.AllocateAnimatorClip(clipName);
AssetDatabase.AddObjectToAsset(animationClip, controller);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(controller));
AssetDatabase.Refresh();
}
}
EditorGUILayout.EndVertical();
if( clipList.Count == 0)
return;
EditorGUILayout.Space();
EditorGUILayout.LabelField("remove clip");
EditorGUILayout.BeginVertical("box");
foreach( var removeClip in clipList )
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(removeClip.name);
if( GUILayout.Button("remove" , GUILayout.Width(100)))
{
Object.DestroyImmediate(removeClip, true);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(controller));
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
}
public override void OnInspectorGUI()
{
trigger = (CVRAdvancedAvatarSettingsTrigger)target;
var avatar = trigger.GetComponentInParent <CVRAvatar>();
animator = null;
animatorParameters = new List <string>();
animatorParameters.Add("-none-");
if (avatar != null && avatar.overrides != null && avatar.overrides.runtimeAnimatorController != null)
{
animator = (AnimatorController)avatar.overrides.runtimeAnimatorController;
foreach (var parameter in animator.parameters)
{
if (parameter.type == AnimatorControllerParameterType.Float && parameter.name.Length > 0 &&
!CCK_CVRAvatarEditor.coreParameters.Contains(parameter.name) && parameter.name.Substring(0, 1) != "#")
{
animatorParameters.Add(parameter.name);
}
}
}
var triggers = trigger.GetComponents <CVRAdvancedAvatarSettingsTrigger>();
if (triggers.Length > 1)
{
EditorGUILayout.HelpBox(CCKLocalizationProvider.GetLocalizedText("ABI_UI_ADVAVTR_TRIGGER_MULTIPLE_TRIGGER_HELPBOX"), MessageType.Error);
}
trigger.areaSize = EditorGUILayout.Vector3Field("Area Size", trigger.areaSize);
trigger.areaOffset = EditorGUILayout.Vector3Field("Area Offset", trigger.areaOffset);
if (!trigger.useAdvancedTrigger)
{
if (animator == null)
{
trigger.settingName = EditorGUILayout.TextField("Setting Name", trigger.settingName);
}
else
{
var animatorParams = animatorParameters.ToArray();
var index = animatorParameters.FindIndex(match => match == trigger.settingName);
index = Mathf.Max(EditorGUILayout.Popup("Setting Name", index, animatorParams), 0);
trigger.settingName = animatorParams[index];
}
trigger.settingValue = EditorGUILayout.FloatField("Setting Value", trigger.settingValue);
trigger.useAdvancedTrigger = EditorGUILayout.Toggle("Enabled Advanced Mode", trigger.useAdvancedTrigger);
}
else
{
trigger.useAdvancedTrigger = EditorGUILayout.Toggle("Enabled Advanced Mode", trigger.useAdvancedTrigger);
var list = serializedObject.FindProperty("allowedPointer");
EditorGUILayout.PropertyField(list, new GUIContent("Allowed Pointers"), true);
serializedObject.ApplyModifiedProperties();
EditorGUILayout.HelpBox(CCKLocalizationProvider.GetLocalizedText("ABI_UI_ADVAVTR_TRIGGER_ALLOWED_POINTERS_HELPBOX"), MessageType.Info);
trigger.isNetworkInteractable = EditorGUILayout.Toggle("Network Interactable", trigger.isNetworkInteractable);
if (_onEnterList == null)
{
_onEnterList = new ReorderableList(trigger.enterTasks, typeof(CVRAdvancedAvatarSettingsTriggerTask),
false, true, true, true);
_onEnterList.drawHeaderCallback = OnDrawHeaderEnter;
_onEnterList.drawElementCallback = OnDrawElementEnter;
_onEnterList.elementHeightCallback = OnHeightElementEnter;
_onEnterList.onAddCallback = OnAddEnter;
_onEnterList.onChangedCallback = OnChangedEnter;
}
_onEnterList.DoLayoutList();
if (_onExitList == null)
{
_onExitList = new ReorderableList(trigger.exitTasks, typeof(CVRAdvancedAvatarSettingsTriggerTask),
false, true, true, true);
_onExitList.drawHeaderCallback = OnDrawHeaderExit;
_onExitList.drawElementCallback = OnDrawElementExit;
_onExitList.elementHeightCallback = OnHeightElementExit;
_onExitList.onAddCallback = OnAddExit;
_onExitList.onChangedCallback = OnChangedExit;
}
_onExitList.DoLayoutList();
}
}
void CheckResources()
{
ActiveTextures.Clear();
ActiveMaterials.Clear();
ActiveMeshDetails.Clear();
MissingObjects.Clear();
thingsMissing = false;
Renderer[] renderers = FindObjects <Renderer>();
MaterialDetails skyMat = new MaterialDetails();
skyMat.material = RenderSettings.skybox;
skyMat.isSky = true;
ActiveMaterials.Add(skyMat);
//Debug.Log("Total renderers "+renderers.Length);
foreach (Renderer renderer in renderers)
{
//Debug.Log("Renderer is "+renderer.name);
foreach (Material material in renderer.sharedMaterials)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(material);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = material;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInRenderers.Add(renderer);
}
if (renderer is SpriteRenderer)
{
SpriteRenderer tSpriteRenderer = (SpriteRenderer)renderer;
if (tSpriteRenderer.sprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSpriteRenderer.sprite.texture, renderer);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
else if (tSpriteRenderer.sprite == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSpriteRenderer.transform;
tMissing.type = "sprite";
tMissing.name = tSpriteRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
}
if (IncludeGuiElements)
{
Graphic[] graphics = FindObjects <Graphic>();
foreach (Graphic graphic in graphics)
{
if (graphic.mainTexture)
{
var tSpriteTextureDetail = GetTextureDetail(graphic.mainTexture, graphic);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
if (graphic.materialForRendering)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(graphic.materialForRendering);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = graphic.materialForRendering;
tMaterialDetails.isgui = true;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInGraphics.Add(graphic);
}
}
Button[] buttons = FindObjects <Button>();
foreach (Button button in buttons)
{
CheckButtonSpriteState(button, button.spriteState.disabledSprite);
CheckButtonSpriteState(button, button.spriteState.highlightedSprite);
CheckButtonSpriteState(button, button.spriteState.pressedSprite);
}
}
foreach (MaterialDetails tMaterialDetails in ActiveMaterials)
{
Material tMaterial = tMaterialDetails.material;
if (tMaterial != null)
{
var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
foreach (Object obj in dependencies)
{
if (obj is Texture)
{
Texture tTexture = obj as Texture;
var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMaterialDetails);
tTextureDetail.isSky = tMaterialDetails.isSky;
tTextureDetail.instance = tMaterialDetails.instance;
tTextureDetail.isgui = tMaterialDetails.isgui;
ActiveTextures.Add(tTextureDetail);
}
}
//if the texture was downloaded, it won't be included in the editor dependencies
if (tMaterial.HasProperty("_MainTex"))
{
if (tMaterial.mainTexture != null && !dependencies.Contains(tMaterial.mainTexture))
{
var tTextureDetail = GetTextureDetail(tMaterial.mainTexture, tMaterial, tMaterialDetails);
ActiveTextures.Add(tTextureDetail);
}
}
}
}
MeshFilter[] meshFilters = FindObjects <MeshFilter>();
foreach (MeshFilter tMeshFilter in meshFilters)
{
Mesh tMesh = tMeshFilter.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInMeshFilters.Add(tMeshFilter);
}
else if (tMesh == null && tMeshFilter.transform.GetComponent("TextContainer") == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tMeshFilter.transform;
tMissing.type = "mesh";
tMissing.name = tMeshFilter.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
var meshRenderrer = tMeshFilter.transform.GetComponent <MeshRenderer>();
if (meshRenderrer == null || meshRenderrer.sharedMaterial == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tMeshFilter.transform;
tMissing.type = "material";
tMissing.name = tMeshFilter.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
SkinnedMeshRenderer[] skinnedMeshRenderers = FindObjects <SkinnedMeshRenderer>();
foreach (SkinnedMeshRenderer tSkinnedMeshRenderer in skinnedMeshRenderers)
{
Mesh tMesh = tSkinnedMeshRenderer.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInSkinnedMeshRenderer.Add(tSkinnedMeshRenderer);
}
else if (tMesh == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSkinnedMeshRenderer.transform;
tMissing.type = "mesh";
tMissing.name = tSkinnedMeshRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
if (tSkinnedMeshRenderer.sharedMaterial == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSkinnedMeshRenderer.transform;
tMissing.type = "material";
tMissing.name = tSkinnedMeshRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
if (IncludeSpriteAnimations)
{
Animator[] animators = FindObjects <Animator>();
foreach (Animator anim in animators)
{
#if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
UnityEditorInternal.AnimatorController ac = anim.runtimeAnimatorController as UnityEditorInternal.AnimatorController;
#elif UNITY_5 || UNITY_5_3_OR_NEWER
UnityEditor.Animations.AnimatorController ac = anim.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
#endif
//Skip animators without layers, this can happen if they don't have an animator controller.
if (!ac || ac.layers == null || ac.layers.Length == 0)
{
continue;
}
for (int x = 0; x < anim.layerCount; x++)
{
UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[x].stateMachine;
int cnt = sm.states.Length;
for (int i = 0; i < cnt; i++)
{
UnityEditor.Animations.AnimatorState state = sm.states[i].state;
Motion m = state.motion;
if (m != null)
{
AnimationClip clip = m as AnimationClip;
if (clip != null)
{
EditorCurveBinding[] ecbs = AnimationUtility.GetObjectReferenceCurveBindings(clip);
foreach (EditorCurveBinding ecb in ecbs)
{
if (ecb.propertyName == "m_Sprite")
{
foreach (ObjectReferenceKeyframe keyframe in AnimationUtility.GetObjectReferenceCurve(clip, ecb))
{
Sprite tSprite = keyframe.value as Sprite;
if (tSprite != null)
{
var tTextureDetail = GetTextureDetail(tSprite.texture, anim);
if (!ActiveTextures.Contains(tTextureDetail))
{
ActiveTextures.Add(tTextureDetail);
}
}
}
}
}
}
}
}
}
}
}
if (IncludeScriptReferences)
{
MonoBehaviour[] scripts = FindObjects <MonoBehaviour>();
foreach (MonoBehaviour script in scripts)
{
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; // only public non-static fields are bound to by Unity.
FieldInfo[] fields = script.GetType().GetFields(flags);
foreach (FieldInfo field in fields)
{
System.Type fieldType = field.FieldType;
if (fieldType == typeof(Sprite))
{
Sprite tSprite = field.GetValue(script) as Sprite;
if (tSprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSprite.texture, script);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
}
if (fieldType == typeof(Mesh))
{
Mesh tMesh = field.GetValue(script) as Mesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
tMeshDetails.instance = true;
ActiveMeshDetails.Add(tMeshDetails);
}
}
}
if (fieldType == typeof(Material))
{
Material tMaterial = field.GetValue(script) as Material;
if (tMaterial != null)
{
MaterialDetails tMatDetails = FindMaterialDetails(tMaterial);
if (tMatDetails == null)
{
tMatDetails = new MaterialDetails();
tMatDetails.instance = true;
tMatDetails.material = tMaterial;
if (!ActiveMaterials.Contains(tMatDetails))
{
ActiveMaterials.Add(tMatDetails);
}
}
if (tMaterial.mainTexture)
{
var tSpriteTextureDetail = GetTextureDetail(tMaterial.mainTexture);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
foreach (Object obj in dependencies)
{
if (obj is Texture)
{
Texture tTexture = obj as Texture;
var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMatDetails);
if (!ActiveTextures.Contains(tTextureDetail))
{
ActiveTextures.Add(tTextureDetail);
}
}
}
}
}
}
}
}
TotalTextureMemory = 0;
foreach (TextureDetails tTextureDetails in ActiveTextures)
{
TotalTextureMemory += tTextureDetails.memSizeKB;
}
TotalMeshVertices = 0;
foreach (MeshDetails tMeshDetails in ActiveMeshDetails)
{
TotalMeshVertices += tMeshDetails.mesh.vertexCount;
}
// Sort by size, descending
ActiveTextures.Sort(delegate(TextureDetails details1, TextureDetails details2) { return(details2.memSizeKB - details1.memSizeKB); });
ActiveTextures = ActiveTextures.Distinct().ToList();
ActiveMeshDetails.Sort(delegate(MeshDetails details1, MeshDetails details2) { return(details2.mesh.vertexCount - details1.mesh.vertexCount); });
collectedInPlayingMode = Application.isPlaying;
}
public static void AddParametersOnAnimator(UnityEditor.Animations.AnimatorController AnimController, UnityEditor.Animations.AnimatorController Mounted)
{
AnimatorControllerParameter[] parameters = AnimController.parameters;
AnimatorControllerParameter[] Mountedparameters = Mounted.parameters;
foreach (var param in Mountedparameters)
{
if (!SearchParameter(parameters, param.name))
{
AnimController.AddParameter(param);
}
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.BeginVertical(MalbersEditor.StyleBlue);
EditorGUILayout.HelpBox("The Combat Mode is managed here", MessageType.None);
EditorGUILayout.EndVertical();
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginVertical(MalbersEditor.StyleGray);
{
EditorGUI.BeginDisabledGroup(true);
script = (MonoScript)EditorGUILayout.ObjectField("Script", script, typeof(MonoScript), false);
EditorGUI.EndDisabledGroup();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
EditorGUILayout.PropertyField(HitMask, new GUIContent("Hit Mask", "What to Hit"));
M.Target = (Transform)EditorGUILayout.ObjectField(new GUIContent("Target", "If the Rider has a Target"), M.Target, typeof(Transform), true);
M.AimDot = (RectTransform)EditorGUILayout.ObjectField(new GUIContent("Aim Dot", "UI for Aiming"), M.AimDot, typeof(RectTransform), true);
M.StrafeOnTarget = EditorGUILayout.Toggle(new GUIContent("Strafe on Target", "If is there a Target change the mount Input to Camera Input "), M.StrafeOnTarget);
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
EditorGUI.indentLevel++;
M.Editor_ShowEquipPoints = EditorGUILayout.Foldout(M.Editor_ShowEquipPoints, "Weapon Equip Points");
if (M.Editor_ShowEquipPoints)
{
M.LeftHandEquipPoint = (Transform)EditorGUILayout.ObjectField("Left Hand", M.LeftHandEquipPoint, typeof(Transform), true);
M.RightHandEquipPoint = (Transform)EditorGUILayout.ObjectField("Right Hand", M.RightHandEquipPoint, typeof(Transform), true);
}
Animator rideranimator = M.GetComponent <Animator>();
if (rideranimator)
{
if (!M.LeftHandEquipPoint)
{
M.LeftHandEquipPoint = rideranimator.GetBoneTransform(HumanBodyBones.LeftHand);
}
if (!M.RightHandEquipPoint)
{
M.RightHandEquipPoint = rideranimator.GetBoneTransform(HumanBodyBones.RightHand);
}
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndVertical();
//INPUTS
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
EditorGUI.indentLevel++;
M.Editor_ShowInputs = EditorGUILayout.Foldout(M.Editor_ShowInputs, "Inputs");
if (M.Editor_ShowInputs)
{
EditorGUILayout.PropertyField(InputAttack1, new GUIContent("Attack1", "Attack Right Side "));
MalbersInputEditor.DrawInputEvents(InputAttack1, InputAttack1.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(InputAttack2, new GUIContent("Attack2", "Attack Left Side "));
MalbersInputEditor.DrawInputEvents(InputAttack2, InputAttack2.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(InputAim, new GUIContent("Aim Mode", "Enable Aim mode for Ranged Weapons"));
MalbersInputEditor.DrawInputEvents(InputAim, InputAim.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(Reload, new GUIContent("Reload", "To Reload Guns"));
MalbersInputEditor.DrawInputEvents(Reload, Reload.FindPropertyRelative("ShowEvents").boolValue);
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndVertical();
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
M.ActiveHolderSide = (WeaponHolder)EditorGUILayout.EnumPopup(new GUIContent("Active Holder Side", "Holder to draw weapons from, When weapons dont have specific holder"), M.ActiveHolderSide);
EditorGUILayout.EndVertical();
if (EditorGUI.EndChangeCheck())
{
M.SetActiveHolder(M.ActiveHolderSide);
}
EditorGUI.indentLevel++;
///──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
//Inventory and Holders
EditorGUILayout.BeginHorizontal();
M.UseInventory = GUILayout.Toggle(M.UseInventory, new GUIContent("Use Inventory", "Get the Weapons from an Inventory"), EditorStyles.toolbarButton);
if (M.UseInventory)
{
M.UseHolders = false;
}
else
{
M.UseHolders = true;
}
M.UseHolders = GUILayout.Toggle(M.UseHolders, new GUIContent("Use Holders", "The Weapons are child of the Holders Transform"), EditorStyles.toolbarButton);
if (M.UseHolders)
{
M.UseInventory = false;
}
else
{
M.UseInventory = true;
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
if (M.UseInventory)
{
EditorGUILayout.BeginVertical(MalbersEditor.StyleGreen);
EditorGUILayout.HelpBox("The weapons gameobjects are received by the method 'SetWeaponByInventory(GameObject)'", MessageType.None);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
M.AlreadyInstantiated = EditorGUILayout.ToggleLeft(new GUIContent("Already Instantiated", "The weapon is already instantiated before entering 'GetWeaponByInventory'"), M.AlreadyInstantiated);
EditorGUILayout.EndVertical();
//if (MyRiderCombat.GetComponent<MInventory>())
//{
// MyRiderCombat.GetComponent<MInventory>().enabled = true;
//}
}
//Holder Stufss
if (M.UseHolders)
{
EditorGUILayout.BeginVertical(MalbersEditor.StyleGreen);
EditorGUILayout.HelpBox("The weapons are child of the Holders", MessageType.None);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
EditorGUI.indentLevel++;
M.Editor_ShowHolders = EditorGUILayout.Foldout(M.Editor_ShowHolders, "Holders");
if (M.Editor_ShowHolders)
{
EditorGUILayout.PropertyField(HolderLeft, new GUIContent("Holder Left", "The Tranform that has the weapons on the Left Side"));
EditorGUILayout.PropertyField(HolderRight, new GUIContent("Holder Right", "The Tranform that has the weapons on the Right Side"));
EditorGUILayout.PropertyField(HolderBack, new GUIContent("Holder Back", "The Tranform that has the weapons on the Back Side"));
M.Editor_ShowHoldersInput = GUILayout.Toggle(M.Editor_ShowHoldersInput, "Holders Input", EditorStyles.toolbarButton);
{
if (M.Editor_ShowHoldersInput)
{
EditorGUILayout.PropertyField(InputWeapon, new GUIContent("Input Weapon", "Draw/Store the Last Weapon"));
MalbersInputEditor.DrawInputEvents(InputWeapon, InputWeapon.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(HLeft, new GUIContent("Left", "Input to get Weapons from the Left Holder"));
MalbersInputEditor.DrawInputEvents(HLeft, HLeft.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(HRight, new GUIContent("Right", "Input to get Weapons from the Right Holder"));
MalbersInputEditor.DrawInputEvents(HRight, HRight.FindPropertyRelative("ShowEvents").boolValue);
EditorGUILayout.PropertyField(HBack, new GUIContent("Back", "Input to get Weapons from the Back Holder"));
MalbersInputEditor.DrawInputEvents(HBack, HBack.FindPropertyRelative("ShowEvents").boolValue);
}
}
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndVertical();
if (M.GetComponent <MInventory>())
{
M.GetComponent <MInventory>().enabled = false;
}
}
}
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(CombatAbilities, new GUIContent("Rider Combat Abilities", ""), true);
EditorGUI.indentLevel--;
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUI.indentLevel++;
M.Editor_ShowAbilities = EditorGUILayout.Foldout(M.Editor_ShowAbilities, "Abilities Properties");
EditorGUI.indentLevel--;
if (M.Editor_ShowAbilities)
{
if (M.CombatAbilities != null)
{
foreach (var combatAbility in M.CombatAbilities)
{
if (combatAbility != null)
{
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUILayout.LabelField(combatAbility.name, EditorStyles.toolbarButton);
//EditorGUILayout.Separator();
DrawAbility(combatAbility);
EditorGUILayout.EndVertical();
}
}
}
}
EditorGUILayout.EndVertical();
EditorGUI.indentLevel++;
DrawEvents();
EditorGUILayout.PropertyField(debug, new GUIContent("Debug", ""));
Animator anim = M.GetComponent <Animator>();
UnityEditor.Animations.AnimatorController controller = null;
if (anim)
{
controller = (UnityEditor.Animations.AnimatorController)anim.runtimeAnimatorController;
}
if (controller)
{
List <UnityEditor.Animations.AnimatorControllerLayer> layers = controller.layers.ToList();
if (layers.Find(layer => layer.name == "Mounted") == null)
//if (anim.GetLayerIndex("Mounted") == -1)
{
EditorGUILayout.HelpBox("No Mounted Layer Found, Add it the Mounted Layer using the Rider 3rd Person Script", MessageType.Warning);
}
else
{
if (layers.Find(layer => layer.name == "Rider Combat") == null)
//if (anim.GetLayerIndex("Rider Combat") == -1)
{
if (GUILayout.Button(new GUIContent("Add Rider Combat Layers", "Used for adding the parameters and Layer from the Mounted Animator to your custom character controller animator ")))
{
AddLayerMountedCombat(controller);
}
}
}
}
EditorGUILayout.EndVertical();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Rider Combat Change");
}
EditorUtility.SetDirty(target);
serializedObject.ApplyModifiedProperties();
}
private void BaseSkillInput(SkillData currSkillData)
{
#region 基本
MyGUIExtend.Instance.Foldout("基本" + this.currSkillData.id + currSkillData.id, "基本", () =>
{
currSkillData.name = MyGUI.TextFieldWithTitle("name", currSkillData.name);
MonoScript component =
(MonoScript)AssetDatabase.LoadAssetAtPath(currSkillData.componentPath, typeof(MonoScript));
component = (UnityEditor.MonoScript)EditorGUILayout.ObjectField(new GUIContent("脚本"),
component, typeof(UnityEditor.MonoScript), true);
if (component != null)
{
currSkillData.componentPath = AssetDatabase.GetAssetPath(component);
currSkillData.componentTypeName =
component.GetClass().Namespace + "." + component.GetClass().Name;
}
currSkillData.SurvivalTime = MyGUI.FloatFieldWithTitle("存活时间", currSkillData.SurvivalTime);
// 朝向模式 add by TangJian 2019/4/20 13:24
currSkillData.SkillOrientationMode =
(SkillOrientationMode)MyGUI.EnumPopupWithTitle("朝向模式",
currSkillData.SkillOrientationMode);
});
#endregion
#region 渲染
MyGUIExtend.Instance.Foldout("渲染" + this.currSkillData.id + currSkillData.id, "渲染", () =>
{
currSkillData.rendererType =
(RendererType)MyGUI.EnumPopupWithTitle("rander类型:", currSkillData.rendererType);
switch (currSkillData.rendererType)
{
case RendererType.SkeletonAnimator:
{
Spine.Unity.SkeletonDataAsset SkeletonDataAsset =
(Spine.Unity.SkeletonDataAsset)AssetDatabase.LoadAssetAtPath(
currSkillData.SkeletonDataAssetPath, typeof(Spine.Unity.SkeletonDataAsset));
UnityEditor.Animations.AnimatorController animatorController =
(UnityEditor.Animations.AnimatorController)AssetDatabase.LoadAssetAtPath(
currSkillData.AnimControllerPath,
typeof(UnityEditor.Animations.AnimatorController));
animatorController =
(UnityEditor.Animations.AnimatorController)EditorGUILayout.ObjectField(
new GUIContent("动画控制器"), animatorController,
typeof(UnityEditor.Animations.AnimatorController), true);
SkeletonDataAsset =
(Spine.Unity.SkeletonDataAsset)EditorGUILayout.ObjectField(
new GUIContent("Skeleton"), SkeletonDataAsset,
typeof(Spine.Unity.SkeletonDataAsset), true);
currSkillData.SkeletonDataAssetPath = AssetDatabase.GetAssetPath(SkeletonDataAsset);
currSkillData.AnimControllerPath = AssetDatabase.GetAssetPath(animatorController);
if (SkeletonDataAsset != null)
{
string[] skins =
new string[SkeletonDataAsset.GetSkeletonData(false).Skins.Count];
int skinIndex = 0;
for (int i = 0; i < skins.Length; i++)
{
string skinNameString = SkeletonDataAsset.GetSkeletonData(false).Skins
.Items[i].Name;
skins[i] = skinNameString;
if (skinNameString == currSkillData.SkinName)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Initial Skin(皮肤)", skinIndex, skins);
currSkillData.SkinName = skins[skinIndex];
}
}
break;
case RendererType.Sprite:
{
currSkillData.SpritePath =
MyGUI.ObjectField <Sprite>("精灵: ", currSkillData.SpritePath);
}
break;
case RendererType.Skeleton:
Spine.Unity.SkeletonDataAsset skeletonDataAsset = AssetDatabase.LoadAssetAtPath <Spine.Unity.SkeletonDataAsset>(currSkillData.SkeletonPath);
skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)EditorGUILayout.ObjectField("Skeleton", skeletonDataAsset, typeof(Spine.Unity.SkeletonDataAsset));
currSkillData.SkeletonPath = AssetDatabase.GetAssetPath(skeletonDataAsset);
if (skeletonDataAsset != null)
{
if (skeletonDataAsset != null && skeletonDataAsset.GetSkeletonData(false) != null && skeletonDataAsset.GetSkeletonData(false).Animations != null)
{
string[] Animations = new string[skeletonDataAsset.GetSkeletonData(false).Animations.Count];
int skinIndex = 0;
for (int i = 0; i < Animations.Length; i++)
{
string skinNameString = skeletonDataAsset.GetSkeletonData(false).Animations.Items[i].Name;
Animations[i] = skinNameString;
if (skinNameString == currSkillData.SkeletonClipName)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Animation(动画片段)", skinIndex, Animations);
currSkillData.SkeletonClipName = Animations[skinIndex];
}
}
break;
case RendererType.Anim:
currSkillData.AnimName = EditorGUILayout.TextField("AnimName:", currSkillData.AnimName);
break;
default:
Debug.Log("UnKnown:" + currSkillData.rendererType);
break;
}
currSkillData.shadow = MyGUI.ToggleWithTitle("阴影", currSkillData.shadow);
if (currSkillData.shadow)
{
currSkillData.shadowScale =
MyGUI.Vector3WithTitle("阴影scale", currSkillData.shadowScale);
currSkillData.CutOffDistance =
MyGUI.FloatFieldWithTitle("阴影CutOffDistance", currSkillData.CutOffDistance);
currSkillData.MaxScaleMultpler = MyGUI.FloatFieldWithTitle("阴影MaxScaleMultpler",
currSkillData.MaxScaleMultpler);
}
});
#endregion
}
public override void OnInspectorGUI()
{
obj.Update();
animatorValidated = false;
Animator animComponent = (obj.targetObject as MLPASAnimatorSFXController).GetComponent <Animator>();
if (animComponent != null)
{
string assetPath = AssetDatabase.GetAssetPath(animComponent.runtimeAnimatorController);
UnityEditor.Animations.AnimatorController newAnim = AssetDatabase.LoadAssetAtPath <UnityEditor.Animations.AnimatorController>(assetPath);
if (anim != newAnim)
{
anim = newAnim;
}
}
if (anim != null)
{
animatorValidated = true;
}
if (!animatorValidated)
{
EditorGUILayout.HelpBox("This Component needs to be placed next to an Animator Component", MessageType.Error);
return;
}
GUILayout.BeginVertical(EditorStyles.helpBox);
List <MLPASAnimatorSFX> validatedAnimatorSfxes = new List <MLPASAnimatorSFX>();
foreach (var i in anim.GetBehaviours <MLPASAnimatorSFX>())
{
if (!validatedAnimatorSfxes.Contains(i))
{
validatedAnimatorSfxes.Add(i);
}
}
Color color_default = GUI.backgroundColor;
GUIStyle itemStyle = new GUIStyle(GUI.skin.box); //make a new GUIStyle
itemStyle.alignment = TextAnchor.MiddleLeft; //align text to the left
itemStyle.active.background = itemStyle.normal.background; //gets rid of button click background style.
itemStyle.margin = new RectOffset(0, 0, 0, 0); //removes the space between items (previously there was a small gap between GUI which made it harder to select a desired item)
itemStyle.font = EditorStyles.miniFont;
itemStyle.fontSize = 10;
itemStyle.fixedWidth = 0;
itemStyle.stretchWidth = true;
itemStyle.wordWrap = true;
itemStyle.richText = true;
itemStyle.normal.textColor = EditorGUIUtility.isProSkin ? new Color(0.8f, 0.8f, 0.8f) : Color.black;
itemStyle.hover.textColor = itemStyle.normal.textColor;
itemStyle.active.textColor = itemStyle.normal.textColor;
itemStyle.focused.textColor = itemStyle.normal.textColor;
itemStyle.normal.background = uiBack;
itemStyle.hover.background = uiBack;
itemStyle.active.background = uiBack;
itemStyle.focused.background = uiBack;
if (validatedAnimatorSfxes.Count > 0)
{
GUILayout.BeginVertical(EditorStyles.helpBox);
for (int i = 0; i < validatedAnimatorSfxes.Count; i++)
{
// Color font_default = GUI.color;
GUI.backgroundColor = (selectedIndexStateM == i) ? color_selected : new Color(1, 1, 1, 0.25f);
if (EditorGUIUtility.isProSkin)
{
GUI.backgroundColor = (selectedIndexStateM == i) ? colorPro_selected : new Color(0.25f, 0.25f, 0.25f, 0.25f);
}
// GUI.color = (selectedIndex == i) ? font_selected : font_default;
string layerName = "";
for (int iL = 0; iL < anim.layers.Length; iL++)
{
if (iL == validatedAnimatorSfxes[i].transitionLayer)
{
layerName = anim.layers[iL].name;
}
}
string buttonName = "L: " + layerName + " | " + (validatedAnimatorSfxes[i].currentState != null ? "S: " + validatedAnimatorSfxes[i].currentState.name : "SM: " + validatedAnimatorSfxes[i].currentStateMachine.name);
if (GUILayout.Button(buttonName, itemStyle))
{
selectedIndexStateM = i;
if (prevSelectedIndexStateM != selectedIndexStateM)
{
Repaint();
prevSelectedIndexStateM = selectedIndexStateM;
EditorGUI.FocusTextInControl(null);
}
valuesModified = true;
}
GUI.backgroundColor = color_default; //this is to avoid affecting other GUIs outside of the list
}
GUILayout.EndVertical();
if (EditorApplication.isPlaying)
{
GUI.enabled = false;
}
EditorGUILayout.Space();
MLPASAnimatorSFXController.ValuesOverride newValue = null;
if (!ContainsStateEditor(validatedAnimatorSfxes[selectedIndexStateM], out newValue))
{
newValue = new MLPASAnimatorSFXController.ValuesOverride();
UnityEditor.Animations.StateMachineBehaviourContext[] context = UnityEditor.Animations.AnimatorController.FindStateMachineBehaviourContext(validatedAnimatorSfxes[selectedIndexStateM]);
UnityEditor.Animations.AnimatorState cState = (context[0].animatorObject as UnityEditor.Animations.AnimatorState);
UnityEditor.Animations.AnimatorStateMachine cStateMachine = (context[0].animatorObject as UnityEditor.Animations.AnimatorStateMachine);
string stateName = cState != null ? cState.name : cStateMachine.name;
int layer = context[0].layerIndex;
newValue.layer = layer;
newValue.stateName = stateName;
(obj.targetObject as MLPASAnimatorSFXController).newValues.Add(newValue);
}
BoolField("Use Different Play Position", ref newValue.useDifferentPlayPosition);
if (newValue.useDifferentPlayPosition)
{
TransformField("Play Position Transform", ref newValue.playPosition);
BoolField("Follow Play Position", ref newValue.followPosition);
}
GUILayout.EndVertical();
if (!EditorApplication.isPlaying)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Custom Play Methods", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
customPlayMethodObj = EditorGUILayout.ObjectField(new GUIContent("Target GameObject", ""), customPlayMethodObj, typeof(GameObject), true) as GameObject;
if (customPlayMethodObj != null && EditorUtility.IsPersistent(customPlayMethodObj))
{
customPlayMethodObj = null;
}
List <MLPASAnimatorSFXController.InspectorDelegate> inspectorDelegates = new List <MLPASAnimatorSFXController.InspectorDelegate>();
if (customPlayMethodObj != null)
{
Component[] components = customPlayMethodObj.GetComponents <Component>();
foreach (var item in components)
{
System.Reflection.MethodInfo[] methods = item.GetType().GetMethods();
for (int i = 0; i < methods.Length; i++)
{
System.Reflection.ParameterInfo[] parameters = methods[i].GetParameters();
for (int i2 = 0; i2 < parameters.Length; i2++)
{
if (parameters[i2].ParameterType == typeof(MLPASACustomPlayMethodParameters))
{
MLPASAnimatorSFXController.InspectorDelegate del = new MLPASAnimatorSFXController.InspectorDelegate();
del.methodName = methods[i].Name;
del.target = item;
inspectorDelegates.Add(del);
break;
}
}
}
}
string[] methodNames = new string[inspectorDelegates.Count];
for (int i = 0; i < inspectorDelegates.Count; i++)
{
methodNames[i] = i.ToString() + " - " + inspectorDelegates[i].methodName + " (MLPASACustomPlayMethodParameters)";
}
if (inspectorDelegates.Count > 0)
{
playMethodIndex = EditorGUILayout.Popup(playMethodIndex, methodNames);
bool alreadyExists = false;
foreach (var item in (obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates)
{
if (item.methodName == inspectorDelegates[playMethodIndex].methodName)
{
alreadyExists = true;
break;
}
}
bool prevGuiEnabled = GUI.enabled;
GUI.enabled = !alreadyExists;
Color prevBackground = GUI.backgroundColor;
GUI.backgroundColor = new Color(0.35f, 0.8f, 0.95f);
if (GUILayout.Button(alreadyExists ? inspectorDelegates[playMethodIndex].methodName + " Already Exists" : "Add Custom Play Method", EditorStyles.miniButton))
{
if ((obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates == null)
{
(obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates = new List <MLPASAnimatorSFXController.InspectorDelegate>();
}
(obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates.Add(inspectorDelegates[playMethodIndex]);
valuesModified = true;
}
GUI.backgroundColor = prevBackground;
GUI.enabled = prevGuiEnabled;
}
else
{
playMethodIndex = 0;
EditorGUILayout.LabelField("No methods found", EditorStyles.miniLabel);
bool prevGuiEnabled = GUI.enabled;
GUI.enabled = false;
Color prevBackground = GUI.backgroundColor;
GUI.backgroundColor = new Color(0.35f, 0.8f, 0.95f);
GUILayout.Button("Select Another GameObject", EditorStyles.miniButton);
GUI.backgroundColor = prevBackground;
GUI.enabled = prevGuiEnabled;
}
}
else
{
bool prevGuiEnabled = GUI.enabled;
GUI.enabled = false;
Color prevBackground = GUI.backgroundColor;
GUI.backgroundColor = new Color(0.35f, 0.8f, 0.95f);
GUILayout.Button("Select a GameObject", EditorStyles.miniButton);
GUI.backgroundColor = prevBackground;
GUI.enabled = prevGuiEnabled;
}
EditorGUILayout.EndVertical();
for (int i = 0; i < (obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates.Count; i++)
{
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
bool prevGuiEnabled = GUI.enabled;
GUI.enabled = false;
if ((obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates[i].target == null)
{
EditorGUILayout.ObjectField("Target GameObject", null, typeof(GameObject), true);
}
else
{
EditorGUILayout.ObjectField("Target GameObject", (obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates[i].target.gameObject, typeof(GameObject), true);
}
if (!(obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates[i].removed)
{
EditorGUILayout.Popup(0, new string[] { (obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates[i].methodName + " (MLPASACustomPlayMethodParameters)" });
}
else
{
EditorGUILayout.Popup(0, new string[] { (obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates[i].methodName + " | MISSING" });
}
GUI.enabled = prevGuiEnabled;
Color prevBackground = GUI.backgroundColor;
GUI.backgroundColor = new Color(1f, 0.35f, 0.38f);
if (GUILayout.Button("Remove Play Method", EditorStyles.miniButton))
{
(obj.targetObject as MLPASAnimatorSFXController).inspectorDelegates.RemoveAt(i);
valuesModified = true;
}
GUI.backgroundColor = prevBackground;
EditorGUILayout.EndVertical();
}
}
if (valuesModified && !dirty)
{
dirty = true;
valuesModified = false;
if (!EditorApplication.isPlaying)
{
SetObjectDirty((obj.targetObject as MLPASAnimatorSFXController));
}
}
}
else
{
EditorGUILayout.HelpBox("The 'Animator' Next to this 'MLPASAnimatorSFXController' doesn't have any 'MLPASAnimatorSFX' State Machine Behaviour", MessageType.Warning);
GUILayout.EndVertical();
return;
}
GUI.enabled = true;
if (EditorApplication.isPlaying)
{
EditorGUILayout.Space();
bool nullMethods = true;
EditorGUILayout.LabelField("Registered Custom Play Methods", EditorStyles.boldLabel);
foreach (var item in (obj.targetObject as MLPASAnimatorSFXController).customPlayMethods)
{
if (item.Value != null)
{
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
GUI.enabled = false;
Component comp = ((item.Value.Target) as Component);
if (comp != null)
{
nullMethods = false;
}
EditorGUILayout.ObjectField("Target GameObject", comp != null ? comp.gameObject : null, typeof(GameObject), true);
if (comp != null)
{
EditorGUILayout.Popup(0, new string[] { item.Value.Method.Name + " (MLPASACustomPlayMethodParameters)" });
}
else
{
EditorGUILayout.Popup(0, new string[] { item.Value.Method.Name + " | MISSING" });
}
GUI.enabled = true;
EditorGUILayout.EndVertical();
}
}
if (nullMethods)
{
EditorGUILayout.LabelField("No methods found");
}
}
obj.ApplyModifiedProperties();
}
void OnGUI()
{
EditorGUILayout.LabelField("target clip");
EditorGUI.BeginChangeCheck();
controller = EditorGUILayout.ObjectField(controller, typeof(UnityEditor.Animations.AnimatorController), false) as UnityEditor.Animations.AnimatorController;
if (EditorGUI.EndChangeCheck())
{
RefleshClipList(controller);
}
if (controller == null)
{
return;
}
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Type a new clip name", MessageType.None);
EditorGUILayout.BeginVertical("box");
clipName = EditorGUILayout.TextField(clipName);
if (clipList.Exists(item => item.name == clipName) || string.IsNullOrEmpty(clipName))
{
//EditorGUILayout.LabelField ("can't create duplicate name or empty");
}
else
{
if (GUILayout.Button("Add Clip"))
{
AddClip(clipName);
clipName = string.Empty;
RefleshClipList(controller);
Repaint();
}
}
EditorGUILayout.EndVertical();
if (clipList.Count == 0)
{
return;
}
EditorGUILayout.Space();
using (var scrollView = new EditorGUILayout.ScrollViewScope(scroll)) {
scroll = scrollView.scrollPosition;
EditorGUILayout.HelpBox("clips", MessageType.None);
EditorGUILayout.BeginVertical("box");
foreach (var removeClip in clipList.ToArray())
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(removeClip.name);
if (GUILayout.Button("Remove Clip", GUILayout.Width(100)))
{
RemoveClip(removeClip);
RefleshClipList(controller);
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
}
}
protected void DrawPressProperties()
{
EditorGUILayout.LabelField("Pressed State Properties", EditorStyles.boldLabel);
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.pressTargetGraphicProperty, new GUIContent("Target Graphic"));
EditorGUILayout.PropertyField(this.pressTransitionProperty, new GUIContent("Transition"));
Graphic graphic = this.pressTargetGraphicProperty.objectReferenceValue as Graphic;
UISlotBase.Transition transition = (UISlotBase.Transition) this.pressTransitionProperty.enumValueIndex;
if (transition != UISlotBase.Transition.None)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
if (transition == UISlotBase.Transition.ColorTint)
{
if (graphic == null)
{
EditorGUILayout.HelpBox("You must have a Graphic target in order to use a color transition.", MessageType.Info);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.pressNormalColorProperty, new GUIContent("Normal"));
if (EditorGUI.EndChangeCheck())
{
graphic.canvasRenderer.SetColor(this.pressNormalColorProperty.colorValue);
}
EditorGUILayout.PropertyField(this.pressPressColorProperty, new GUIContent("Pressed"));
EditorGUILayout.PropertyField(this.pressTransitionDurationProperty, new GUIContent("Duration"));
EditorGUIUtility.labelWidth = 150f;
EditorGUILayout.PropertyField(this.pressTransitionInstaOutProperty, new GUIContent("Instant Out"));
EditorGUIUtility.labelWidth = 120f;
}
}
else if (transition == UISlotBase.Transition.SpriteSwap)
{
if (graphic as Image == null)
{
EditorGUILayout.HelpBox("You must have a Image target in order to use a sprite swap transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.pressOverrideSpriteProperty, new GUIContent("Override Sprite"));
}
}
else if (transition == UISlotBase.Transition.Animation)
{
if (graphic == null)
{
EditorGUILayout.HelpBox("You must have a Graphic target in order to use a animation transition.", MessageType.Info);
}
else
{
EditorGUILayout.PropertyField(this.pressNormalTriggerProperty, new GUIContent("Normal"));
EditorGUILayout.PropertyField(this.pressPressTriggerProperty, new GUIContent("Pressed"));
Animator animator = graphic.gameObject.GetComponent <Animator>();
if (animator == null || animator.runtimeAnimatorController == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = this.GeneratePressAnimatorController();
if (animatorController != null)
{
if (animator == null)
{
animator = graphic.gameObject.AddComponent <Animator>();
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, animatorController);
}
}
}
}
}
EditorGUIUtility.labelWidth = 150f;
EditorGUILayout.PropertyField(this.pressForceHoverNormalProperty, new GUIContent("Force Hover Normal"));
EditorGUIUtility.labelWidth = 120f;
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
private void DrawTargetImageProperties()
{
bool newState = EditorGUILayout.Foldout(this.showImageProperties, "Image Target Properties", this.m_FoldoutStyle);
if (newState != this.showImageProperties)
{
EditorPrefs.SetBool(PREFS_KEY + "1", newState);
this.showImageProperties = newState;
}
if (this.showImageProperties)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
EditorGUILayout.PropertyField(this.m_ImageTargetProperty);
// Check if image is set
if (this.m_ImageTargetProperty.objectReferenceValue != null)
{
Image image = (this.m_ImageTargetProperty.objectReferenceValue as Image);
EditorGUILayout.PropertyField(this.m_ImageTransitionProperty);
// Get the selected transition
Selectable.Transition transition = (Selectable.Transition) this.m_ImageTransitionProperty.enumValueIndex;
if (transition != Selectable.Transition.None)
{
EditorGUI.indentLevel = (EditorGUI.indentLevel + 1);
if (transition == Selectable.Transition.ColorTint)
{
EditorGUILayout.PropertyField(this.m_ImageColorsProperty);
}
else if (transition == Selectable.Transition.SpriteSwap)
{
EditorGUILayout.PropertyField(this.m_ImageSpriteStateProperty);
}
else if (transition == Selectable.Transition.Animation)
{
EditorGUILayout.PropertyField(this.m_ImageAnimationTriggersProperty);
Animator animator = image.gameObject.GetComponent <Animator>();
if (animator == null || animator.runtimeAnimatorController == null)
{
Rect controlRect = EditorGUILayout.GetControlRect();
controlRect.xMin = (controlRect.xMin + EditorGUIUtility.labelWidth);
if (GUI.Button(controlRect, "Auto Generate Animation", EditorStyles.miniButton))
{
// Generate the animator controller
UnityEditor.Animations.AnimatorController animatorController = UIAnimatorControllerGenerator.GenerateAnimatorContoller(this.m_ImageAnimationTriggersProperty, this.target.name);
if (animatorController != null)
{
if (animator == null)
{
animator = image.gameObject.AddComponent <Animator>();
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animator, animatorController);
}
}
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
}
EditorGUI.indentLevel = (EditorGUI.indentLevel - 1);
}
}
/// <summary>
/// New way to create sub-state machines without destroying what exists first.
/// </summary>
protected override void CreateStateMachine()
{
int rLayerIndex = mMotionLayer._AnimatorLayerIndex;
MotionController rMotionController = mMotionController;
UnityEditor.Animations.AnimatorController lController = null;
Animator lAnimator = rMotionController.Animator;
if (lAnimator == null)
{
lAnimator = rMotionController.gameObject.GetComponent <Animator>();
}
if (lAnimator != null)
{
lController = lAnimator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
}
if (lController == null)
{
return;
}
while (lController.layers.Length <= rLayerIndex)
{
UnityEditor.Animations.AnimatorControllerLayer lNewLayer = new UnityEditor.Animations.AnimatorControllerLayer();
lNewLayer.name = "Layer " + (lController.layers.Length + 1);
lNewLayer.stateMachine = new UnityEditor.Animations.AnimatorStateMachine();
lController.AddLayer(lNewLayer);
}
UnityEditor.Animations.AnimatorControllerLayer lLayer = lController.layers[rLayerIndex];
UnityEditor.Animations.AnimatorStateMachine lLayerStateMachine = lLayer.stateMachine;
UnityEditor.Animations.AnimatorStateMachine lSSM_N237494 = MotionControllerMotion.EditorFindSSM(lLayerStateMachine, "BasicDeath-SM");
if (lSSM_N237494 == null)
{
lSSM_N237494 = lLayerStateMachine.AddStateMachine("BasicDeath-SM", new Vector3(192, -912, 0));
}
UnityEditor.Animations.AnimatorState lState_N247470 = MotionControllerMotion.EditorFindState(lSSM_N237494, "Unarmed Death 0");
if (lState_N247470 == null)
{
lState_N247470 = lSSM_N237494.AddState("Unarmed Death 0", new Vector3(324, -72, 0));
}
lState_N247470.speed = 1.5f;
lState_N247470.mirror = false;
lState_N247470.tag = "";
lState_N247470.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/Assets/MotionController/Content/Animations/Humanoid/Utilities/Utilities_01.fbx", "DeathBackward");
UnityEditor.Animations.AnimatorState lState_N247472 = MotionControllerMotion.EditorFindState(lSSM_N237494, "Unarmed Death 180");
if (lState_N247472 == null)
{
lState_N247472 = lSSM_N237494.AddState("Unarmed Death 180", new Vector3(324, -24, 0));
}
lState_N247472.speed = 1.8f;
lState_N247472.mirror = false;
lState_N247472.tag = "";
lState_N247472.motion = MotionControllerMotion.EditorFindAnimationClip("Assets/ootii/Assets/MotionController/Content/Animations/Humanoid/Utilities/Utilities_01.fbx", "DeathForward");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N299372 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N247470, 0);
if (lAnyTransition_N299372 == null)
{
lAnyTransition_N299372 = lLayerStateMachine.AddAnyStateTransition(lState_N247470);
}
lAnyTransition_N299372.isExit = false;
lAnyTransition_N299372.hasExitTime = false;
lAnyTransition_N299372.hasFixedDuration = true;
lAnyTransition_N299372.exitTime = 0.75f;
lAnyTransition_N299372.duration = 0.1f;
lAnyTransition_N299372.offset = 0.115787f;
lAnyTransition_N299372.mute = false;
lAnyTransition_N299372.solo = false;
lAnyTransition_N299372.canTransitionToSelf = true;
lAnyTransition_N299372.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N299372.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N299372.RemoveCondition(lAnyTransition_N299372.conditions[i]);
}
lAnyTransition_N299372.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3375f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N299372.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 0f, "L" + rLayerIndex + "MotionForm");
lAnyTransition_N299372.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Greater, -100f, "L" + rLayerIndex + "MotionParameter");
lAnyTransition_N299372.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Less, 100f, "L" + rLayerIndex + "MotionParameter");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N299806 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N247472, 0);
if (lAnyTransition_N299806 == null)
{
lAnyTransition_N299806 = lLayerStateMachine.AddAnyStateTransition(lState_N247472);
}
lAnyTransition_N299806.isExit = false;
lAnyTransition_N299806.hasExitTime = false;
lAnyTransition_N299806.hasFixedDuration = true;
lAnyTransition_N299806.exitTime = 0.75f;
lAnyTransition_N299806.duration = 0.1f;
lAnyTransition_N299806.offset = 0.115787f;
lAnyTransition_N299806.mute = false;
lAnyTransition_N299806.solo = false;
lAnyTransition_N299806.canTransitionToSelf = true;
lAnyTransition_N299806.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N299806.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N299806.RemoveCondition(lAnyTransition_N299806.conditions[i]);
}
lAnyTransition_N299806.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3375f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N299806.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 0f, "L" + rLayerIndex + "MotionForm");
lAnyTransition_N299806.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Greater, 100f, "L" + rLayerIndex + "MotionParameter");
UnityEditor.Animations.AnimatorStateTransition lAnyTransition_N300182 = MotionControllerMotion.EditorFindAnyStateTransition(lLayerStateMachine, lState_N247472, 1);
if (lAnyTransition_N300182 == null)
{
lAnyTransition_N300182 = lLayerStateMachine.AddAnyStateTransition(lState_N247472);
}
lAnyTransition_N300182.isExit = false;
lAnyTransition_N300182.hasExitTime = false;
lAnyTransition_N300182.hasFixedDuration = true;
lAnyTransition_N300182.exitTime = 0.75f;
lAnyTransition_N300182.duration = 0.1f;
lAnyTransition_N300182.offset = 0.115787f;
lAnyTransition_N300182.mute = false;
lAnyTransition_N300182.solo = false;
lAnyTransition_N300182.canTransitionToSelf = true;
lAnyTransition_N300182.interruptionSource = (UnityEditor.Animations.TransitionInterruptionSource) 0;
for (int i = lAnyTransition_N300182.conditions.Length - 1; i >= 0; i--)
{
lAnyTransition_N300182.RemoveCondition(lAnyTransition_N300182.conditions[i]);
}
lAnyTransition_N300182.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 3375f, "L" + rLayerIndex + "MotionPhase");
lAnyTransition_N300182.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Equals, 0f, "L" + rLayerIndex + "MotionForm");
lAnyTransition_N300182.AddCondition(UnityEditor.Animations.AnimatorConditionMode.Less, -100f, "L" + rLayerIndex + "MotionParameter");
#if USE_ARCHERY_MP || OOTII_AYMP
ArcheryPackDefinition.ExtendBasicDeath(rMotionController, rLayerIndex);
#endif
#if USE_SWORD_SHIELD_MP || OOTII_SSMP
SwordShieldPackDefinition.ExtendBasicDeath(rMotionController, rLayerIndex);
#endif
#if USE_SPELL_CASTING_MP || OOTII_SCMP
//SpellCastingPackDefinition.ExtendBasicDeath(rMotionController, rLayerIndex);
#endif
// Run any post processing after creating the state machine
OnStateMachineCreated();
}
/// <summary>
/// Adds the abilities states/transitions to the animator.
/// </summary>
/// <param name="animatorController">The Animator Controller to add the states to.</param>
/// <param name="firstPersonAnimatorController">The first person Animator Controller to add the states to.</param>
public virtual void BuildAnimator(UnityEditor.Animations.AnimatorController animatorController, UnityEditor.Animations.AnimatorController firstPersonAnimatorController)
{
}
void IStateEditoHelper.CopyParamsFrom(UnityEditor.Animations.AnimatorController animatorToCpyParametersfrom)
{
// This SHould Be in IState!
if (animatorToCpyParametersfrom != null)
{
editorHelperDictionary.Clear();
editorHelperList.Clear();
editorHelperList.AddRange(parameters);
foreach (var item in editorHelperList)
{
editorHelperDictionary.Add(item.keyName, item);
}
// Save previous
var dictCopy = new Dictionary <string, AnimationParamSerialiazable>();
foreach (var item in editorHelperDictionary)
{
var copy = new AnimationParamSerialiazable();
item.Value.CopyTo(copy);
dictCopy.Add(item.Value.keyName, copy);
}
editorHelperList.Clear();
AnimationParamSerialiazable temporalParam = null;
for (int i = 0; i < animatorToCpyParametersfrom.parameters.Length; i++)
{
if (!editorHelperDictionary.TryGetValue(animatorToCpyParametersfrom.parameters[i].name, out temporalParam))
{
temporalParam = new AnimationParamSerialiazable();
}
temporalParam.boolValue = animatorToCpyParametersfrom.parameters[i].defaultBool;
temporalParam.floatValue = animatorToCpyParametersfrom.parameters[i].defaultFloat;
temporalParam.intValue = animatorToCpyParametersfrom.parameters[i].defaultInt;
temporalParam.keyName = animatorToCpyParametersfrom.parameters[i].name;
temporalParam.nameHash = animatorToCpyParametersfrom.parameters[i].nameHash;
switch (animatorToCpyParametersfrom.parameters[i].type)
{
case AnimatorControllerParameterType.Float:
temporalParam.type = AnimationParamSerialiazable.AnimationType.Float;
break;
case AnimatorControllerParameterType.Int:
temporalParam.type = AnimationParamSerialiazable.AnimationType.Int;
break;
case AnimatorControllerParameterType.Bool:
temporalParam.type = AnimationParamSerialiazable.AnimationType.Bool;
break;
case AnimatorControllerParameterType.Trigger:
temporalParam.type = AnimationParamSerialiazable.AnimationType.Trigger;
break;
}
if (dictCopy.TryGetValue(animatorToCpyParametersfrom.parameters[i].name, out var prevValue) &&
prevValue != null)
{
temporalParam.boolValue = prevValue.boolValue;
temporalParam.floatValue = prevValue.floatValue;
temporalParam.intValue = prevValue.intValue;
}
editorHelperList.Add(temporalParam);
}
parameters = editorHelperList.ToArray();
}
}
