//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FOperand, FOperator /*,FPA,FPM*/);
FOutput.SliceCount = SpreadMax;
var help = new Helpers();
for (int binID = 0; binID < SpreadMax; binID++)
{
int numOperands = FOperand[binID].SliceCount;// + FOperandB[binID].SliceCount;
//{{{VA,FA},{VB,FB},"i"},{{{VC,FC},{VD,FD},"u"},{VE,FE},"u"},"m"};
string operationString = FOperand[binID][0];
for (int operandID = 0; operandID < numOperands - 1; operandID++)
{
operationString = generateOperationString(operationString, FOperand[binID][operandID + 1], operatorsSmallCaps[(int)FOperator[binID]]);
}
FOutput[binID].SliceCount = 1;
FOutput[binID][0] = operationString;
}
}
public void Evaluate(int spreadMax)
{
if (!FKeyIn.IsChanged && !FCapsIn.IsChanged && !FTimeIn.IsChanged)
{
return;
}
spreadMax = SpreadUtils.SpreadMax(FKeyIn, FCapsIn, FTimeIn);
FSubjects.ResizeAndDispose(spreadMax, slice => new Subject <KeyNotification>());
FOutput.ResizeAndDismiss(spreadMax, slice => new Keyboard(FSubjects[slice], true));
FKeyboardStates.ResizeAndDismiss(spreadMax, () => KeyboardState.Empty);
for (int i = 0; i < spreadMax; i++)
{
var keyboard = FOutput[i];
var keyboardState = new KeyboardState(FKeyIn[i].Cast <Keys>(), FCapsIn[0], FTimeIn[i]);
var previousKeyboardState = FKeyboardStates[i];
if (keyboardState != previousKeyboardState)
{
var subject = FSubjects[i];
var keyDowns = keyboardState.KeyCodes.Except(previousKeyboardState.KeyCodes);
foreach (var keyDown in keyDowns)
{
subject.OnNext(new KeyDownNotification(keyDown, this));
}
var keyUps = previousKeyboardState.KeyCodes.Except(keyboardState.KeyCodes);
foreach (var keyUp in keyUps)
{
subject.OnNext(new KeyUpNotification(keyUp, this));
}
}
FKeyboardStates[i] = keyboardState;
}
}
public void Render(DX11RenderContext context, DX11RenderSettings settings)
{
if (this.FEnabled[0])
{
if (this.FLayerIn.IsConnected)
{
var spMax = SpreadUtils.SpreadMax(this.FInWorld, this.FInRelative);
for (int i = 0; i < spMax; i++)
{
Matrix world = settings.WorldTransform;
if (this.FInRelative[i])
{
settings.WorldTransform = settings.WorldTransform * this.FInWorld[i];
}
else
{
settings.WorldTransform = this.FInWorld[i];
}
this.FLayerIn.RenderAll(context, settings);
settings.WorldTransform = world;
}
}
}
else
{
if (this.FLayerIn.IsConnected)
{
this.FLayerIn.RenderAll(context, settings);
}
}
}
//called when data for any output pin is requested
public virtual void Evaluate(int SpreadMax)
{
Prepare();
var input = FInputContainer.IOObject;
var output = FOutputContainer.IOObject;
int sMax = SpreadUtils.SpreadMax(input, FSelect);
output.SliceCount = 0;
FFormerSlice.SliceCount = 0;
for (int i = 0; i < sMax; i++)
{
for (int s = 0; s < FSelect[i]; s++)
{
if (s == 0)
{
output.SliceCount++;
output[output.SliceCount - 1].SliceCount = 0;
}
output[output.SliceCount - 1].AddRange(input[i]);
FFormerSlice.Add(i);
}
}
}
private IEnumerable <Tuple <string, string> > GetNamespaces(ISpread <string> prefixes, ISpread <string> namespaces)
{
for (int i = 0; i < SpreadUtils.SpreadMax(prefixes, namespaces); i++)
{
yield return(Tuple.Create(prefixes[i], namespaces[i]));
}
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(XML, Validation))
{
return;
}
RootElement.SliceCount = spreadMax;
Document.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
try
{
var document = XMLNodes.AsDocument(XML[i], Validation[i]);
Document[i] = document;
RootElement[i] = document.Root;
}
catch (Exception e)
{
Document[i] = null;
RootElement[i] = null;
FLogger.Log(e);
}
}
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(Name, Value, Childs, Attributes))
{
return;
}
spreadMax = Name
.CombineWith(Value)
.CombineWith(Childs)
.CombineWith(Attributes);
Element.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
var element = new XElement(Name[i], Value[i]);
// clone attributes on the fly if they are already rooted somewhere
var attributes = Attributes[i]
.Where(a => a != null)
.Select(a => a.Parent != null ? new XAttribute(a) : a)
.ToArray();
element.Add(attributes);
// clone elements on the fly if they are already rooted somewhere
var children = Childs[i]
.Where(c => c != null)
.Select(c => c.Parent != null ? new XElement(c) : c)
.ToArray();
element.Add(children);
Element[i] = element;
}
}
protected virtual int SliceCount()
{
return(SpreadUtils.SpreadMax(OperationsIn, LoadIn, HardLoadIn, ReloadIn, SizeIn,
DocSizeBaseSelectorIn, AutoWidthIn, AutoHeightIn, PopupIn, FilterUrlIn,
ZoomLevelIn, MouseIn, KeyboardIn, ShowDevToolsIn,
LivePageIn, UserAgentIn, LogToConsoleIn, NoMouseMoveOnFirstTouchIn, EnabledIn));
}
public void Evaluate(int SpreadMax)
{
if (_init)
{
DeviceList.Local.Changed += (sender, args) => _devChange = true;
_init = false;
}
if (_devChange || SpreadUtils.AnyChanged(VendorIdIn, ProductIdIn))
{
var sprmax = SpreadUtils.SpreadMax(VendorIdIn, ProductIdIn);
DevicesOut.SliceCount = sprmax;
for (int i = 0; i < sprmax; i++)
{
if (VendorIdIn[i] < 0 || ProductIdIn[i] < 0)
{
var devices = DeviceList.Local.GetHidDevices();
DevicesOut[i].AssignFrom(devices);
}
else
{
var devices = DeviceList.Local.GetHidDevices(VendorIdIn[i], ProductIdIn[i]);
DevicesOut[i].AssignFrom(devices);
}
}
_devChange = false;
}
ChangedOut[0] = _devChange;
}
public void Evaluate(int spreadmax)
{
var changed = InputIsChanged() ||
FOtherBehavs.IsChanged ||
FAdd.IsChanged ||
FRemove.IsChanged ||
FTarget.IsChanged;
FOutput.Stream.IsChanged = false;
//FFlatDate.Stream.IsChanged = false;
if (changed)
{
var slc = Math.Max(SpreadUtils.SpreadMax(FAdd, FRemove, FTarget), Spreadmax());
FOutput.SliceCount = slc;
for (int i = 0; i < slc; i++)
{
if (FOutput[i] == null)
{
FOutput[i] = new SetProgressbarBehavior();
}
FOutput[i].Range = CreateRange(i);
FOutput[i].Add = FAdd[i];
FOutput[i].Remove = FRemove[i];
FOutput[i].WorksheetName = FTarget[i];
}
if (slc > 0)
{
FOutput[0].Others = FOtherBehavs;
}
FOutput.Stream.IsChanged = true;
}
}
public override void OnEvaluateEnd()
{
base.OnEvaluateEnd();
if (FInput.IsChanged || SpreadUtils.AnyChanged(ReadIn, FilterReportIdIn))
{
InputReportOut.SliceCount = FInput.SliceCount;
for (int i = 0; i < FInput.SliceCount; i++)
{
if (FInput[i] == null || !ReadIn[i])
{
InputReportOut[i].ResizeAndDispose(0, () => new MemoryStream());
continue;
}
var insprmax = FilterReportIdIn[i].SliceCount;
InputReportOut[i].ResizeAndDispose(insprmax, () => new MemoryStream());
var device = FInput[i];
for (int j = 0; j < insprmax; j++)
{
if (InputReportOut[i][j] == null)
{
InputReportOut[i][j] = new MemoryStream();
}
device.Read(InputReportOut[i][j], FilterReportIdIn[i][j]);
}
}
}
}
protected override void UpdateOps(ref ScrollOperation ops, int i, int j)
{
ops.ElementSelector = FElement[i][j];
ops.ScrollPos = FScroll[i][j];
ops.Normalized = FNorm[i][j];
ops.Execute = SpreadUtils.AnyChanged(FScroll, FNorm, FElement);
}
void KeyMatchChangedCB(IDiffSpread <string> sender)
{
var keyCodes = KeyMatchConfig[0].ToKeyCodes();
//add new pins
foreach (var keyCode in keyCodes)
{
if (!FColumns.Any(col => col.KeyCode == keyCode))
{
var column = new Column(FIOFactory, keyCode, FScheduler);
FColumns.Add(column);
}
}
//remove obsolete pins
foreach (var column in FColumns.ToArray())
{
if (!keyCodes.Contains(column.KeyCode))
{
FColumns.Remove(column);
column.Dispose();
}
}
var spreadMax = SpreadUtils.SpreadMax(KeyMatchConfig, KeyboardIn, ResetIn, KeyModeIn);
UpdateColumns(spreadMax);
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(XML, Validation))
{
return;
}
RootElement.SliceCount = spreadMax;
Document.SliceCount = spreadMax;
Success.SliceCount = spreadMax;
ErrorMessage.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
try
{
var document = XMLNodes.AsDocument(XML[i], Validation[i]);
Document[i] = document;
RootElement[i] = document.Root;
Success[i] = true;
ErrorMessage[i] = null;
}
catch (Exception e)
{
Document[i] = null;
RootElement[i] = null;
Success[i] = false;
ErrorMessage[i] = e.Message;
FLogger.Log(LogType.Warning, e.Message);
}
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FVec, FTI /*,FPA,FPM*/);
FVecOut.SliceCount = SpreadMax;
var help = new Helpers();
if (FCal[0])
{
for (int binID = 0; binID < SpreadMax; binID++)
{
int entries = FVec[binID].SliceCount;
int entriesXYZ = entries * 3;
int entriesXY = entries * 2;
int numIndices = FTI[binID].SliceCount;
int numTriangles = numIndices / 3;
double[] V = new double[entriesXYZ];
V = help.Vector3DToArray(V, FVec[binID]);
int[] tI = new int[numIndices];
tI = FTI[binID].ToArray();
double[] Vuv = new double[entriesXY];
int[] binSizes = new int[2];
binSizes[0] = entries;
binSizes[1] = numTriangles;
try
{
if ((int)FMode[binID] == 0)
{
doARAPParam(V, tI, binSizes, Vuv);
}
else
{
doLSCMParam(V, tI, binSizes, Vuv);
}
// double[] tTexCoordsArr = new double[entriesXY];
// Marshal.Copy(tTexCoords, tTexCoordsArr, 0, entriesXY);
FVecOut[binID].SliceCount = entries;
for (int i = 0; i < entries; i++)
{
FVecOut[binID][i] = new Vector2D(Vuv[i * 2], Vuv[i * 2 + 1]);
}
// ReleaseMemory(tTexCoords);
}
catch (Exception ex)
{
}
}
}
}
public void Evaluate(int SpreadMax)
{
if (!this.FFormat.PluginIO.IsConnected)
{
this.FOutput.SliceCount = 0;
return;
}
if (this.apply[0] || this.first)
{
this.FText.Sync();
this.FTextAlign.Sync();
this.FParaAlign.Sync();
this.FMaxHeight.Sync();
this.FMaxWidth.Sync();
this.FFormat.Sync();
this.textStyles.Sync();
//first dispose old outputs
for (int i = 0; i < this.FOutput.SliceCount; i++)
{
if (this.FOutput[i] != null)
{
this.FOutput[i].Dispose();
}
}
var spMax = SpreadUtils.SpreadMax(this.FText, this.FTextAlign, this.FParaAlign, this.FMaxHeight, this.FMaxWidth, this.FFormat, this.textStyles);
//then set new slicecount
this.FOutput.SliceCount = spMax;
//then create new outputs
for (int i = 0; i < spMax; i++)
{
float maxw = this.FMaxWidth[i] > 0.0f ? this.FMaxWidth[i] : 0.0f;
float maxh = this.FMaxHeight[i] > 0.0f ? this.FMaxHeight[i] : 0.0f;
var tl = new TextLayout(this.dwFactory, this.FText[i], this.FFormat[i], maxw, maxh);
var align = (int)this.FTextAlign[i];
tl.TextAlignment = (TextAlignment)align;
tl.ParagraphAlignment = this.FParaAlign[i];
var styles = textStyles[i];
for (int j = 0; j < styles.SliceCount; j++)
{
if (styles[j] != null)
{
styles[j].Apply(tl);
}
}
this.FOutput[i] = tl;
}
}
this.first = false;
}
public void Update(DX11RenderContext context)
{
if (shaderSample == null)
{
shaderSample = new DX11ShaderInstance(context, effectSample);
shaderLoad = new DX11ShaderInstance(context, effectLoad);
}
DX11ShaderInstance instance = this.pixelCoords[0] ? shaderLoad : shaderSample;
if (this.mipLevel.SliceCount > 1)
{
instance.SelectTechnique("ConstantLevel");
}
else
{
instance.SelectTechnique("DynamicLevel");
}
int totalCount;
if (this.mipLevel.SliceCount > 1)
{
totalCount = SpreadUtils.SpreadMax(this.coordinates, this.mipLevel);
instance.SetByName("UvCount", this.coordinates.SliceCount);
instance.SetByName("LevelCount", this.mipLevel.SliceCount);
}
else
{
totalCount = this.coordinates.SliceCount;
instance.SetByName("MipLevel", this.mipLevel[0]);
}
this.coordinateBuffer = this.coordinateBuffer.GetOrResize(context.Device, this.coordinates.SliceCount, 8);
this.levelBuffer = this.levelBuffer.GetOrResize(context.Device, this.mipLevel.SliceCount, 4);
this.writeBuffer = this.writeBuffer.GetOrResize(context.Device, totalCount, 16);
this.readbackBuffer = this.readbackBuffer.GetOrResize(context.Device, totalCount, 16);
instance.SetByName("TotalCount", totalCount);
instance.SetByName("uvBuffer", coordinateBuffer.SRV);
if (this.mipLevel.SliceCount > 1)
{
instance.SetByName("uvLevelBuffer", levelBuffer.SRV);
}
instance.SetByName("inputTexture", this.textureInput[0][context].SRV);
instance.SetByName("OutputBuffer", writeBuffer.UAV);
instance.ApplyPass(0);
context.CurrentDeviceContext.CopyResource(this.writeBuffer.Buffer, this.readbackBuffer.Buffer);
}
public override bool Sync()
{
// Sync source
IsChanged = FDataStream.Sync() | FBinSizeStream.Sync();
if (IsChanged)
{
int dataLength = FDataStream.Length;
int binSizeLength = FBinSizeStream.Length;
int binSizeSum = 0;
foreach (var binSize in FBinSizeStream)
{
binSizeSum += SpreadUtils.NormalizeBinSize(dataLength, binSize);
}
int binTimes = SpreadUtils.DivByBinSize(dataLength, binSizeSum);
binTimes = binTimes > 0 ? binTimes : 1;
Length = binTimes * binSizeLength;
var binSizeBuffer = MemoryPool <int> .GetArray();
try
{
using (var binSizeReader = FBinSizeStream.GetCyclicReader())
{
var numSlicesToWrite = Length;
var offsetIntoDataStream = 0;
while (numSlicesToWrite > 0)
{
var numSlicesToRead = Math.Min(numSlicesToWrite, binSizeBuffer.Length);
binSizeReader.Read(binSizeBuffer, 0, numSlicesToRead);
var offset = Length - numSlicesToWrite;
for (int i = offset; i < offset + numSlicesToRead; i++)
{
var binSize = SpreadUtils.NormalizeBinSize(dataLength, binSizeBuffer[i - offset]);
var innerStream = this[i] as InnerStream;
// Inner stream will use cyclic reader when offset + length > length of data stream.
innerStream.Offset = offsetIntoDataStream;
innerStream.Length = binSize;
offsetIntoDataStream += binSize;
}
numSlicesToWrite -= numSlicesToRead;
}
}
}
finally
{
MemoryPool <int> .PutArray(binSizeBuffer);
}
}
return(base.Sync());
}
public void Evaluate(int SpreadMax)
{
if (SpreadUtils.AnyChanged(this.sheetMips, this.sheetSizeX, this.sheetSizeY, this.glyphWidth, this.glyphHeight, this.aniso))
{
this.FOutTextWrapper.SafeDisposeAll();
}
if (this.FOutTextWrapper[0] == null)
{
this.FOutTextWrapper[0] = new DX11Resource <TextFontRenderer>();
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FOutput.SliceCount = SpreadUtils.SpreadMax(FSpread, FInput, FOffset);
for (int i = 0; i < FInput.SliceCount; i++)
{
FOutput[i].AssignFrom(FSpread[i]);
for (int s = 0; s < FInput[i].SliceCount; s++)
{
FOutput[i][s + FOffset[i]] = FInput[i][s];
}
}
}
public override bool Sync()
{
// Sync source
IsChanged = FBinSizeStream.Sync() | FDataStream.Sync();
if (IsChanged)
{
// Normalize bin size and compute sum
int dataStreamLength = FDataStream.Length;
int binSizeSum = 0;
foreach (var binSize in FBinSizeStream)
{
binSizeSum += SpreadUtils.NormalizeBinSize(dataStreamLength, binSize);
}
int binTimes = SpreadUtils.DivByBinSize(dataStreamLength, binSizeSum);
binTimes = binTimes > 0 ? binTimes : 1;
Length = binTimes * FBinSizeStream.Length;
using (var binSizeReader = FBinSizeStream.GetCyclicReader())
using (var dataReader = FDataStream.GetCyclicReader())
{
for (int i = 0; i < Length; i++)
{
var spread = Buffer[i];
var stream = spread.Stream;
var binSize = SpreadUtils.NormalizeBinSize(dataStreamLength, binSizeReader.Read());
spread.SliceCount = binSize;
switch (binSize)
{
case 0:
break;
case 1:
stream.Buffer[0] = dataReader.Read();
break;
default:
dataReader.Read(stream.Buffer, 0, binSize);
break;
}
// Mark the stream as changed
stream.IsChanged = true;
}
}
}
return(base.Sync());
}
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());
}
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(Name, Value))
{
return;
}
Attribute.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
Attribute[i] = new XAttribute(Name[i], Value[i]);
}
}
public void Evaluate(int SpreadMax)
{
if (FWrapper.IsConnected)
{
FOut.SliceCount = FValid.SliceCount = FWrapper.SliceCount;
for (int i = 0; i < FWrapper.SliceCount; i++)
{
var wrapper = FWrapper[i];
if (wrapper == null)
{
FOut[i].SliceCount = FValid[i].SliceCount = 0;
continue;
}
var slc = SpreadUtils.SpreadMax(FObj[i], FFunc[i]);
FOut[i].SliceCount = FValid[i].SliceCount = slc;
for (int j = 0; j < slc; j++)
{
var objname = FObj[i][j];
var funcname = FFunc[i][j];
if (wrapper.JsBindings.ContainsKey(objname))
{
var obj = wrapper.JsBindings[objname];
if (obj.Functions.ContainsKey(funcname))
{
FOut[i][j] = obj.Functions[funcname];
FValid[i][j] = true;
}
else
{
FOut[i][j] = null;
FValid[i][j] = false;
}
}
else
{
FOut[i][j] = null;
FValid[i][j] = false;
}
}
}
}
else
{
FOut.SliceCount = FValid.SliceCount = 0;
}
}
private int CalculateSpreadMax()
{
int max = this.varmanager.CalculateSpreadMax();
int spFixed = SpreadUtils.SpreadMax(this.FIn, this.FInTechnique);
if (max == 0 || spFixed == 0)
{
return(0);
}
else
{
max = Math.Max(spFixed, max);
return(max);
}
}
public List <int> Reorder(DX11RenderSettings settings, List <DX11ObjectRenderSettings> objectSettings)
{
internalBuffer.Clear();
int spreadMax = SpreadUtils.SpreadMax(this.FInCount, this.FInIndex);
for (int i = 0; i < spreadMax; i++)
{
int start = this.FInIndex[i];
int count = this.FInCount[i];
for (int j = 0; j < count; j++)
{
internalBuffer.Add(start + j);
}
}
return(this.internalBuffer);
}
public void Evaluate(int SpreadMax)
{
if (SpreadUtils.AnyChanged(this.w, this.normal, this.FCustom))
{
this.FShapes.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
PlaneShapeDefinition plane = new PlaneShapeDefinition(new BulletSharp.Vector3(this.normal[i].X, this.normal[i].Y, this.normal[i].Z), this.w[i]);
plane.Pose = RigidBodyPose.Default;
plane.CustomString = this.FCustom[i];
this.FShapes[i] = plane;
}
}
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(FNodeIn, FPrefixIn, FNamespaceIn))
{
return;
}
if (FNodeIn.SliceCount > 0)
{
var namespaces = GetNamespaces(FPrefixIn, FNamespaceIn);
var node = FNodeIn[0] ?? new XElement("dummy");
FNamespaceResolverOut[0] = node.CreateNamespaceResolver(namespaces);
}
else
{
FNamespaceResolverOut.SliceCount = 0;
}
}
public void Evaluate(int spreadMax)
{
if (!SpreadUtils.AnyChanged(Element, XPath, NamespaceResolver))
{
return;
}
Elements.SliceCount = spreadMax;
ErrorMessage.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
string error;
Elements[i] = Element[i].GetElementsByXPath(XPath[i], NamespaceResolver[0], out error);
ErrorMessage[i] = error;
}
}
public void Evaluate(int SpreadMax)
{
if (SpreadUtils.AnyChanged(this.suspensionStiffness, this.wheelsDampingCompression, this.wheelsDampingRelaxation, this.frictionSlip, this.rollInfluence))
{
this.output.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
this.output[i] = new WheelInfoSettings()
{
FrictionSlip = this.frictionSlip[i],
RollInfluence = this.rollInfluence[i],
SuspensionStiffness = this.suspensionStiffness[i],
WheelsDampingCompression = this.wheelsDampingCompression[i],
WheelsDampingRelaxation = this.wheelsDampingRelaxation[i]
};
}
}
}
