private NodeConnection GetConnection(string v)
{
if (rebuildConnectionDictionary)
{
rebuildConnectionDictionary = false;
connectionDictionary.Clear();
foreach (var conn in graph.Connections)
{
connectionDictionary.Add(conn.InputNode.GUID + conn.InputSocketName, conn);
}
}
NodeConnection nc = null;
if (connectionDictionary.TryGetValue(v, out nc))
{
return(nc);
}
return(null);
}
/// <summary>
/// Restores node graph state from previously serialized binary data.
/// </summary>
/// <param name="data"></param>
public void Deserialize(byte[] data)
{
using (var br = new BinaryReader(new MemoryStream(data)))
{
var ident = br.ReadString();
if (ident != "NodeSystemP")
{
return;
}
rebuildConnectionDictionary = true;
graph.Connections.Clear();
graph.Nodes.Clear();
Controls.Clear();
var version = br.ReadInt32();
int nodeCount = br.ReadInt32();
for (int i = 0; i < nodeCount; i++)
{
var nv = DeserializeNode(br);
graph.Nodes.Add(nv);
}
var connectionsCount = br.ReadInt32();
for (int i = 0; i < connectionsCount; i++)
{
var con = new NodeConnection();
var og = br.ReadString();
con.OutputNode = graph.Nodes.FirstOrDefault(x => x.GUID == og);
con.OutputSocketName = br.ReadString();
var ig = br.ReadString();
con.InputNode = graph.Nodes.FirstOrDefault(x => x.GUID == ig);
con.InputSocketName = br.ReadString();
br.ReadBytes(br.ReadInt32()); //read additional data
graph.Connections.Add(con);
rebuildConnectionDictionary = true;
}
br.ReadBytes(br.ReadInt32()); //read additional data
}
Refresh();
}
void OnConnectorDoubleClick(object sender, HyperGraph.GraphControl.NodeConnectorEventArgs e)
{
var dialog = new HyperGraph.TextEditForm();
dialog.InputText = "1.0f";
// look for an existing simple connection attached to this connector
foreach (var i in e.Node.Connections)
{
if (i.To == e.Connector && i.From == null)
{
dialog.InputText = i.Name;
}
}
var result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
bool foundExisting = false;
foreach (var i in e.Node.Connections)
{
if (i.To == e.Connector && i.From == null)
{
i.Name = dialog.InputText;
foundExisting = true;
}
}
if (!foundExisting)
{
var connection = new NodeConnection();
connection.To = e.Connector;
connection.Name = dialog.InputText;
e.Node.AddConnection(connection);
}
ShaderFragmentNodeUtil.InvalidateAttachedConstants(graphControl);
}
}
public static void AddToHyperGraph(ShaderPatcherLayer.NodeGraph nodeGraph, HyperGraph.GraphControl graphControl, ShaderDiagram.Document doc)
{
//
// Convert from the "ShaderPatcherLayer" representation back to
// our graph control nodes.
//
// This is required for robust serialisation. We can't easily
// serialise in and out the graph control objects directly, because
// it risks problems if the rendering code or shader fragment objects
// change. That is, it's not very version-robust.
//
// It's better to serialise a slightly higher level representation
// that just contains the node names and connections. That way, we
// can adapt to changes in the tool and data.
//
{
// --------< Basic Nodes >--------
var newNodes = new Dictionary <int, Node>();
var nodeIdToControlNode = new Dictionary <UInt64, Node>();
foreach (var n in nodeGraph.Nodes)
{
if (!newNodes.ContainsKey(n.VisualNodeId))
{
if (n.NodeType == ShaderPatcherLayer.Node.Type.Procedure)
{
var fn = ShaderFragmentArchive.Archive.GetFunction(n.FragmentArchiveName);
if (fn != null)
{
var visualNode = nodeGraph.VisualNodes[n.VisualNodeId];
var newNode = ShaderFragmentNodeCreator.CreateNode(fn, n.FragmentArchiveName, graphControl, doc);
newNode.Location = visualNode.Location;
newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed;
newNodes[n.VisualNodeId] = newNode;
nodeIdToControlNode[n.NodeId] = newNode;
}
}
else
{
var ps = ShaderFragmentArchive.Archive.GetParameterStruct(n.FragmentArchiveName);
if (ps != null)
{
var visualNode = nodeGraph.VisualNodes[n.VisualNodeId];
var newNode = ShaderFragmentNodeCreator.CreateParameterNode(ps, n.FragmentArchiveName, AsSourceType(n.NodeType));
newNode.Location = visualNode.Location;
newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed;
newNodes[n.VisualNodeId] = newNode;
nodeIdToControlNode[n.NodeId] = newNode;
}
}
}
}
graphControl.AddNodes(newNodes.Values);
// --------< Node Connections >--------
foreach (var c in nodeGraph.NodeConnections)
{
if (nodeIdToControlNode.ContainsKey(c.InputNodeID) && nodeIdToControlNode.ContainsKey(c.OutputNodeID))
{
var inputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.InputNodeID],
(item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)),
() => new ShaderFragmentNodeItem("return", c.InputType, null, false, true));
var outputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.OutputNodeID],
(item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)),
() => new ShaderFragmentNodeItem(c.OutputParameterName, c.OutputType, null, true, false));
graphControl.Connect(inputItem.Output, outputItem.Input);
}
}
// --------< Node Constant Connections >--------
foreach (var c in nodeGraph.NodeConstantConnections)
{
if (nodeIdToControlNode.ContainsKey(c.OutputNodeID))
{
var node = nodeIdToControlNode[c.OutputNodeID];
var outputItem = FindOrCreateNodeItem(node,
(item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)),
() => new ShaderFragmentNodeItem(c.OutputParameterName, "float", null, true, false));
var connection = new NodeConnection();
connection.To = outputItem.Input;
connection.Name = c.Value;
node.AddConnection(connection);
}
}
}
}
