public GraphBuilder NewNode(Type nodeType, Vector2 position, string name, BaseGraphCLIAttributes attributes = null)
{
if (!nodeType.IsSubclassOf(typeof(BaseNode)))
{
Debug.Log("[GraphBuilder] unknown node type: '" + nodeType + "'");
return(this);
}
commands.Add(BaseGraphCLI.GenerateNewNodeCommand(nodeType, name, position, attributes));
return(this);
}
public static string GenerateNewNodeCommand(Type nodeType, string name, BaseGraphCLIAttributes datas = null)
{
string cmd = "NewNode " + nodeType.Name + " \"" + name + "\"";
if (datas != null && datas.Count != 0)
{
cmd += " attr=" + Jsonizer.Generate(datas);
}
return(cmd);
}
public static void PerlinNoiseWithAttributesToDebugNodeExecution()
{
string perlinNodeName = "perlin";
var perlinAttributes = new BaseGraphCLIAttributes {
{ "persistence", 2.4f }, { "octaves", 6 }
};
var graph = GraphBuilder.NewGraph <WorldGraph>()
.NewNode <NodePerlinNoise2D>(perlinNodeName, perlinAttributes)
.Execute()
.GetGraph();
NodePerlinNoise2D perlinNode = graph.FindNodeByName(perlinNodeName) as NodePerlinNoise2D;
Assert.That(perlinNode.octaves == 6, "Perlin node octaves expected to be 6 but was " + perlinNode.octaves);
Assert.That(perlinNode.persistence == 2.4f, "Perlin node persistence expected to be 2.4 but was " + perlinNode.persistence);
}
public GraphBuilder NewNode <T>(string name, BaseGraphCLIAttributes attributes = null) where T : BaseNode
{
commands.Add(BaseGraphCLI.GenerateNewNodeCommand(typeof(T), name, attributes));
return(this);
}
public static void Export(BaseGraph graph, string filePath)
{
List <string> commands = new List <string>();
List <string> nodeNames = new List <string>();
var nodeToNameMap = new Dictionary <BaseNode, string>();
//GraphAttr commands
var fields = graph.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
foreach (var field in fields)
{
var attrs = field.GetCustomAttributes(true);
if (attrs.Any(a => a is TextSerializeField))
{
string s = GenerateGraphAttributeCommand(field.Name, field.GetValue(graph));
if (s != null)
{
commands.Add(s);
}
}
}
//CreateNode commands
foreach (var node in graph.allNodes)
{
var attrs = new BaseGraphCLIAttributes();
//load node attributes
FieldInfo[] attrFields = node.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (var field in attrFields)
{
var attributes = field.GetCustomAttributes(false);
bool isInput = attributes.Any(a => {
return(a.GetType() == typeof(InputAttribute));
});
if (isInput)
{
continue;
}
//if the field can't be jsonified, we skip it
if (Jsonizer.allowedJsonTypes.FindIndex(j => j.type == field.FieldType) == -1)
{
continue;
}
attrs.Add(field.Name, field.GetValue(node));
}
string nodeName = node.name;
int i = 0;
//unique name generation
while (nodeNames.Contains(nodeName))
{
nodeName = node.name + i++;
}
nodeNames.Add(nodeName);
nodeToNameMap[node] = nodeName;
commands.Add(GenerateNewNodeCommand(node.GetType(), nodeName, node.rect.position, attrs));
}
//Link commands
foreach (var link in graph.nodeLinkTable.GetLinks())
{
if (link.fromNode == null || link.toNode == null)
{
continue;
}
var fromName = nodeToNameMap[link.fromNode];
var toName = nodeToNameMap[link.toNode];
var fromAnchorName = link.fromAnchor.fieldName;
var toAnchorName = link.toAnchor.fieldName;
commands.Add(GenerateLinkAnchorNameCommand(fromName, fromAnchorName, toName, toAnchorName));
}
File.WriteAllLines(filePath, commands.ToArray());
}
