public virtual IEnumerable <NodeAsset> Apply(NodeAsset parentNode, INodeAsset node)
{
NodeAsset transformedNode = null;
if (node.Mesh != null)
{
var transformedMaterials = node.Mesh.Materials.Select(Map).ToList();
foreach (var transformedMesh in Map(node.Mesh.Mesh))
{
if (transformedNode != null)
{
yield return(transformedNode);
}
transformedNode = CreateNodeCopy(parentNode, node);
transformedNode.Mesh = new MeshInstance(transformedMesh, transformedMaterials);
}
}
transformedNode = transformedNode ?? CreateNodeCopy(parentNode, node);
if (node.Camera != null)
{
transformedNode.Camera = Map(node.Camera);
}
if (node.Light != null)
{
transformedNode.Light = Map(node.Light);
}
yield return(transformedNode);
}
public static void NodeGraphToolbar(XNode.NodeGraph nodeGraph)
{
Elements.BeginToolbarHorizontal();
if (Elements.ToolbarButton(ToolTips.runPreset))
{
NodeAsset.Parse(nodeGraph);
}
if (Elements.ToolbarButton(ToolTips.deletePreset))
{
if (EditorUtility.DisplayDialog("Delete Preset", "Are you sure you wish to delete this preset? Once deleted it can't be undone.", "Ok", "Cancel"))
{
XNodeEditor.NodeEditorWindow.focusedWindow.Close();
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(nodeGraph));
MapManager.RefreshPresetsList();
}
}
if (Elements.ToolbarButton(ToolTips.renamePreset))
{
XNodeEditor.RenamePreset.Show(nodeGraph);
}
if (Elements.ToolbarButton(ToolTips.presetWiki))
{
Application.OpenURL("https://github.com/RustMapMaking/Rust-Map-Editor-Unity/wiki/Node-System");
}
Elements.EndToolbarHorizontal();
}
public virtual void LoadData(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap)
{
ID = string.IsNullOrEmpty(nodeAsset.ID) ? Guid.NewGuid().ToString() : nodeAsset.ID;
NameField.SetValueWithoutNotify(string.IsNullOrEmpty(nodeAsset.Data.Name) ? DefaultName : nodeAsset.Data.Name);
_speedField.SetValueWithoutNotify(nodeAsset.Data.Speed);
}
public override void GenerateLinkData(NodeAsset nodeAsset, Dictionary <Node, NodeAsset> nodeMap)
{
NodeAsset outputNodeAsset = InputPort.connections.Count() > 0 ? nodeMap[InputPort.connections.First().output.node] : null;
nodeAsset.InputPorts.Add(new NodeInputPortAsset {
SourceNodeAsset = outputNodeAsset, Weight = 1f
});
}
public override void LoadData(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap)
{
base.LoadData(graphView, nodeAsset, nodeMap);
StateMachineNodeAsset = (StateMachineNodeAsset)nodeAsset;
LoadDataWithCallback(graphView, nodeAsset, nodeMap, portAsset => GenerateStatePort(((StateMachineNodeInputPortAsset)portAsset).StateName));
}
private void SaveAnimationGraph()
{
if (AnimationGraphAsset == null)
{
return;
}
AnimationGraphAsset.Nodes.Clear();
Dictionary <Node, NodeAsset> nodeUIMap = new Dictionary <Node, NodeAsset>();
GraphView.nodes.ForEach(n =>
{
if (!(n is BaseNodeUI nodeUI))
{
return;
}
NodeAsset nodeAsset = nodeUI.GenerateData();
nodeAsset.Name = nodeUI.NameField.value;
nodeAsset.ID = nodeUI.ID;
nodeAsset.Position = n.GetPosition().position;
nodeAsset.IsExpanded = n.expanded;
AnimationGraphAsset.Nodes.Add(nodeAsset);
nodeUIMap.Add(n, nodeAsset);
});
GraphView.nodes.ForEach(n =>
{
if (!(n is BaseNodeUI nodeUI))
{
return;
}
nodeUI.GenerateLinkData(nodeUIMap[n], nodeUIMap);
});
if (GraphView.OutputIndicatorNode != null)
{
AnimationGraphAsset.OutputIndicatorNode = new NodeAsset {
Position = GraphView.OutputIndicatorNode.GetPosition().position, IsExpanded = GraphView.OutputIndicatorNode.expanded
};
if (GraphView.OutputNode != null)
{
AnimationGraphAsset.OutputNode = nodeUIMap[GraphView.OutputNode];
}
}
else
{
AnimationGraphAsset.OutputIndicatorNode = null;
AnimationGraphAsset.OutputNode = null;
}
EditorUtility.SetDirty(AnimationGraphAsset);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
private static NodeAsset CreateNodeCopy(NodeAsset parentNode, INodeAsset node)
{
NodeAsset transformedNode;
transformedNode = new NodeAsset(node.Id);
transformedNode.Transform.CopyFrom(node.Transform);
transformedNode.Parent = parentNode;
return(transformedNode);
}
private void AttachChildren(Node node, NodeAsset parentAsset, ReaderContext context)
{
foreach (var childNode in node.VisualChildren)
{
var nodeAsset = (NodeAsset)context.Nodes[childNode.LogicalIndex];
nodeAsset.Parent = parentAsset;
AttachChildren(childNode, nodeAsset, context);
}
}
public static void ShowWindowWithAsset(NodeAsset asset = null)
{
var win = EditorWindow.GetWindow(typeof(TreeNodeWindowEditor)) as TreeNodeWindowEditor;
if (asset != null)
{
win.rootAsset = asset.Value;
win.parse();
}
}
private static void ShowEditor()
{
UnityEngine.Object obj = Selection.activeObject;
string path = AssetDatabase.GetAssetPath(obj);
NodeAsset nodeAsset = AssetDatabase.LoadAssetAtPath <NodeAsset>(path);
Node.SetNodeAsset(nodeAsset, Path.GetFileNameWithoutExtension(path));
TreeNodeEditor.ShowWindow();
}
public override void GenerateLinkData(NodeAsset nodeAsset, Dictionary <Node, NodeAsset> nodeMap)
{
nodeAsset.InputPorts.Clear();
StatePorts.ForEach(p =>
{
NodeAsset outputNodeAsset = p.connections.Count() > 0 ? nodeMap[p.connections.First().output.node] : null;
nodeAsset.InputPorts.Add(new StateMachineNodeInputPortAsset {
SourceNodeAsset = outputNodeAsset, Weight = 0f, StateName = p.portName
});
});
}
private void ApplyOnSubtree(NodeAsset transformedParent, INodeAsset node)
{
NodeAsset parent = null;
foreach (var transformedNode in Apply(transformedParent, node))
{
parent = transformedNode;
}
if (parent != null)
{
foreach (var childNode in node.ChildNodes)
{
ApplyOnSubtree(parent, childNode);
}
}
}
public static void CreateAsset(NodeValue nodeValue, string fileName)
{
// 实例化类 Bullet
ScriptableObject nodeAsset = ScriptableObject.CreateInstance <NodeAsset>();
// 如果实例化 Bullet 类为空，返回
if (!nodeAsset)
{
Debug.LogWarning("Bullet not found");
return;
}
fileName = string.IsNullOrEmpty(fileName) ? (typeof(NodeAsset).ToString()) : fileName;
// 自定义资源保存路径
//将类名 Bullet 转换为字符串
//拼接保存自定义资源（.asset） 路径
string path = string.Format("Assets/Resources/NodeAsset/{0}.asset", fileName);
if (File.Exists(path))
{
if (!EditorUtility.DisplayDialog("已存在文件", "是否替换新文件", "替换", "取消"))
{
return;
}
}
// 如果项目总不包含该路径，创建一个
string directory = Path.GetDirectoryName(path);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
NodeAsset node = (NodeAsset)nodeAsset;
node.nodeValue = nodeValue;
EditorUtility.SetDirty(nodeAsset);
// 生成自定义资源到指定路径
AssetDatabase.CreateAsset(nodeAsset, path);
EditorUtility.SetDirty(nodeAsset);
AssetDatabase.Refresh();
}
public NodeRoot GetNode(NodeAsset nodeAsset)
{
NodeValue nodeValue = nodeAsset.nodeValue;
if (nodeValue == null)
{
Debug.LogError("RootNode is null");
return(null);
}
NodeRoot rootNode = GetNodeRoot(nodeValue);
if (rootNode.GetType().IsSubclassOf(typeof(NodeCombiner)))
{
IterationChild((NodeCombiner)rootNode, nodeValue);
}
return(rootNode);
}
private INodeAsset TransformNode(Node node, string id, ReaderContext context)
{
var nodeAsset = new NodeAsset(id);
nodeAsset.Transform.Matrix = node.LocalMatrix;
if (node.Mesh != null)
{
nodeAsset.Mesh = new MeshInstance(context.Meshes[node.Mesh.LogicalIndex],
node.Mesh.Primitives.Select(_ => context.Materials[_.Material.LogicalIndex]).ToList());
}
if (node.Camera != null)
{
nodeAsset.Camera = context.Cameras[node.Camera.LogicalIndex];
}
if (node.PunctualLight != null)
{
nodeAsset.Light = context.Lights[node.PunctualLight.LogicalIndex];
}
return(nodeAsset);
}
public void LoadDataWithCallback(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap, Func <NodeInputPortAsset, Port> callback)
{
for (int i = 0; i < nodeAsset.InputPorts.Count; i++)
{
Port inputPortUI = callback(nodeAsset.InputPorts[i]);
if (nodeAsset.InputPorts[i].SourceNodeAsset != null)
{
Edge edge = new Edge {
input = inputPortUI, output = (Port)nodeMap[nodeAsset.InputPorts[i].SourceNodeAsset].outputContainer[0]
};
edge.input.Connect(edge);
edge.output.Connect(edge);
graphView.AddElement(edge);
}
}
RefreshExpandedState();
RefreshPorts();
}
public virtual IEnumerable <ISceneAsset> Apply(ISceneAsset scene)
{
var transformedScene = new SceneAsset(scene.Id);
foreach (var node in scene.ChildNodes)
{
NodeAsset parent = null;
foreach (var transformedNode in Apply(null, node))
{
transformedScene.Add(transformedNode);
parent = transformedNode;
}
if (parent != null)
{
foreach (var childNode in node.ChildNodes)
{
ApplyOnSubtree(parent, childNode);
}
}
}
yield return(transformedScene);
}
public override void GenerateLinkData(NodeAsset nodeAsset, Dictionary <Node, NodeAsset> nodeMap)
{
}
public override void LoadData(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap)
{
base.LoadData(graphView, nodeAsset, nodeMap);
_clipField.SetValueWithoutNotify(((ClipNode)nodeAsset.Data).Clip);
}
public static void SetNodeAsset(NodeAsset _nodeAsset, string _fileName)
{
nodeAsset = _nodeAsset;
fileName = _fileName;
}
public static void Clear()
{
nodeAsset = null;
}
public abstract void GenerateLinkData(NodeAsset nodeAsset, Dictionary <Node, NodeAsset> nodeMap);
public override void LoadData(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap)
{
base.LoadData(graphView, nodeAsset, nodeMap);
LoadDataWithCallback(graphView, nodeAsset, nodeMap, portAsset => InputPort);
}
