public void AddTerrain(R_Landblock landblock) { if (CurrentBatch == null || !CurrentBatch.CanAdd(landblock)) { CurrentBatch = new TerrainBatchDraw(OverlayAtlasChain, AlphaAtlasChain); Batches.Add(CurrentBatch); } CurrentBatch.AddTerrain(landblock); }
public void XmlRead(XmlReader reader) { reader.ReadStartElement(nameof(BatchList)); NextBatchId = reader.ReadElementContentAsInt(nameof(NextBatchId), ""); while (reader.IsStartElement(nameof(Batch))) { Batches.Add(new Batch()); Batches.Last().XmlRead(reader); } }
//Draws the pendulum bobs. public override void Draw(State state) { //Sets width and height to canvas height and width propeties depending on //if the canvas is initialised. var width = Canvas.ActualWidth > 0 ? Canvas.ActualWidth : Canvas.Width; var height = Canvas.ActualHeight > 0 ? Canvas.ActualHeight : Canvas.Height; //Calaculate bob position. BobPosition.X = Length * Math.Sin(state.Displacement); BobPosition.Y = Length * Math.Cos(state.Displacement); PivotPosition = new Vec2 { X = width / 2, Y = height / 2 }; Batches.Add(DrawingMethods.FilledCircle(PivotPosition, 4, Brushes.Black)); //Calculate bob position relative to the canvas coordinates. BobPosCanvas.X = PivotPosition.X + BobPosition.X * PixelsPerMeter; BobPosCanvas.Y = PivotPosition.Y + BobPosition.Y * PixelsPerMeter; //Create line objects for pendulum arm. var arm = new LightLine { X1 = PivotPosition.X, Y1 = PivotPosition.Y, X2 = BobPosCanvas.X - BobRadius * Math.Sin(state.Displacement), Y2 = BobPosCanvas.Y - BobRadius * Math.Cos(state.Displacement) }; var armLineBatch = new LineBatch { LineThickness = 2 }; armLineBatch.Add(arm); Batches.Add(armLineBatch); //Draw origin circles depending on whether interaction is taking place. Batches.Add(IsInteracting ? DrawingMethods.FilledCircle(BobPosCanvas, (int)BobRadius, Brushes.Red) : DrawingMethods.FilledCircle(BobPosCanvas, (int)BobRadius, Brushes.Blue)); //Render the batches. foreach (var batch in Batches) { batch.Render(Canvas); batch.Clear(); } Batches.Clear(); }
private void AddBatches(IEnumerable <Batch> batches) { if (Batches == null) { Batches = new List <ObservationBatch>(); } foreach (var batch in batches) { Batches.Add(new ObservationBatch(batch)); } }
private void CreateDefaultConfiguration() { Client = new BlazorClient() { DefaultLatencyTimeout = DefaultLatencyTimeout }; Client.RenderBatchReceived += (id, data) => Batches.Add(new Batch(id, data)); Client.OnCircuitError += (error) => Errors.Add(error); _ = _serverFixture.RootUri; // this is needed for the side-effects of getting the URI. TestSink = _serverFixture.Host.Services.GetRequiredService <TestSink>(); TestSink.MessageLogged += LogMessages; }
/// <summary> /// Called when [get diagnostics batches completed]. /// </summary> /// <param name="items">The items.</param> /// <remarks></remarks> public void OnGetDiagnosticsBatchesCompleted(DiagnosticsBatchViewItem[] items) { IsEmpty = true; IsBusy = false; if (items == null) { return; } IsEmpty = (items.Count() == 0); Batches.Clear(); foreach (var diagnosticsBatchViewItem in items) { Batches.Add(diagnosticsBatchViewItem); } RaisePropertyChanged(Property.Batches); }
public void LoadNextBatchSet() { if (_currentEpoch >= 0) { for (int setIdx = 0; setIdx < Constants.BATCHES_PER_SET; setIdx++) { DataBatch batch; if ((Batches == null) || (Batches.Count < (Constants.BATCHES_PER_SET))) { batch = new DataBatch(Constants.TOTAL_VALUE_COUNT, 1, sparse: true); Batches.Add(batch); } else { batch = Batches[setIdx]; } for (var minibatchIdx = 0; minibatchIdx < Constants.MINIBATCH_SIZE; minibatchIdx++) { OneHotRecordReadOnly rec = _records[_recNo]; rec.CopyDataToSparseArray(batch.SparseIndices, batch.SparseValues, minibatchIdx); batch.Labels[minibatchIdx] = rec.Label; _recNo++; if (_recNo >= _records.Count) { _recNo = 0; if (_totalBatchCount == 0) { _totalBatchCount = _batchesRead; } _batchesRead = 0; _currentEpoch++; CurrentEpochBatch = 0; if (_shuffle) { _records.Shuffle(); } } _batchesRead++; } } } _currentBatch = 0; CurrentSet++; _loaded = true; }
public RemoteRendererBufferLimitTest(AspNetSiteServerFixture serverFixture) { serverFixture.BuildWebHostMethod = TestServer.Program.BuildWebHost; _serverFixture = serverFixture; // Needed here for side-effects _ = _serverFixture.RootUri; Client = new BlazorClient() { DefaultLatencyTimeout = DefaultLatencyTimeout }; Client.RenderBatchReceived += (id, data) => Batches.Add(new Batch(id, data)); Sink = _serverFixture.Host.Services.GetRequiredService <TestSink>(); Sink.MessageLogged += LogMessages; }
private void CreateDefaultConfiguration() { Client = new BlazorClient() { DefaultLatencyTimeout = DefaultLatencyTimeout }; Client.RenderBatchReceived += (id, data) => Batches.Add(new Batch(id, data)); Client.OnCircuitError += (error) => Errors.Add(error); Client.LoggerProvider = new XunitLoggerProvider(Output); Client.FormatError = (error) => { var logs = string.Join(Environment.NewLine, Logs); return(new Exception(error + Environment.NewLine + logs)); }; _ = _serverFixture.RootUri; // this is needed for the side-effects of getting the URI. TestSink = _serverFixture.Host.Services.GetRequiredService <TestSink>(); TestSink.MessageLogged += LogMessages; }
public Task EmitBatchAsync(IEnumerable <LogEvent> events) { lock (_stateLock) { if (_stopped) { return(Task.FromResult(0)); } if (IsDisposed) { WasCalledAfterDisposal = true; } Thread.Sleep(_batchEmitDelay); Batches.Add(events.ToList()); } return(Task.FromResult(0)); }
/// <summary> /// Aggregate the input range into a single batch. /// </summary> /// <param name="totalSz"></param> /// <param name="lo"></param> /// <param name="hi"></param> private void Create <VertexType>(int totalSz, int lo, int hi) where VertexType : struct { if (totalSz > 0) { int totalNumVerts = BytesToCount(totalSz); var localVerts = CheckLocalVerts <VertexType>(totalNumVerts); int accumSz = 0; int iVerts = 0; _boundsScratch.Set(_bufferScratch[lo].Bounds); for (int i = lo; i <= hi; ++i) { _boundsScratch.Union(_bufferScratch[i].Bounds); int numVerts = _bufferScratch[i].Buffer.VertexCount; _bufferScratch[i].Buffer.GetData <VertexType>(localVerts, iVerts, numVerts); iVerts += numVerts; // TODO (****) Do we really need this in bytes? Can we simplify? accumSz += _bufferScratch[i].Buffer.VertexCount * _bufferScratch[i].Buffer.VertexDeclaration.VertexStride; _bufferScratch[i].Dispose(); } Debug.Assert(accumSz == totalSz); GraphicsDevice device = BokuGame.bokuGame.GraphicsDevice; VertexBuffer vbuf = new VertexBuffer(device, typeof(VertexType), totalNumVerts, BufferUsage.WriteOnly); vbuf.SetData <VertexType>(localVerts, 0, totalNumVerts); Batch batch = new Batch(new BoundVBuf(_boundsScratch, vbuf, Stride)); Batches.Add(batch); CheckIndexBuffer(totalNumVerts); } }
protected override Task WriteMessagesAsync(IEnumerable <LogMessage> messages, CancellationToken token) { Batches.Add(messages.ToArray()); return(Task.CompletedTask); }
/// <summary> /// Add a DocumentBatchGet object to the multi-table batch request. /// </summary> /// <param name="batch">DocumentBatchGet to add.</param> public void AddBatch(DocumentBatchGet batch) { Batches.Add(batch); }
//Draws the pendulum bobs. public override void Draw(State state) { var springLength = (Length + state.Displacement) * PixelsPerMeter - ConnectorLength * 2; var coilSpan = springLength / NumberOfCoils; var multiplier = -1; //Sets width and height to canvas height and width propeties depending on //if the canvas is initialised. var width = Canvas.ActualWidth > 0 ? Canvas.ActualWidth : Canvas.Width; var height = Canvas.ActualHeight > 0 ? Canvas.ActualHeight : Canvas.Height; BobPosition.Y = Length + state.Displacement; PivotPosition = new Vec2 { X = width / 2, Y = 10 }; Batches.Add(DrawingMethods.FilledCircle(PivotPosition, 4, Brushes.Black)); //Calaculate bob position. BobPosCanvas.X = PivotPosition.X; BobPosCanvas.Y = PivotPosition.Y + BobPosition.Y * PixelsPerMeter + BobRadius; #region DrawSpring var springlineBatch = new LineBatch(); var springPivotLine = new LightLine() { X1 = PivotPosition.X, Y1 = PivotPosition.Y, X2 = PivotPosition.X, Y2 = PivotPosition.Y + ConnectorLength }; springlineBatch.Add(springPivotLine); var theta = Math.Asin(coilSpan / 2 / CoilDiameter); var x = (CoilDiameter * Math.Cos(theta) / 2); var startLine = new LightLine() { X1 = PivotPosition.X, Y1 = PivotPosition.Y + ConnectorLength, X2 = PivotPosition.X + x, Y2 = PivotPosition.Y + ConnectorLength + coilSpan / 2 }; springlineBatch.Add(startLine); var tempLine = startLine; for (int i = 0; i < (NumberOfCoils - 1) * 2; i++) { var coilLine = new LightLine() { X1 = tempLine.X2, Y1 = tempLine.Y2, X2 = tempLine.X2 + 2 * x * multiplier, Y2 = tempLine.Y2 + coilSpan / 2, }; springlineBatch.Add(coilLine); tempLine = coilLine; multiplier *= -1; } var endLine = new LightLine() { X1 = tempLine.X2, Y1 = tempLine.Y2, X2 = tempLine.X2 + x * multiplier, Y2 = tempLine.Y2 + coilSpan / 2 }; springlineBatch.Add(endLine); var springBobLine = new LightLine() { X1 = endLine.X2, Y1 = endLine.Y2, X2 = endLine.X2, Y2 = endLine.Y2 + ConnectorLength }; springlineBatch.Add(springBobLine); #endregion springlineBatch.LineThickness = 2; Batches.Add(springlineBatch); //Draw origin circles depending on whether interaction is taking place. Batches.Add(IsInteracting ? DrawingMethods.FilledCircle(BobPosCanvas, (int)BobRadius, Brushes.Red) : DrawingMethods.FilledCircle(BobPosCanvas, (int)BobRadius, Brushes.Blue)); //Render the batches. foreach (var batch in Batches) { batch.Render(Canvas); batch.Clear(); } Batches.Clear(); }