#pragma warning restore public void Evaluate(int SpreadMax) { if (FInput.IsAnyInvalid()) { SpreadMax = 0; if (FOutput.SliceCount != 0) { FOutput.SliceCount = 0; FOutput.Flush(); } return; } else { SpreadMax = FInput.SliceCount; } if (!FInput.IsChanged && !FTopicAdd.IsChanged && !FContract.IsChanged) { return; } FOutput.SliceCount = 0; for (int i = 0; i < SpreadMax; i++) { Message message = OSCExtensions.FromOSC(FInput[i], FExtendedMode[0], FTopicAdd[0], FContract[0]); if (message != null) { FOutput.Add(message); } } FOutput.Flush(); }
//called when data for any output pin is requested public void Evaluate(int SpreadMax) { if (FInput.IsAnyInvalid() || FIndex.IsAnyInvalid()) { if (FOutput.SliceCount > 0) { FOutput.SliceCount = 0; FOutput.Flush(); } return; } if (!FInput.IsChanged && !FIndex.IsChanged) { return; } FOutput.SliceCount = 0; var search = from message in FInput let track = (message["TrackId"] as Bin <int>).First where FIndex.Contains(track) select message; FOutput.AssignFrom(search); FOutput.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { if (FInput.IsAnyInvalid() || FExtendedMode.IsAnyInvalid()) { SpreadMax = 0; } else { SpreadMax = FInput.SliceCount; } if (SpreadMax == 0) { if (FOutput.SliceCount != 0) { FOutput.SliceCount = 0; FOutput.Flush(); } return; } if (!FInput.IsChanged && !FExtendedMode.IsChanged) { return; } FOutput.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { FOutput[i].SliceCount = 0; MemoryStream ms = new MemoryComStream(); FInput[i].Position = 0; FInput[i].CopyTo(ms); byte[] bytes = ms.ToArray(); int start = 0; OSCPacket packet = OSCPacket.Unpack(bytes, ref start, (int)FInput[i].Length, FExtendedMode[0]); if (packet.IsBundle()) { var packets = ((OSCBundle)packet).Values; foreach (OSCPacket innerPacket in packets) { MemoryStream memoryStream = new MemoryStream(innerPacket.BinaryData); FOutput[i].Add(memoryStream); } } else { MemoryStream memoryStream = new MemoryStream(packet.BinaryData); FOutput[i].Add(memoryStream); } } FOutput.Flush(); }
public void Evaluate(int spreadMax) { FOutput.SliceCount = FBuffer.SliceCount; for (int i = 0; i < FBuffer.SliceCount; i++) { if (FBuffer[i] == null) { FOutput[i] = null; } else { if (FOutput[i] == null) { FOutput[i] = new Core.Struct(FBuffer[i]); } foreach (var f in FBuffer[i].Fields) { FOutput[i][f] = FBuffer[i].GetClonedData(f); } } } if (!declarationChanged) { FOutput.Flush(); FInput.Sync(); } FBuffer.SliceCount = FInput.SliceCount; for (int i = 0; i < FInput.SliceCount; i++) { if (FInput[i] == null) { FBuffer[i] = null; } else { if (FBuffer[i] == null || FBuffer[i].Name != FInput[i].Name) { FBuffer[i] = new Core.Struct(FInput[i]); FOutput[i] = new Core.Struct(FBuffer[i]); declarationChanged = true; } foreach (var f in FInput[i].Fields) { FBuffer[i][f] = FInput[i].GetClonedData(f); } } } if (declarationChanged) { FOutput.Flush(); declarationChanged = false; } }
public void Evaluate(int SpreadMax) { FTransform.Stream.IsChanged = false; if (FTrans.IsChanged || FRot.IsChanged || FScale.IsChanged) { FTransform.SliceCount = SpreadMax; for (int i = SpreadMax - 1; i >= 0; i--) { if (FTransform[i] == null) { FTransform[i] = new ElementTransformation(); } else if (i > 0) { for (int j = i - 1; j >= 0; j--) { if (FTransform[i] != FTransform[j]) { continue; } FTransform[i] = new ElementTransformation(); break; } } FTransform[i].Position = FTrans[i].AsSystemVector(); FTransform[i].Rotation = FRot[i].AsSystemQuaternion(); FTransform[i].Scale = FScale[i].AsSystemVector(); } FTransform.Flush(true); FTransform.Stream.IsChanged = true; } }
public void Evaluate(int SpreadMax) { if (!FInput.IsChanged) { return; } if (FInput.SliceCount <= 0 || FInput[0] == null) { SpreadMax = 0; } else { SpreadMax = FInput.SliceCount; } FOutput.SliceCount = SpreadMax; var serializer = FResolver == null ? new DataContractSerializer(typeof(T)) : new DataContractSerializer(typeof(T), null, 65536, false, false, null, FResolver); // string xmlString; for (int i = 0; i < SpreadMax; i++) { Stream output = new MemoryStream(); serializer.WriteObject(output, FInput[i]); FOutput[i] = output; } FOutput.Flush(); }
public void Evaluate(int SpreadMax) { FOutput.Resize(SpreadMax, () => new MemoryComStream(), str => str.Dispose()); FMmf.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { if (string.IsNullOrWhiteSpace(FName[i])) { continue; } if (FOpen[i] && !_mmfs.ContainsKey(FName[i])) { try { var mmf = MemoryMappedFile.OpenExisting(FName[i]); _mmfs.Add(FName[i], mmf); } catch { } } if ((FOpen[i] || FRead[i]) && _mmfs.ContainsKey(FName[i])) { var mmf = _mmfs[FName[i]]; FMmf[i] = mmf; if (FOutput[i] == null) { FOutput[i] = new MemoryComStream(); } if (FSize[i] == 0) { using (var accessor = mmf.CreateViewStream()) { FOutput[i].SetLength(accessor.Length); accessor.Position = 0; FOutput[i].Position = 0; accessor.CopyTo(FOutput[i]); FOutput[i].Position = 0; } } else { using (var accessor = mmf.CreateViewStream(FOffset[i], FSize[i])) { FOutput[i].SetLength(accessor.Length); accessor.Position = 0; FOutput[i].Position = 0; accessor.CopyTo(FOutput[i]); FOutput[i].Position = 0; } } } } FOutput.Stream.IsChanged = false; if (FRead.Any() || FOpen.Any()) { FOutput.Flush(true); } }
private void UpdateOutputPins() { if (FParticleSystemName.SliceCount != 0) { var particleSystemData = ParticleSystemRegistry.Instance.GetByParticleSystemName(FParticleSystemName[0]); if (particleSystemData != null) { FBufferSemantic.SliceCount = FElementCountBuf.SliceCount = FStrideBuf.SliceCount = FModeBuf.SliceCount = FResetCounterBuf.SliceCount = 0; foreach (ParticleSystemBufferSettings psbs in particleSystemData.GetBufferSettings()) { FBufferSemantic.Add(psbs.bufferSemantic); FElementCountBuf.Add(psbs.elementCount); FStrideBuf.Add(psbs.stride); FModeBuf.Add(psbs.bufferMode); FResetCounterBuf.Add(psbs.resetCounter); } FBufferSemantic.Flush(); FElementCountBuf.Flush(); FStrideBuf.Flush(); FModeBuf.Flush(); FResetCounterBuf.Flush(); FElementCountPS[0] = particleSystemData.ElementCount; FElementCountPS.Flush(); FStridePS[0] = particleSystemData.Stride; FStridePS.Flush(); } } }
public override void Evaluate(int SpreadMax) { if (Default != null && !FInput.IsChanged) { return; } if (FInput.IsAnyInvalid()) { if (Default == null) { NewDefault(); } FOutput.SliceCount = 1; Default.Topic = FTopic[0]; FOutput[0] = Default; FOutput.Flush(); } else { FOutput.FlushResult(FInput); } }
#pragma warning restore public void Evaluate(int SpreadMax) { if (FInput.IsAnyInvalid() || FFilter.IsAnyInvalid()) { SpreadMax = 0; } else { SpreadMax = FInput.SliceCount; } if (SpreadMax == 0) { FOutput.FlushNil(); FNotFound.FlushNil(); return; } if (!FInput.IsChanged && !FFilter.IsChanged) { return; } FOutput.SliceCount = 0; FNotFound.SliceCount = 0; bool[] found = new bool[SpreadMax]; for (int i = 0; i < SpreadMax; i++) { found[i] = false; } for (int i = 0; i < FFilter.SliceCount; i++) { string[] filter = FFilter[i].Split('.'); var regex = FFilter[i].CreateWildCardRegex(); for (int j = 0; j < SpreadMax; j++) { if (!found[j]) { found[j] = regex.IsMatch(FInput[j].Topic); } } } for (int i = 0; i < SpreadMax; i++) { if (found[i]) { FOutput.Add(FInput[i]); } else { FNotFound.Add(FInput[i]); } } FOutput.Flush(); FNotFound.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { if ((!FInput.IsChanged && !FRemove.IsChanged)) { return; } if ((FRemove.IsAnyInvalid() || FInput.IsAnyInvalid())) { if (FOutput.SliceCount > 0) { FOutput.FlushResult(FInput); return; } else { return; } } SpreadMax = FInput.SliceCount; FOutput.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { var remains = from msg in FInput[i] where !FRemove.Contains(msg) select msg; FOutput[0].SliceCount = 0; FOutput[0].AssignFrom(remains); } FOutput.Flush(); }
#pragma warning restore #endregion fields & pins //called when data for any output pin is requested public void Evaluate(int SpreadMax) { // if (!FInput.IsChanged) return; FOutput.SliceCount = 0; SpreadMax = FInput.SliceCount; if ((FInput.SliceCount == 0) || (FInput[0] == null) || (FInput[0].Length == 0)) { return; } for (int i = 0; i < SpreadMax; i++) { // try { MemoryStream ms = new MemoryStream(); FInput[i].Position = 0; FInput[i].CopyTo(ms); byte[] bytes = ms.ToArray(); int start = 0; OSCPacket packet = OSCPacket.Unpack(bytes, ref start, (int)ms.Length); bool matches = false; for (int j = 0; j < FPinInAddress.SliceCount; j++) { switch (FPinInFilter[0]) { case Filter.Matches: matches |= packet.Address == FPinInAddress[j]; break; case Filter.Contains: matches |= packet.Address.Contains(FPinInAddress[j]); break; case Filter.Starts: matches |= packet.Address.StartsWith(FPinInAddress[j]); break; case Filter.Ends: matches |= packet.Address.EndsWith(FPinInAddress[j]); break; case Filter.All: matches = true; break; } } if (matches) { FOutput.Add(ms); } // } catch (Exception ex) {} } FOutput.Flush(); }
public void Evaluate(int SpreadMax) { SpreadMax = FInput.IsAnyInvalid() || FIndex.IsAnyInvalid()? 0 : FIndex.CombineWith(FIndex); if (SpreadMax == 0) { FOutput.FlushNil(); return; } else { if (!FIndex.IsChanged && !FInput.IsChanged) { return; } } FOutput.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { FOutput[i].AssignFrom(FInput[FIndex[i]]); } FOutput.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { if (!FInput.IsChanged && !FPretty.IsChanged) { return; } FOutput.SliceCount = SpreadMax; JsonSerializer ser = new JsonSerializer(); JsonSerializerSettings settings = new JsonSerializerSettings(); if (FPretty[0]) { settings.Formatting = Formatting.Indented; } else { settings.Formatting = Formatting.None; } settings.TypeNameHandling = TypeNameHandling.None; for (int i = 0; i < SpreadMax; i++) { string s = JsonConvert.SerializeObject(FInput[i], settings); FOutput[i] = s ?? ""; } FOutput.Flush(); }
public void Evaluate(int SpreadMax) { if (FSet[0] == false) { return; } FInput.Sync(); SpreadMax = FInput.SliceCount; FOutput.SliceCount = SpreadMax; bool clone = FClone[0] && (FInput[0] != null) && (FInput[0] is ICloneable); for (int i = 0; i < FInput.SliceCount; i++) { T output; if (clone) { output = (T)((ICloneable)FInput[i]).Clone(); } else { output = FInput[i]; } FOutput[i] = output; } FOutput.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { if (!FInput.IsChanged) { return; } SpreadMax = FInput.SliceCount; FOutput.SliceCount = 0; var settings = new JsonSerializerSettings(); for (int i = 0; i < SpreadMax; i++) { var result = JsonConvert.DeserializeObject(FInput[i]); if (result is JArray) { foreach (var o in (result as JArray).Children()) { FOutput.Add(o.ToObject <Message>()); } } if (result is JObject) { FOutput.Add((result as JObject).ToObject <Message>()); } } FOutput.Flush(); }
//called when data for any output pin is requested public void Evaluate(int spreadMax) { //ResizeAndDispose will adjust the spread length and thereby call //the given constructor function for new slices and Dispose on old //slices. FStreamOut.ResizeAndDispose(spreadMax, () => new MemoryStream()); FKeyGens.SliceCount = spreadMax; if (FPass.IsChanged || FKeyLength.IsChanged || FKeyIterations.IsChanged || FKeySalt.IsChanged) { for (int i = 0; i < spreadMax; i++) { var outputStream = FStreamOut[i]; try { FKeyGens[i] = new KeyGenerator(); var key = FKeyGens[i].GenerateKey(FPass[i], FKeyLength[i], FKeyIterations[i], FKeySalt[i]); outputStream.SetLength(0); outputStream.Write(key, 0, key.Length); } catch (Exception e) { FLogger.Log(e); outputStream.SetLength(0); FErrorOut[i] = e.Message; } } //this will force the changed flag of the output pin to be set FStreamOut.Flush(true); } }
public void Evaluate(int SpreadMax) { if (!FInput.IsChanged) { return; } if (FInput.SliceCount <= 0 || FInput[0] == null) { SpreadMax = 0; } else { SpreadMax = FInput.SliceCount; } FOutput.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { Message message = Message.FromOSC(FInput[i]); FOutput[i] = message; } FOutput.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount; if (SpreadMax <= 0) { FMatch.FlushNil(); FOutput.FlushNil(); return; } FMatch.SliceCount = FOutput.SliceCount = 0; foreach (var message in FInput) { var match = new bool[FFilter.SliceCount]; for (int i = 0; i < FFilter.SliceCount; i++) { match[i] = message.Fields.Contains(FFilter[i]); } if (match.Any()) { FOutput.Add(message); FMatch.AddRange(match); } } FOutput.Flush(); FMatch.Flush(); }
#pragma warning restore public void Evaluate(int SpreadMax) { if (!FInput.IsChanged && !FAddress.IsChanged && !FContract.IsChanged) { return; } if ((FInput.SliceCount == 0) || (FInput[0] == null) || (FInput[0].Length == 0)) { return; } if (FInput.SliceCount <= 0 || FInput[0] == null) { SpreadMax = 0; } else { SpreadMax = FInput.SliceCount; } FOutput.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { Message message = Message.FromOSC(FInput[i], FAddress[0], FContract[0]); FOutput[i] = message; } FOutput.Flush(); }
private void UpdateOutputPins() { var particleSystemData = ParticleSystemRegistry.Instance.GetByParticleSystemName(FParticleSystemName[0]); if (particleSystemData != null) { FOutDefines.SliceCount = 0; FOutDefines.Add("COMPOSITESTRUCT=" + particleSystemData.StructureDefinition); FOutDefines.Add("MAXPARTICLECOUNT=" + particleSystemData.ElementCount); foreach (string define in particleSystemData.GetDefines()) { if (define != "") { FOutDefines.Add(define); } } FOutDefines.Flush(); FOutBufferSemantics.SliceCount = 0; FOutBufferSemantics.AssignFrom(particleSystemData.BufferSemantics); FOutBufferSemantics.Flush(); FElementCount[0] = particleSystemData.ElementCount; FElementCount.Flush(); FStride[0] = particleSystemData.Stride; FStride.Flush(); } }
public static void FlushNil(this ISpread spread) { if (spread.SliceCount != 0) { spread.SliceCount = 0; spread.Flush(); } }
public void OnImportsSatisfied() { IOManager.IOsChanged += IOManager_IOsChanged; FEnabled.Changed += (s) => { if (s.SliceCount > 0 && s[0]) { FStructOut.SliceCount = 1; FStructOut[0] = FStruct; } else { FStructOut.SliceCount = 0; } FStructOut.Flush(); }; }
public void Evaluate(int SpreadMax) { if (!FInput.IsChanged) { return; } SpreadMax = FInput.SliceCount; FOutput.SliceCount = 0; bool[] found = new bool[SpreadMax]; for (int i = 0; i < SpreadMax; i++) { found[i] = false; } for (int i = 0; i < FFilter.SliceCount; i++) { string[] filter = FFilter[i].Split('.'); for (int j = 0; j < SpreadMax; j++) { if (!found[j]) { string[] message = FInput[j].Address.Split('.'); if (message.Length < filter.Length) { continue; } bool match = true; for (int k = 0; k < filter.Length; k++) { if ((filter[k].Trim() != message[k].Trim()) && (filter[k].Trim() != "*")) { match = false; } } found[j] = match; } } } for (int i = 0; i < SpreadMax; i++) { if (found[i]) { FOutput.Add(FInput[i]); } else { FNotFound.Add(FInput[i]); } } FOutput.Flush(); FNotFound.Flush(); }
public static void FlushResult <T>(this ISpread <T> spread, IEnumerable <T> result) { spread.SliceCount = 0; if (result != null) { spread.AssignFrom(result); } spread.Flush(); }
public void Evaluate(int SpreadMax) { FOutput.Stream.IsChanged = false; if (Initial) { FOutput.AssignFrom(FDefault); Initial = false; FOutput.Flush(); FOutput.Stream.IsChanged = true; } if (FEval[0]) { FInput.Sync(); FOutput.AssignFrom(FInput); FOutput.Flush(); FOutput.Stream.IsChanged = true; } }
public void Evaluate(int SpreadMax) { this.FOutValid.SliceCount = 1; this.FStreamOut.SliceCount = 1; if (this.FRead[0]) { this.FBufferIn.Sync(); if (this.FBufferIn.IsConnected) { if (this.RenderRequest != null) { this.RenderRequest(this, this.FHost); } if (this.AssignedContext == null) { this.FOutValid.SliceCount = 0; return; } var context = this.AssignedContext; if (this.FBufferIn[0].Contains(this.AssignedContext)) { var rawBuffer = this.FBufferIn[0][context]; if (this.lastBuffer != null) { if (rawBuffer.Buffer.Description.SizeInBytes != lastBuffer.Size) { this.lastStream.Dispose(); this.lastStream = null; this.lastBuffer.Dispose(); this.lastBuffer = null; } } if (this.lastBuffer == null) { this.lastBuffer = new DX11StagingRawBuffer(context.Device, rawBuffer.Buffer.Description.SizeInBytes); this.lastStream = new MemoryStream(rawBuffer.Buffer.Description.SizeInBytes); } lastStream.Position = 0; context.CurrentDeviceContext.CopyResource(rawBuffer.Buffer, this.lastBuffer.Buffer); DataStream ds = this.lastBuffer.MapForRead(context.CurrentDeviceContext); ds.CopyTo(lastStream); lastStream.Position = 0; this.lastBuffer.UnMap(context.CurrentDeviceContext); FStreamOut[0] = lastStream; FStreamOut.Flush(true); } } } }
public void Evaluate(int SpreadMax) { if (OpenIn.Any(v => v) || CloseIn.Any(v => v)) { DeviceIn.Sync(); DeviceOut.ResizeAndDispose(DeviceIn.SliceCount, () => new HidDeviceWrap()); for (int i = 0; i < DeviceOut.SliceCount; i++) { if (OpenIn[i]) { if (DeviceOut[i] == null) { DeviceOut[i] = new HidDeviceWrap(); } if (DeviceOut[i].Device == null) { DeviceOut[i].Device = DeviceIn[i]; DeviceOut[i].Initialize(); } else { DeviceOut[i].Open(); } } if (CloseIn[i] && DeviceOut[i] != null && DeviceOut[i].Opened) { DeviceOut[i].Close(); DeviceOut[i].Dispose(); DeviceOut[i] = null; } } DeviceOut.Stream.IsChanged = true; DeviceOut.Flush(true); } if (_changeRef != HidChange.GlobalChangeCounter) { _changeRef = HidChange.GlobalChangeCounter; DeviceOut.Stream.IsChanged = true; DeviceOut.Flush(true); } }
public override void Evaluate(int SpreadMax) { InitDX11Graph(); bool warnPinSafety = false; if (RemovePinsFirst) { warnPinSafety = !RetryConfig(); } if (!FNew.Any()) // if none true { FOutput.FlushNil(); return; } SpreadMax = FNew.CombineWith(FTopic); foreach (string name in FPins.Keys) { var pin = FPins[name].ToISpread(); pin.Sync(); SpreadMax = Math.Max(pin.SliceCount, SpreadMax); } FOutput.SliceCount = 0; for (int i = 0; i < SpreadMax; i++) { if (FNew[i]) { var message = new Message(); message.Topic = FTopic[i]; foreach (string name in FPins.Keys) { var pin = FPins[name].ToISpread(); if (pin.SliceCount > 0) { message.AssignFrom(name, pin[i] as ISpread); } else { message[name] = BinFactory.New(Formular[name].Type); // will do empty spreads as well, but ignore faults } } FOutput.Add(message); } } FOutput.Flush(); if (warnPinSafety) { throw new PinConnectionException("Manually remove unneeded links first! [Create]. ID = [" + PluginHost.GetNodePath(false) + "]"); } }
//called when data for any output pin is requested public void Evaluate(int spreadMax) { //ResizeAndDispose will adjust the spread length and thereby call //the given constructor function for new slices and Dispose on old //slices. FStreamOut.ResizeAndDispose(spreadMax, () => new MemoryStream()); Tasks.SliceCount = spreadMax; IOs.SliceCount = spreadMax; FWorking.SliceCount = spreadMax; FError.SliceCount = spreadMax; for (int i = 0; i < spreadMax; i++) { if (!FAsync[i]) { FWorking[i] = false; } if (FCompress[i]) { IOs[i] = new CompressorIO(); IOs[i].InBytes = new byte[FStreamIn[i].Length]; FStreamIn[i].Position = 0; FStreamIn[i].Read(IOs[i].InBytes, 0, (int)FStreamIn[i].Length); if (FAsync[i]) { Tasks[i] = new Task(CompressAsync, IOs[i]); Tasks[i].Start(); } else { CompressAsync(IOs[i]); FWorking[i] = true; FStreamOut[i].Position = 0; FStreamOut[i].Write(IOs[i].OutBytes, 0, IOs[i].OutBytes.Length); } } if (Tasks[i] != null) { if (FAsync[i]) { if ((IOs[i].OutBytes != null) && FWorking[i]) { FStreamOut[i].Position = 0; FStreamOut[i].Write(IOs[i].OutBytes, 0, IOs[i].OutBytes.Length); } FWorking[i] = (!Tasks[i].IsCompleted) && (!Tasks[i].IsFaulted); } if (Tasks[i].Exception != null) { FError[i] = Tasks[i].Exception.Message; } } } //this will force the changed flag of the output pin to be set FStreamOut.Flush(true); }