コード例 #1
0
        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;
        }
コード例 #2
0
        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);
                }
            }
        }
コード例 #3
0
            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);
                }
            }
コード例 #4
0
ファイル: DenseList.cs プロジェクト: jli94/Fracture
        public void Clear()
        {
            if (_Count != 0)
            {
                _Count = 0;
                Item1  = Item2 = Item3 = Item4 = default(T);
            }

            if (_HasList)
            {
                Items.Clear();
            }
        }
コード例 #5
0
        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();
            }
        }
コード例 #6
0
        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);
            }
        }
コード例 #7
0
        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;
                    }
                }
            }
        }
コード例 #8
0
            public static void Free(UnorderedList <T> queue)
            {
                queue.Clear();

                if (UnusedLists.Count > Capacity)
                {
                    return;
                }

                UnusedLists.Add(queue);
            }
コード例 #9
0
        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;
            }
        }
コード例 #10
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);
                 */
            }
        }
コード例 #11
0
        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()
            );
        }
コード例 #12
0
        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;
        }
コード例 #13
0
ファイル: BufferGenerator.cs プロジェクト: jli94/Fracture
        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);
                 */
            }
        }
コード例 #14
0
        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);
            }
        }
コード例 #15
0
ファイル: ThreadGroup.cs プロジェクト: jli94/Fracture
        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);
            }
        }
コード例 #16
0
 public void Reset()
 {
     Lines.Clear();
 }
コード例 #17
0
 public void Reset()
 {
     UsedRectangles.Clear();
     Dependencies.Clear();
     VisitedByTopoSort = false;
 }
コード例 #18
0
        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);
                 */
            }
        }
コード例 #19
0
 public void Execute()
 {
     List.Clear();
     ClearedLists.Value.Add(List);
 }