public void Update() { if (CapacityLimit.HasValue && CapacityLimit.Value < 1) { throw new ArgumentOutOfRangeException("CapacityLimit"); } if (SectorCapacityLimit.HasValue && SectorCapacityLimit.Value < 1) { throw new ArgumentOutOfRangeException("SectorCapacityLimit"); } _SectorsFromLastUpdate.Clear(); UpdateArgs.SetTime(TimeProvider); var newCount = 0; foreach (var sector in Particles.Sectors) { UpdateSector(sector); newCount += sector.Count; } _PreviousCount = _Count; _Count = newCount; LastUpdateTime = UpdateArgs.Now; }
protected void BuildMaterialCache() { lock (Lock) { MaterialCacheScratchSet.Clear(); foreach (var field in AllMaterialFields) { var material = field(); if (material != null) { MaterialCacheScratchSet.Add(material); } } foreach (var coll in AllMaterialCollections) { coll()?.AddToSet(MaterialCacheScratchSet); } foreach (var m in ExtraMaterials) { MaterialCacheScratchSet.Add(m); } MaterialCache.Clear(); foreach (var m in MaterialCacheScratchSet) { MaterialCache.Add(m); } } }
public void UpdateItems() { var items = (from kvp in ListsByPriority orderby kvp.Key descending select kvp.Value); Items.Clear(); foreach (var l in items) { var buf = new IWorkQueue[l.Count]; l.CopyTo(buf, 0, l.Count); Items.Add(buf); } }
public void Clear() { if (_Count != 0) { _Count = 0; Item1 = Item2 = Item3 = Item4 = default(T); } if (_HasList) { Items.Clear(); } }
private void NotifyPendingDrawCompletions() { lock (CompletedPendingDrawQueue) { foreach (var cpd in CompletedPendingDrawQueue) { if (cpd.Exception != null) { cpd.OnComplete.SetResult2(null, cpd.Exception); continue; } if ( (cpd.OnComplete.ResultType == cpd.UserData.GetType()) || (cpd.OnComplete.ResultType == typeof(object)) ) { cpd.OnComplete.SetResult(cpd.UserData, null); } else if ( (cpd.OnComplete.ResultType == typeof(RenderTarget2D)) || (cpd.OnComplete.ResultType == typeof(Texture2D)) ) { cpd.OnComplete.SetResult(cpd.RenderTarget, null); } else { cpd.OnComplete.SetResult(null, new Exception("No way to generate completion result for type " + cpd.OnComplete.ResultType)); } } CompletedPendingDrawQueue.Clear(); } }
protected void Initialize(IBatchContainer container, int layer, Material material, bool addToContainer) { if (State.IsPrepareQueued) { throw new Exception("Batch currently queued for prepare"); } if ((material != null) && (material.IsDisposed)) { throw new ObjectDisposedException("material"); } StackTrace = null; if (BatchesCombinedIntoThisOne != null) { BatchesCombinedIntoThisOne.Clear(); } Released = false; ReleaseAfterDraw = false; Layer = layer; Material = material; Index = Interlocked.Increment(ref _BatchCount); lock (State) { State.IsCombined = false; State.IsInitialized = true; State.IsPrepared = State.IsPrepareQueued = State.IsIssued = false; } if (addToContainer) { container.Add(this); } }
public void Dispose() { lock (_StateLock) { _VertexArray = null; _IndexArray = null; _VertexCount = _IndexCount = 0; _FlushedToBuffers = 0; lock (_StaticStateLock) { _InstanceCount -= 1; if (_InstanceCount <= 0) { foreach (var buffer in _UnusedHardwareBuffers) { buffer.Dispose(); } _UnusedHardwareBuffers.Clear(); _LargeUnusedBufferCount = _SmallUnusedBufferCount = 0; } } } }
public static void Free(UnorderedList <T> queue) { queue.Clear(); if (UnusedLists.Count > Capacity) { return; } UnusedLists.Add(queue); }
public virtual void Dispose() { lock (_StateLock) { foreach (var buffer in _UnusedHardwareBuffers) { buffer.Dispose(); } _UnusedHardwareBuffers.Clear(); _PendingCopies.Clear(); _VertexArray = null; _IndexArray = null; _VertexCount = _IndexCount = 0; _FlushedToBuffers = 0; } }
void IBufferGenerator.Reset() { lock (_StateLock) { _FillingHardwareBufferEntry = null; _FlushedToBuffers = 0; _VertexCount = _IndexCount = 0; // Any buffers that remain unused (either from being too small, or being unnecessary now) // should be disposed. THardwareBuffer hb; using (var e = _UnusedHardwareBuffers.GetEnumerator()) while (e.GetNext(out hb)) { hb.Age += 1; bool shouldKill = (hb.Age >= MaxBufferAge) || ((_UnusedHardwareBuffers.Count > MaxUnusedBuffers) && (hb.Age > 1)); if (shouldKill) { e.RemoveCurrent(); hb.Invalidate(); DisposeResource(hb); } } // Return any buffers that were used this frame to the unused state. foreach (var _hb in _UsedHardwareBuffers) { // HACK var hwb = _hb.Buffer; hwb.Invalidate(); _UnusedHardwareBuffers.Add(hwb); } _UsedHardwareBuffers.Clear(); foreach (var swb in _SoftwareBuffers) { swb.Uninitialize(); _SoftwareBufferPool.Release(swb); } _SoftwareBuffers.Clear(); /* * Array.Clear(_VertexArray, 0, _VertexArray.Length); * Array.Clear(_IndexArray, 0, _IndexArray.Length); */ } }
public void Clear () { var l = new UnorderedList<int>(new int[] { 1, 2 }); l.Clear(); Assert.AreEqual( new int[0], l.ToArray() ); l.Add(1); l.Add(2); Assert.AreEqual( new int[] { 1, 2 }, l.ToArray() ); }
public void Clear() { actionsStillWaiting.Clear(); TimedAction ignore; while (queuedUpdateCallbacks.Dequeue(out ignore)) { ; } foreach (var elem in recurrentCallbacks) { elem.Clear(); } foreach (var elem in delayedRemoves) { elem.Clear(); } timesUpdated = 0; }
public void Reset(int frameIndex) { lock (_StateLock) { _FillingHardwareBufferEntry = null; _FlushedToBuffers = 0; _VertexCount = _IndexCount = 0; lock (_StaticStateLock) StaticReset(frameIndex, RenderManager); // Return any buffers that were used this frame to the unused state. foreach (var _hb in _UsedHardwareBuffers) { // HACK var hwb = _hb.Buffer; hwb.Invalidate(frameIndex); lock (_StaticStateLock) _UnusedHardwareBuffers.Add(hwb); } _UsedHardwareBuffers.Clear(); _BufferCache.Clear(); foreach (var swb in _SoftwareBuffers) { swb.Uninitialize(); _SoftwareBufferPool.Release(swb); } _SoftwareBuffers.Clear(); _LastFrameReset = frameIndex; /* * Array.Clear(_VertexArray, 0, _VertexArray.Length); * Array.Clear(_IndexArray, 0, _IndexArray.Length); */ } }
private void ClearAndReturn(UnorderedList <T> list, UnorderedList <UnorderedList <T> > pool, int limit, WorkQueueNotifyMode notifyMode = WorkQueueNotifyMode.Stochastically) { if ( !FastClearEnabled && (list.Count > DeferredClearSizeThreshold) && (_ClearQueue != null) ) { _ClearQueue.Enqueue(new ListClearWorkItem { List = list, }, notifyChanged: notifyMode); return; } // HACK: Acquiring the lock here would be technically correct but // unnecessarily slow, since we're just trying to avoid doing a clear // in cases where the list will be GCd anyway if (pool.Count >= limit) { return; } if (FastClearEnabled) { list.UnsafeFastClear(); } else { list.Clear(); } lock (pool) { if (pool.Count >= limit) { return; } pool.Add(list); } }
void Dispose(bool finalizing) { if (IsDisposed) { return; } IsDisposed = true; lock (Threads) { foreach (var thread in Threads) { thread.Dispose(); } Threads.Clear(); } if (!finalizing) { GC.SuppressFinalize(this); } }
public void Reset() { Lines.Clear(); }
public void Reset() { UsedRectangles.Clear(); Dependencies.Clear(); VisitedByTopoSort = false; }
public void Reset(int frameIndex) { var id = RenderManager.DeviceManager.DeviceId; lock (_StateLock) { _FillingHardwareBufferEntry = null; _FlushedToBuffers = 0; _VertexCount = _IndexCount = 0; lock (_StaticStateLock) StaticReset(frameIndex, RenderManager); foreach (var _hb in _PreviouslyUsedHardwareBufferEntries) { _ReusableHardwareBufferEntries.Add(_hb); } _PreviouslyUsedHardwareBufferEntries.Clear(); // Return any buffers that were used this frame to the unused state. foreach (var _hb in _UsedHardwareBufferEntries) { _hb.AddedToList = false; _PreviouslyUsedHardwareBufferEntries.Add(_hb); // HACK var hwb = _hb.Buffer; if (hwb.DeviceId < id) { continue; } hwb.Invalidate(frameIndex); lock (_StaticStateLock) { if (hwb.IsLarge) { _LargeUnusedBufferCount++; } else { _SmallUnusedBufferCount++; } _UnusedHardwareBuffers.Add(hwb); } } _UsedHardwareBufferEntries.Clear(); foreach (var kvp in _BufferCache) { var swb = kvp.Value; if (!swb.IsInitialized) { continue; } // Console.WriteLine($"Uninit corner buffer {swb}"); swb.Uninitialize(); _SoftwareBufferPool.Release(swb); } _BufferCache.Clear(); foreach (var swb in _SoftwareBuffers) { if (!swb.IsInitialized) { continue; } swb.Uninitialize(); _SoftwareBufferPool.Release(swb); } _SoftwareBuffers.Clear(); _LastFrameReset = frameIndex; /* * Array.Clear(_VertexArray, 0, _VertexArray.Length); * Array.Clear(_IndexArray, 0, _IndexArray.Length); */ } }
public void Execute() { List.Clear(); ClearedLists.Value.Add(List); }