public override void Evaluate(int SpreadMax)
{
SpreadMax = FInput.SliceCount;
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
}
for (int i = 0; i < SpreadMax; i++)
{
var agent = FInput[i];
if (FInitFirst[0])
{
Type face = AllAgentFaces[FFace[0].Index];
agent.Init(face, FInitFirst[0]);
}
foreach (string pinName in FPins.Keys)
{
var pin = ((ISpread)FPins[pinName].RawIOObject);
pin.Sync();
agent.Assign(pinName, pin[i]);
}
}
FOutput.AssignFrom(FInput);
}
public override void Evaluate(int SpreadMax)
{
var update = CheckReset();
if (FInput.IsChanged && !FInput.IsAnyInvalid())
{
Keep.AssignFrom(FInput);
update = true;
}
if (UpKeep())
{
update = true;
}
if (FHold.IsChanged)
{
update = true;
}
if (FHold[0] == HoldEnum.Index && FIndex.IsChanged)
{
update = true;
}
if (update)
{
switch (FHold[0])
{
case HoldEnum.All:
FOutput.SliceCount = 0;
FOutput.AssignFrom(Keep);
break;
case HoldEnum.Index:
if (Keep.Count == 0)
{
FOutput.SliceCount = 0;
}
else
{
FOutput.SliceCount = FIndex.SliceCount;
for (int i = 0; i < FIndex.SliceCount; i++)
{
var index = VMath.Zmod(FIndex[i], Keep.Count);
FOutput[i] = Keep[index];
}
}
break;
}
FOutput.Flush();
}
}
public override void Evaluate(int SpreadMax)
{
FInput.Dispose();
for (int i = 0; i < SpreadMax; i++)
{
Agent agent = FInput[i];
foreach (string name in FPins.Keys)
{
var pin = ((ISpread <ISpread>)FPins[name].RawIOObject)[i];
agent.Assign(name, pin);
}
}
FOutput.AssignFrom(FInput);
FOutput.Flush();
}
public override void Evaluate(int SpreadMax)
{
SpreadMax = FInput.SliceCount;
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
}
foreach (string pinName in FPins.Keys)
{
((ISpread)FPins[pinName].RawIOObject).SliceCount = SpreadMax;
FTimeStamp.SliceCount = SpreadMax;
}
for (int i = 0; i < SpreadMax; i++)
{
Agent agent = FInput[i];
FTimeStamp[i] = agent.BirthTime.ToString();
foreach (string name in FPins.Keys)
{
var pinSpread = (ISpread)((ISpread)FPins[name].RawIOObject)[i];
var bin = agent[name];
pinSpread.SliceCount = bin.Count;
for (int j = 0; j < bin.Count; j++)
{
pinSpread[j] = bin[j];
}
}
}
FOutput.AssignFrom(FInput);
FTimeStamp.Flush();
foreach (var pin in FPins.Values)
{
((ISpread)pin.RawIOObject).Flush();
}
}
//called when data for any output pin is requested
public override void Evaluate(int SpreadMax)
{
//check transforms
if (FTransformIn.IsChanged)
{
//assign size and clear group list
FOutput.SliceCount = FTransformIn.SliceCount;
FGroups.Clear();
//create groups and add matrix to it
for (int i = 0; i < FTransformIn.SliceCount; i++)
{
var g = new SvgGroup();
g.Transforms = new SvgTransformCollection();
var m = FTransformIn[i];
var mat = new SvgMatrix(new List <float>()
{
m.M11, m.M12, m.M21, m.M22, m.M41, m.M42
});
g.Transforms.Add(mat);
FGroups.Add(g);
}
}
//add all elements to each group
var pinsChanged = FInput.IsChanged || FTransformIn.IsChanged || FEnabledIn.IsChanged;
if (pinsChanged)
{
foreach (var g in FGroups)
{
g.Children.Clear();
if (FEnabledIn[0])
{
for (int i = 0; i < FInput.SliceCount; i++)
{
var pin = FInput[i];
for (int j = 0; j < pin.SliceCount; j++)
{
var elem = pin[j];
if (elem != null)
{
g.Children.AddAndFixID(elem, true, true, LogIDFix);
}
}
}
}
}
//write groups to output
FOutput.AssignFrom(FGroups);
}
//set id and class to elements
if (pinsChanged || FIDIn.IsChanged || FClassIn.IsChanged)
{
base.SetIDs();
}
}
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return; // if no input, no further calculation.
}
bool doFlush = false;
// any of the update slices is true -> update the plugin.
var anyUpdate = FUpdate.Any();
// Flush upstream changes through the plugin
if (FInput.IsChanged)
{
FOutput.SliceCount = 0;
FOutput.AssignFrom(FInput);
doFlush = true;
}
else if (!anyUpdate)
{
return;
}
var keyCount = FKey.SliceCount;
var ValueSpread = FValue.ToISpread();
bool newData = ValueSpread.IsChanged; // changed pin
newData |= !FAutoSense[0]; // assume newData, if AutoSense is off.
if (anyUpdate && newData)
{
SpreadMax = FInput.SliceCount;
doFlush = true;
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
var keyIndex = 0;
foreach (var key in FKey)
{
var fieldIndex = i * keyCount + keyIndex;
keyIndex++;
if (!FUpdate[fieldIndex])
{
continue;
}
if (!message.Fields.Contains(key))
{
message[key] = BinFactory.New(TargetDynamicType);
}
var value = ValueSpread[fieldIndex] as ISpread;
if (value.SliceCount > 0)
{
if (message[key].GetInnerType().IsAssignableFrom(TargetDynamicType))
{
// check if any relevant change occurred
if (!message[key].Equals(value as IEnumerable))
{
message.AssignFrom(key, value);
}
}
else
{
var casted = from slice in value as IEnumerable <object>
let targetType = message[key].GetInnerType()
select Convert.ChangeType(slice, targetType);
if (!message[key].Equals(casted))
{
message.AssignFrom(key, casted);
}
}
}
else
{
message[key].Clear();
}
}
}
}
if (doFlush)
{
FOutput.Flush();
}
}
public override void Evaluate(int SpreadMax)
{
InitDX11Graph();
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return; // if no input, no further calculation.
}
bool doFlush = false;
// any of the update slices is true -> update the plugin.
var anyUpdate = FUpdate.Any();
// Flush upstream changes through the plugin
if (FInput.IsChanged)
{
FOutput.SliceCount = 0;
FOutput.AssignFrom(FInput);
doFlush = true;
}
else if (!anyUpdate)
{
return;
}
var dataSpread = FValue.ToISpread();
bool newData = dataSpread.IsChanged; // changed pin
newData |= FForce[0]; // assume newData, if AutoSense is off.
if (anyUpdate && newData)
{
// Update and Force not included in spreading.
SpreadMax = dataSpread.SliceCount.CombineWith(FKey).CombineWith(FInput);
if (FUpdate.IsAnyInvalid() || FForce.IsAnyInvalid())
{
SpreadMax = 0;
}
FIterations[0] = SpreadMax;
doFlush = true;
var fieldIndex = 0;
for (int i = 0; i < SpreadMax; i++) // iterate spreaded (except update, which gets cut short)
{
Message message = FInput[i];
for (int j = 0; j < FKey[i].SliceCount; j++, fieldIndex++) // iterate all relevant fields for each message
{
if (!FUpdate[fieldIndex])
{
continue; // update is per-field
}
var key = FKey[i][j];
var spread = dataSpread[fieldIndex] as ISpread;
LazyInsert(message, key, spread);
}
}
}
if (doFlush)
{
FOutput.Flush();
}
}