| public AddItem ( string header ) : TreeViewItem, | ||
| header | string | |
| return | TreeViewItem, | |
TreeViewItem AddPathToTreeItem(TreeViewItem item, AkWwiseProjectData.AkInformation AkInfo)
{
TreeViewItem parentItem = item;
string path = "/" + RootItem.Header + "/" + item.Header;
for (int i = 0; i < AkInfo.PathAndIcons.Count; i++)
{
AkWwiseProjectData.PathElement PathElem = AkInfo.PathAndIcons[i];
TreeViewItem childItem = parentItem.FindItemByName(PathElem.ElementName);
path = path + "/" + PathElem.ElementName;
if (childItem == null)
{
if (i != AkInfo.PathAndIcons.Count - 1)
{
childItem = parentItem.AddItem(PathElem.ElementName, new AkTreeInfo(0, Guid.Empty.ToByteArray(), PathElem.ObjectType), GetExpansionStatus(path));
}
else
{
bool isDraggable = !(PathElem.ObjectType == AkWwiseProjectData.WwiseObjectType.STATEGROUP || PathElem.ObjectType == AkWwiseProjectData.WwiseObjectType.SWITCHGROUP);
childItem = parentItem.AddItem(PathElem.ElementName, isDraggable, GetExpansionStatus(path), new AkTreeInfo(AkInfo.ID, AkInfo.Guid, PathElem.ObjectType));
}
}
AddHandlerEvents(childItem);
parentItem = childItem;
}
return(parentItem);
}
/// <summary>
/// 添加技能
/// </summary>
TreeViewItem AddSkill(TreeViewItem parent, int skillId, bool createAsset = false)
{
try
{
//技能节点的数据
ItemData itemData = new ItemData();
itemData.resPath = ResPath + skillId + "/Skill";
itemData.type = ItemType.Skill;
//增加技能节点
TreeViewItem item = parent.AddItem(skillId.ToString());
item.DataContext = itemData;
AddEvents(item);
if (createAsset)
{
Skill skill = ScriptableObject.CreateInstance <Skill>();
skill.ID = skillId;
skillTable.Add(skill.ID, skill);
AssetEditor.CreateAsset(skill, FixedPath + skillId, "Skill");
TreeViewItem activeEventItem = AddEvent(item, "ActiveEvent", true);
AddAction(activeEventItem, "AnimationAction", true);
AddAction(activeEventItem, "FinishAction", true);
AddEvent(item, "AnimEvent", true);
}
return(item);
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return(null);
}
/// <summary>
/// 添加技能
/// </summary>
/// <param name="newSkillId">技能id</param>
/// <param name="isCreateAsset">是否创建新的资源</param>
static TreeViewItem AddSkill(int newSkillId, bool isCreateAsset = true)
{
Skill skill = ScriptableObject.CreateInstance <Skill>();
_skillDic[skill.skillId] = skill;
skill.skillId = newSkillId;
if (isCreateAsset)
{
AssetEditor.CreateAsset(skill, FixPath + newSkillId, "Skill");
}
TreeViewItem skillItem = _root.AddItem(newSkillId.ToString());
SkillBase data = new SkillBase();
data.type = ItemType.Root;
data.resPath = ResPath + newSkillId + "/Skill";
data.skillId = newSkillId;
skillItem.DataContext = data;
AddEvents(skillItem);
if (isCreateAsset)
{
TreeViewItem evtItem = AddSkillEventNode(skillItem, SkillEventType.ActiveEvent.ToString());
if (evtItem != null)
{
AddSkillAction(evtItem, "PlayAnimator");
AddSkillAction(evtItem, "FinishSkill");
}
AddSkillEventNode(skillItem, SkillEventType.AnimaEvent.ToString());
}
return(skillItem);
}
/// <summary>
/// 添加事件
/// </summary>
/// <param name="item">父节点</param>
/// <param name="name">事件名</param>
/// <param name="isCreateAsset">是否创建新的资源</param>
/// <returns></returns>
static TreeViewItem AddSkillEventNode(TreeViewItem item, string name, bool isCreateAsset = true)
{
if (name == String.Empty)
{
return(null);
}
Skill skill = RegetditSkill(item);
if (skill == null)
{
return(null);
}
string evtName = name;
Assembly ass = typeof(SkillEvent).Assembly;
string[] nameList = name.Split('_');
System.Type type = ass.GetType(nameList[0]);
SkillEvent evt = System.Activator.CreateInstance(type) as SkillEvent;
SkillBase evtData = new SkillBase();
if (evt is ActiveEvent)
{
if (isCreateAsset)
{
skill.activeEvent.Add(evt as ActiveEvent);
}
}
else
{
if (skill.animaEvent.Count > 0)
{
evtName = name + "_" + skill.animaEvent.Count;
}
if (isCreateAsset)
{
skill.animaEvent.Add(evt as AnimaEvent);
}
}
if (isCreateAsset)
{
AssetEditor.CreateAsset(evt, FixPath + skill.skillId + "/" + evtName, evtName);
}
else
{
evtName = name;
}
TreeViewItem evtItem = item.AddItem(evtName);
evtData.type = ItemType.SkillEvent;
evtData.skillId = skill.skillId;
evtData.resPath = ResPath + skill.skillId + "/" + evtName + "/" + evtName;
evtItem.DataContext = evtData;
AddEvents(evtItem);
EditorUtility.SetDirty(skill);
return(evtItem);
}
public static void PopulateExampleData(TreeViewControl item)
{
item.Width = 600;
item.Height = 500;
item.Header = "Example.cs populated this treeview control";
AddEvents(item.RootItem);
TreeViewItem item1 = item.RootItem.AddItem("You can also add a tree view control");
AddEvents(item1);
AddEvents(item1.AddItem("to any existing game object by"));
AddEvents(item1.AddItem("selecting the game object and"));
AddEvents(item1.AddItem("using the menu item"));
TreeViewItem games = item1.AddItem("TreeView->Add Tree View to selected.", false);
AddEvents(games);
AddEvents(games.AddItem("You can also drag and drop the"));
AddEvents(games.AddItem("TreeViewControl script onto a"));
AddEvents(games.AddItem("game object."));
AddEvents(games.AddItem("New checked and", false, true));
AddEvents(games.AddItem("unchecked checkboxes", false, false));
}
/// <summary>
/// 添加技能action
/// </summary>
/// <param name="item">父节点</param>
/// <param name="name">action名</param>
/// <param name="isCreateAsset">是否创建新资源</param>
static void AddSkillAction(TreeViewItem item, string name, bool isCreateAsset = true)
{
SkillBase data = item.DataContext as SkillBase;
SkillBase actData = new SkillBase();
Skill skill = RegetditSkill(item);
SkillEvent evt = Resources.Load(data.resPath) as SkillEvent;
if (skill == null || evt == null)
{
return;
}
Assembly ass = typeof(SkillAction).Assembly;
string[] nameList = name.Split('_');
System.Type type = ass.GetType(nameList[0]);
SkillAction act = System.Activator.CreateInstance(type) as SkillAction;
string actName = name;
int num = 0;
foreach (var act2 in evt.skillActions)
{
if (act2.name.StartsWith(name))
{
num++;
}
}
if (num > 0)
{
actName = actName + "_" + num;
}
if (isCreateAsset)
{
evt.skillActions.Add(act);
AssetEditor.CreateAsset(act, FixPath + skill.skillId + "/" + evt.name + "/SkillAction", actName);
}
else
{
actName = name;
}
TreeViewItem evtItem = item.AddItem(actName);
actData.type = ItemType.SkillAction;
actData.skillId = skill.skillId;
actData.resPath = ResPath + skill.skillId + "/" + evt.name + "/SkillAction/" + actName;
evtItem.DataContext = actData;
AddEvents(evtItem);
EditorUtility.SetDirty(evt);
EditorUtility.SetDirty(skill);
}
public void PopulateItem(TreeViewItem attachTo, string itemName, List <AkWwiseProjectData.AkInfoWorkUnit> workUnits)
{
TreeViewItem attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName), new AkTreeInfo(0, AkWwiseProjectData.WwiseObjectType.PHYSICALFOLDER));
foreach (AkWwiseProjectData.AkInfoWorkUnit wwu in workUnits)
{
foreach (AkWwiseProjectData.AkInformation akInfo in wwu.List)
{
AddHandlerEvents(AddPathToTreeItem(attachPoint, akInfo));
}
}
AddHandlerEvents(attachPoint);
}
TreeViewItem AddEvent(TreeViewItem parent, string type, bool createAsset = false)
{
try
{
int skillId = (parent.DataContext as ItemData).skillId;
string name = type;
if (createAsset)
{
Skill skill = skillTable[skillId];
Assembly ass = typeof(SkillEvent).Assembly;
SkillEvent skillEvent = System.Activator.CreateInstance(ass.GetType(type)) as SkillEvent;
if (skillEvent is ActiveEvent)
{
name = "ActiveEvent";
skill.ActiveEvents.Add(skillEvent as ActiveEvent);
}
else
{
if (skill.AnimEvents.Count > 0)
{
name = type + skill.AnimEvents.Count;
}
else
{
name = type;
}
skill.AnimEvents.Add(skillEvent as AnimEvent);
}
AssetEditor.CreateAsset(skillEvent, FixedPath + skillId + "/" + name, name);
EditorUtility.SetDirty(skill);
}
ItemData itemData = new ItemData();
itemData.resPath = ResPath + skillId + "/" + name + "/" + name;
itemData.type = ItemType.Event;
TreeViewItem item = parent.AddItem(name);
item.Header = name;
item.DataContext = itemData;
AddEvents(item);
return(item);
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return(null);
}
public void PopulateItem(TreeViewItem attachTo, string itemName,
System.Collections.Generic.List <AkWwiseProjectData.AkInfoWorkUnit> workUnits)
{
var attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName),
new AkTreeInfo(WwiseObjectType.PhysicalFolder));
foreach (var wwu in workUnits)
{
foreach (var akInfo in wwu.List)
{
AddHandlerEvents(AddPathToTreeItem(attachPoint, akInfo));
}
}
AddHandlerEvents(attachPoint);
}
public void PopulateItem(TreeViewItem attachTo, string itemName, List <AkWwiseProjectData.GroupValWorkUnit> GroupWorkUnits)
{
TreeViewItem attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName), new AkTreeInfo(0, AkWwiseProjectData.WwiseObjectType.PHYSICALFOLDER));
foreach (AkWwiseProjectData.GroupValWorkUnit wwu in GroupWorkUnits)
{
foreach (AkWwiseProjectData.GroupValue group in wwu.List)
{
TreeViewItem groupItem = AddPathToTreeItem(attachPoint, group);
AddHandlerEvents(groupItem);
for (int i = 0; i < group.values.Count; i++)
{
TreeViewItem item = groupItem.AddItem(group.values[i], true, false, new AkTreeInfo(group.valueIDs[i], group.ValueGuids[i].bytes, group.ValueIcons[i].ObjectType));
AddHandlerEvents(item);
}
}
}
AddHandlerEvents(attachPoint);
}
public static void CreateSkill()
{
var id = SelectedItem.ChildItemCount;
var skill = ScriptableObject.CreateInstance <Skill>();
skill.Id = id;
var newItem = SelectedItem.AddItem(id.ToString());
var path = Path + "/" + skill.Id + "/" + "Skill" + ".asset";
newItem.DataContext = new ItemData()
{
SelectedType = SelectedType.Skill,
Path = path,
Name = skill.Id.ToString(),
Data = skill
};
AddEvents(newItem);
CreateFolder(Path, skill.Id.ToString());
AssetDatabase.CreateAsset(skill, path);
}
public static void CreateActionAsset(TreeViewItem parentItem, ActionBase action)
{
var newItem = parentItem.AddItem(action.GetType().Name + (parentItem.ChildItemCount + 1));
var data = parentItem.DataContext as ItemData;
var path = Path + "/" + data.Name;
var Skill = data.Data as Skill;
Skill.Actions.Add(action);
newItem.DataContext = new ItemData()
{
SelectedType = SelectedType.Action,
Path = path + "/Actions/" + action.GetType().Name + parentItem.ChildItemCount + ".asset"
};
AddEvents(newItem);
CreateFolder(path, "Actions");
AssetDatabase.CreateAsset(action,
path + "/Actions/" + action.GetType().Name + parentItem.ChildItemCount + ".asset");
EditorUtility.SetDirty(Skill);
}
public void PopulateItem(TreeViewItem attachTo, string itemName,
System.Collections.Generic.List <AkWwiseProjectData.GroupValWorkUnit> GroupWorkUnits)
{
var attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName),
new AkTreeInfo(WwiseObjectType.PhysicalFolder));
foreach (var wwu in GroupWorkUnits)
{
foreach (var group in wwu.List)
{
var groupItem = AddPathToTreeItem(attachPoint, group);
AddHandlerEvents(groupItem);
foreach (var child in group.values)
{
var item = groupItem.AddItem(child.Name, true, false, new AkTreeInfo(child.Guid, child.PathAndIcons[0].ObjectType));
AddHandlerEvents(item);
}
}
}
AddHandlerEvents(attachPoint);
}
public void PopulateItem(TreeViewItem attachTo, string itemName, List<AkWwiseProjectData.GroupValWorkUnit> GroupWorkUnits)
{
TreeViewItem attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName), new AkTreeInfo(0, AkWwiseProjectData.WwiseObjectType.PHYSICALFOLDER));
foreach (AkWwiseProjectData.GroupValWorkUnit wwu in GroupWorkUnits)
{
foreach(AkWwiseProjectData.GroupValue group in wwu.List)
{
TreeViewItem groupItem = AddPathToTreeItem(attachPoint, group);
AddHandlerEvents(groupItem);
for (int i = 0; i < group.values.Count; i++)
{
TreeViewItem item = groupItem.AddItem(group.values[i], true, false, new AkTreeInfo(group.valueIDs[i], group.ValueGuids[i].bytes, group.ValueIcons[i].ObjectType));
AddHandlerEvents(item);
}
}
}
AddHandlerEvents(attachPoint);
}
public void PopulateItem(TreeViewItem attachTo, string itemName, List<AkWwiseProjectData.AkInfoWorkUnit> workUnits)
{
TreeViewItem attachPoint = attachTo.AddItem(itemName, false, GetExpansionStatus("/" + RootItem.Header + "/" + itemName), new AkTreeInfo(0, AkWwiseProjectData.WwiseObjectType.PHYSICALFOLDER));
foreach (AkWwiseProjectData.AkInfoWorkUnit wwu in workUnits)
{
foreach(AkWwiseProjectData.AkInformation akInfo in wwu.List)
{
AddHandlerEvents(AddPathToTreeItem(attachPoint, akInfo));
}
}
AddHandlerEvents(attachPoint);
}
/// <summary>
/// 添加技能
/// </summary>
TreeViewItem AddSkill(TreeViewItem parent, int skillId, bool createAsset = false)
{
try
{
//技能节点的数据
ItemData itemData = new ItemData();
itemData.resPath = ResPath + skillId + "/Skill";
itemData.type = ItemType.Skill;
//增加技能节点
TreeViewItem item = parent.AddItem(skillId.ToString());
item.DataContext = itemData;
AddEvents(item);
if (createAsset)
{
Skill skill = ScriptableObject.CreateInstance<Skill>();
skill.ID = skillId;
skillTable.Add(skill.ID, skill);
AssetEditor.CreateAsset(skill, FixedPath + skillId, "Skill");
TreeViewItem activeEventItem = AddEvent(item, "ActiveEvent", true);
AddAction(activeEventItem, "AnimationAction", true);
AddAction(activeEventItem, "FinishAction", true);
AddEvent(item, "AnimEvent", true);
}
return item;
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return null;
}
TreeViewItem AddEvent(TreeViewItem parent, string type, bool createAsset = false)
{
try
{
int skillId = (parent.DataContext as ItemData).skillId;
string name = type;
if (createAsset)
{
Skill skill = skillTable[skillId];
Assembly ass = typeof(SkillEvent).Assembly;
SkillEvent skillEvent = System.Activator.CreateInstance(ass.GetType(type)) as SkillEvent;
if (skillEvent is ActiveEvent)
{
name = "ActiveEvent";
skill.ActiveEvents.Add(skillEvent as ActiveEvent);
}
else
{
if (skill.AnimEvents.Count > 0)
name = type + skill.AnimEvents.Count;
else
name = type;
skill.AnimEvents.Add(skillEvent as AnimEvent);
}
AssetEditor.CreateAsset(skillEvent, FixedPath + skillId + "/" + name, name);
EditorUtility.SetDirty(skill);
}
ItemData itemData = new ItemData();
itemData.resPath = ResPath + skillId + "/" + name + "/" + name;
itemData.type = ItemType.Event;
TreeViewItem item = parent.AddItem(name);
item.Header = name;
item.DataContext = itemData;
AddEvents(item);
return item;
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return null;
}
TreeViewItem AddAction(TreeViewItem parent, string type, bool createAsset = false)
{
try
{
ItemData parentData = parent.DataContext as ItemData;
string name = type;
string[] arr = parentData.resPath.Split('/');
string actionResPath = "";
for (int i = 0; i < arr.Length - 1; i++)
{
actionResPath += arr[i];
actionResPath += "/";
}
if (createAsset)
{
Assembly ass = typeof(SkillAction).Assembly;
SkillAction skillAction = System.Activator.CreateInstance(ass.GetType(type)) as SkillAction;
SkillEvent parentEvent = Resources.Load<SkillEvent>(parentData.resPath);
parentEvent.actions.Add(skillAction);
int count = 0;
foreach (var act in parentEvent.actions)
{
if (act.name.StartsWith(type))
count++;
}
if (count > 0)
skillAction.name = type + count.ToString();
else
skillAction.name = type;
name = skillAction.name;
AssetEditor.CreateAsset(skillAction, "Assets/Resources/" + actionResPath + "Actions", name);
EditorUtility.SetDirty(parentEvent);
}
ItemData itemData = new ItemData();
itemData.resPath = actionResPath + "Actions/" + name;
itemData.type = ItemType.Aciton;
TreeViewItem item = parent.AddItem(name);
item.Header = name;
item.DataContext = itemData;
AddEvents(item);
return item;
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return null;
}
TreeViewItem AddAction(TreeViewItem parent, string type, bool createAsset = false)
{
try
{
ItemData parentData = parent.DataContext as ItemData;
string name = type;
string[] arr = parentData.resPath.Split('/');
string actionResPath = "";
for (int i = 0; i < arr.Length - 1; i++)
{
actionResPath += arr[i];
actionResPath += "/";
}
if (createAsset)
{
Assembly ass = typeof(SkillAction).Assembly;
SkillAction skillAction = System.Activator.CreateInstance(ass.GetType(type)) as SkillAction;
SkillEvent parentEvent = Resources.Load <SkillEvent>(parentData.resPath);
parentEvent.actions.Add(skillAction);
int count = 0;
foreach (var act in parentEvent.actions)
{
if (act.name.StartsWith(type))
{
count++;
}
}
if (count > 0)
{
skillAction.name = type + count.ToString();
}
else
{
skillAction.name = type;
}
name = skillAction.name;
AssetEditor.CreateAsset(skillAction, "Assets/Resources/" + actionResPath + "Actions", name);
EditorUtility.SetDirty(parentEvent);
}
ItemData itemData = new ItemData();
itemData.resPath = actionResPath + "Actions/" + name;
itemData.type = ItemType.Aciton;
TreeViewItem item = parent.AddItem(name);
item.Header = name;
item.DataContext = itemData;
AddEvents(item);
return(item);
}
catch (Exception e)
{
this.ShowNotification(new GUIContent(e.Message));
}
return(null);
}
