public void Evaluate(int SpreadMax)
{
if (FRectangle.IsChanged || FGap.IsChanged)
{
FPacked.SliceCount = FRectangle.SliceCount;
FID.SliceCount = FRectangle.SliceCount;
var rectlist = FRectangle.Select((wh, i) => new Rect(0, 0, wh.x, wh.y, i)).ToList();
rectlist.Sort((a, b) => b.Area.CompareTo(a.Area));
var packer = new RectanglePacker();
double dimw = 0;
double dimh = 0;
for (int i = 0; i < rectlist.Count; i++)
{
var rect = rectlist[i];
FSuccess[0] = packer.Pack(rect.W + FGap[0].x, rect.H + FGap[0].y, out rect.X, out rect.Y);
rectlist[i] = rect;
FID[i] = rect.ID;
FPacked[i] = new Vector4D(rect.X, rect.Y, rect.W, rect.H);
dimw = Math.Max(dimw, rect.X + rect.W);
dimh = Math.Max(dimh, rect.Y + rect.H);
}
FDim[0] = new Vector2D(dimw, dimh);
}
}
public void Evaluate(int SpreadMax)
{
if (DirectoryIn.IsChanged || UpdateIn.TryGetSlice(0))
{
ExistsOut.AssignFrom(DirectoryIn.Select(Directory.Exists));
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FInput.IsChanged || FIndex.IsChanged)
{
FOutput.AssignFrom(FInput);
foreach (int i in FIndex.Select(x => x % FInput.SliceCount).Distinct().OrderByDescending(x => x))
{
FOutput.RemoveAt(i);
}
}
}
public void Evaluate(int spreadMax)
{
if (!MiceIn.IsChanged)
{
return;
}
MouseOut.SliceCount = MiceIn.GetMaxSliceCount();
for (int i = 0; i < MouseOut.SliceCount; i++)
{
var mice = MiceIn.Select((ms, j) => ms.SliceCount > 0 ? ms[j] ?? Mouse.Empty : Mouse.Empty);
MouseOut[i] = new Mouse(Observable.Merge(mice.Select(m => m.MouseNotifications)), false);
}
}
public void Evaluate(int SpreadMax)
{
if (!SpreadUtils.AnyChanged(FInput, FArgumentsIn))
{
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
var arguments = FArgumentsIn.Select(a => a[i]);
FOutput[i] = string.Format(FInput[i], arguments.ToArray());
}
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
var flow = FFlowControl[0];
FChange.SliceCount = 0;
switch (flow)
{
case FlowControlEnum.Block:
FChange.AssignFrom(Enumerable.Repeat(false, 1));
break;
case FlowControlEnum.Default:
if (FInput.IsChanged && !FInput.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
FChange.AssignFrom(Enumerable.Repeat(true, 1));
}
else
{
FChange.AssignFrom(Enumerable.Repeat(false, 1));
}
break;
case FlowControlEnum.Inspect:
var change = FInput.Select(message => message.IsChanged);
if (FInput.IsChanged || change.Any())
{
FOutput.FlushResult(FInput);
FChange.AssignFrom(change);
}
else
{
FChange.AssignFrom(Enumerable.Repeat(false, 1));
}
break;
case FlowControlEnum.Force:
FOutput.FlushResult(FInput);
FChange.AssignFrom(Enumerable.Repeat(true, 1));
break;
default:
FChange.AssignFrom(Enumerable.Repeat(false, 1));
break;
}
}
public void Evaluate(int spreadMax)
{
if (KeyCodeIn.IsChanged)
{
KeyOut.AssignFrom(
KeyCodeIn.Select(k =>
{
if (k < 0 || k > 255)
{
return(Keys.None.ToString());
}
return(((Keys)k).ToString());
}
)
);
}
}
public void Evaluate(int spreadMax)
{
if (KeyIn.IsChanged)
{
KeyCodeOut.AssignFrom(
KeyIn.Select(s =>
{
Keys result;
if (Enum.TryParse <Keys>(s, true, out result))
{
return((int)result);
}
else
{
return((int)Keys.None);
}
}
)
);
}
}
public void Evaluate(int SpreadMax)
{
var flow = FFlowControl[0];
FChange.SliceCount = 0;
SpreadMax = FInput.SliceCount;
if (FForce[0])
{
flow = FlowControlEnum.Force;
}
switch (flow)
{
case FlowControlEnum.Default:
if (FInput.IsChanged && !FInput.IsAnyInvalid())
{
FOutput.FlushResult(FInput);
FChange.FlushItem(true);
}
else
{
FChange.FlushItem(false);
}
break;
case FlowControlEnum.Inspect:
if (FInput.IsAnyInvalid())
{
FChange.FlushItem(false);
break;
}
var change = FInput.Select(message => message.IsChanged);
if (FInput.IsChanged || change.Any())
{
if (FFilter[0])
{
FOutput.FlushResult(FInput.Where(message => message.IsChanged));
}
else
{
FOutput.FlushResult(FInput);
}
FChange.FlushResult(change);
}
else
{
FChange.FlushResult(Enumerable.Repeat(false, SpreadMax));
}
break;
case FlowControlEnum.SinceLastFrame:
if (FInput.IsAnyInvalid())
{
FChange.FlushItem(false);
break;
}
var changed = FInput.Select(message => message.HasRecentCommit());
if (FInput.IsChanged || changed.Any())
{
if (FFilter[0])
{
FOutput.FlushResult(FInput.Where(message => message.HasRecentCommit()));
}
else
{
FOutput.FlushResult(FInput);
}
FChange.FlushResult(changed);
}
else
{
FChange.FlushResult(Enumerable.Repeat(false, SpreadMax));
}
break;
case FlowControlEnum.Block:
FChange.FlushItem(false);
break;
case FlowControlEnum.Force:
FOutput.FlushResult(FInput);
FChange.FlushResult(Enumerable.Repeat(true, SpreadMax));
break;
default: // all bases covered?
FChange.FlushItem <bool>(false);
break;
}
}
public void Evaluate(int SpreadMax)
{
if (!FEnabled[0])
{
wasDisabled = true;
return;
}
// check for changes
bool newData = false;
// has number of functioncalls changed?
if (FInSelector.SliceCount != functionCalls.Count && FInSelector[0] != null)
{
newData = true;
functionCalls.AddRange(FInSelector.Select(item => item.FunctionCall));
}
// have functioncalls changed?
if (!newData)
{
for (int i = 0; i < FInSelector.SliceCount; i++)
{
if (FInSelector[i] != null && FInSelector[i].FunctionCall != functionCalls[i])
{
newData = true;
functionCalls[i] = FInSelector[i].FunctionCall;
}
}
}
// was there an update in selectors?
if (!newData)
{
for (int i = 0; i < FInSelector.SliceCount; i++)
{
if (FInSelector[i] != null && FInSelector[i].HasUpdate)
{
newData = true;
break;
}
}
}
// re-enabled?
if (!newData && wasDisabled)
{
wasDisabled = false; newData = true;
}
// abort if nothing has changed
if (!newData)
{
return;
}
if (FPreventDoubles[0]) // output only unique data
{
FVariables.SliceCount = FFunctionCall.SliceCount = FFunctions.SliceCount =
FOutCSEntry.SliceCount = FOutCustomSemantic.SliceCount =
FOutRSEntry.SliceCount = FOutResourceSemantic.SliceCount = 1;
FFunctionCall[0].SliceCount = FVariables[0].SliceCount = FFunctions[0].SliceCount =
FOutCSEntry[0].SliceCount = FOutCustomSemantic[0].SliceCount =
FOutRSEntry[0].SliceCount = FOutResourceSemantic[0].SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
Selector selector = FInSelector[i];
if (selector != null)
{
// functioncalls
if (!FFunctionCall[0].Contains(selector.FunctionCall))
{
FFunctionCall[0].Add(selector.FunctionCall);
}
// variables
foreach (string variable in selector.Variables)
{
if (!FVariables[0].Contains(variable))
{
FVariables[0].Add(variable);
}
}
// functions
foreach (string funcdef in selector.Functions)
{
if (!FFunctions[0].Contains(funcdef))
{
FFunctions[0].Add(funcdef);
}
}
// custom semantic entries
foreach (string cs in selector.CustomSemanticEntries)
{
if (!FOutCSEntry[0].Contains(cs))
{
FOutCSEntry[0].Add(cs);
}
}
// custom semantics
foreach (IDX11RenderSemantic csIn in selector.GetCustomSemantics())
{
bool canAdd = true;
foreach (IDX11RenderSemantic cs in FOutCustomSemantic[0])
{
if (cs.Semantic == csIn.Semantic)
{
canAdd = false;
}
}
if (canAdd)
{
FOutCustomSemantic[0].Add(csIn);
}
}
// resource semantic entries
foreach (string rs in selector.ResourceSemanticEntries)
{
if (!FOutRSEntry[0].Contains(rs))
{
FOutRSEntry[0].Add(rs);
}
}
// resource semantics
foreach (DX11Resource <IDX11RenderSemantic> rsIn in selector.GetResourceSemantics())
{
bool canAdd = true;
foreach (DX11Resource <IDX11RenderSemantic> rs in FOutResourceSemantic[0])
{
if (rs.Equals(rsIn))
{
canAdd = false;
}
}
if (canAdd)
{
FOutResourceSemantic[0].Add(rsIn);
}
}
}
}
}
else // ouput all selector data with correct bin sizes
{
FVariables.SliceCount = FFunctionCall.SliceCount = FFunctions.SliceCount =
FOutCSEntry.SliceCount = FOutCustomSemantic.SliceCount =
FOutRSEntry.SliceCount = FOutResourceSemantic.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FFunctionCall[i].SliceCount = FVariables[i].SliceCount = FFunctions[i].SliceCount =
FOutCSEntry[i].SliceCount = FOutCustomSemantic[i].SliceCount =
FOutRSEntry[i].SliceCount = FOutResourceSemantic[i].SliceCount = 0;
Selector selector = FInSelector[i];
if (selector != null)
{
FFunctionCall[i].Add(selector.FunctionCall);
FVariables[i].AssignFrom(selector.Variables);
FFunctions[i].AssignFrom(selector.Functions);
FOutCSEntry[i].AssignFrom(selector.CustomSemanticEntries);
FOutCustomSemantic[i].AssignFrom(selector.GetCustomSemantics());
FOutRSEntry[i].AssignFrom(selector.ResourceSemanticEntries);
FOutResourceSemantic[i].AssignFrom(selector.GetResourceSemantics());
}
}
}
}