private void ResolveData(ProcessingTree <SwitchBase> root, ProcessingNode <SwitchBase> start, ProcessingNode <SwitchBase> node)
{
var items =
root.ConnectionsForCompilation.Where(x => !(x.ToInputOutput.InputOutput.Signature is ActionSignature))
.OrderBy(x => x.ToInputOutput.InputOutputId);
foreach (var c in items) // sorgt für korrekte reihenfolge
{
if (node.Value == c.FromInputOutput.Origin)
{
var nextNode = new ProcessingNode <SwitchBase>(c.ToInputOutput.Origin, c, true);
if (node.Previous.Count == 0)
{
nextNode.NextData.Add(node);
}
node.PreviousData.Add(nextNode);
if (!start.ChainedNodes.Contains(nextNode.Value.Id) && c.ToInputOutput.Origin != start.Value)
{
start.ChainedNodes.Add(nextNode.Value.Id);
ResolveData(root, start, nextNode);
}
}
}
}
private void RelayOutput(Processor p, ProcessingNode <T> node, Engine renderingEngine)
{
var connections = ConnectionsForCompilation.Where(x => x.ToInputOutput.Origin == node.Value);
foreach (var c in connections)
{
c.FromInputOutput.InputOutput.Data = c.ToInputOutput.InputOutput.Data;
}
}
private void ProcessDataRoot(ProcessingNode <T> node, Engine renderingEngine)
{
var dataNodes = node.BacktrackData;
foreach (var layer in dataNodes.OrderByDescending(x => x.Key))
{
foreach (var dataNode in layer.Value)
{
if (renderingEngine.DebugMode)
{
Log.Debug("Processing: {0}", dataNode.Value.UniqueName);
}
dataNode.Value.ProcessData(Processor, dataNode);
RelayOutput(Processor, dataNode, renderingEngine);
}
}
}
private void ResolveTree(ProcessingTree <SwitchBase> root, ProcessingNode <SwitchBase> start, ProcessingNode <SwitchBase> node)
{
ResolveData(root, node, node);
BacktrackData(node, node, RenderingEngine, 0);
var items =
root.ConnectionsForCompilation.Where(x => x.ToInputOutput.InputOutput.Signature is ActionSignature)
.OrderBy(x => x.ToInputOutput.InputOutputId);
foreach (var c in items) // sorgt für korrekte reihenfolge
{
if (node.Value == c.ToInputOutput.Origin)
{
var nextNode = new ProcessingNode <SwitchBase>(c.FromInputOutput.Origin, c);
nextNode.Previous.Add(node);
node.Next.Add(nextNode);
node.OutputIndex = c.ToInputOutput.InputOutputId;
ResolveTree(root, start, nextNode);
}
}
}
private void BacktrackData(ProcessingNode <SwitchBase> start, ProcessingNode <SwitchBase> node, Engine renderingEngine, int layer)
{
layer++;
foreach (var prev in node.PreviousData.Where(x => !x.Value.HasActionOutput))
{
BacktrackData(start, prev, renderingEngine, layer);
}
if (start != node && !node.Value.IsStart)
{
if (!start.BacktrackData.ContainsKey(layer))
{
start.BacktrackData[layer] = new List <ProcessingNode <SwitchBase> >();
}
if (!start.BacktrackData[layer].Contains(node))
{
start.BacktrackData[layer].Add(node);
}
}
}
private void Process(ProcessingNode <T> node, Engine renderingEngine)
{
do
{
node.Repeat = false;
ProcessDataRoot(node, renderingEngine);
if (renderingEngine.DebugMode)
{
Log.Warn("Processing: {0}", node.Value.UniqueName);
}
node.Value.Process(Processor, node);
node.Value.ProcessData(Processor, node);
RelayOutput(Processor, node, renderingEngine);
if (node.Next != null && node.Next.Count > 0)
{
for (int i = 0; i < node.Next.Count; i++)
{
var n = node.Next[i];
if (node.Skip == null)
{
Process(n, renderingEngine);
}
else
{
if (n.Connection.ToInputOutput.InputOutputId != node.Skip.OutputIndex)
{
Process(n, renderingEngine);
}
}
}
}
}while (node.Repeat && !CancellationTokenSource.IsCancellationRequested);
}