Move solution and projects to src

4 files changed, 0 insertions, 569 deletions

diff --git a/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs b/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs
deleted file mode 100644
index 9d43f6c3..00000000
--- a/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-using OpenTK.Graphics.OpenGL;
-using Ryujinx.Common.Logging;
-using System;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace Ryujinx.Graphics.OpenGL.Queries
-{
-    class BufferedQuery : IDisposable
-    {
-        private const int MaxQueryRetries = 5000;
-        private const long DefaultValue = -1;
-        private const ulong HighMask = 0xFFFFFFFF00000000;
-
-        public int Query { get; }
-
-        private int _buffer;
-        private IntPtr _bufferMap;
-        private QueryTarget _type;
-
-        public BufferedQuery(QueryTarget type)
-        {
-            _buffer = GL.GenBuffer();
-            Query = GL.GenQuery();
-            _type = type;
-
-            GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
-
-            unsafe
-            {
-                long defaultValue = DefaultValue;
-                GL.BufferStorage(BufferTarget.QueryBuffer, sizeof(long), (IntPtr)(&defaultValue), BufferStorageFlags.MapReadBit | BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit);
-            }
-            _bufferMap = GL.MapBufferRange(BufferTarget.QueryBuffer, IntPtr.Zero, sizeof(long), BufferAccessMask.MapReadBit | BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit);
-        }
-
-        public void Reset()
-        {
-            GL.EndQuery(_type);
-            GL.BeginQuery(_type, Query);
-        }
-
-        public void Begin()
-        {
-            GL.BeginQuery(_type, Query);
-        }
-
-        public unsafe void End(bool withResult)
-        {
-            GL.EndQuery(_type);
-
-            if (withResult)
-            {
-                GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
-
-                Marshal.WriteInt64(_bufferMap, -1L);
-                GL.GetQueryObject(Query, GetQueryObjectParam.QueryResult, (long*)0);
-                GL.MemoryBarrier(MemoryBarrierFlags.QueryBufferBarrierBit | MemoryBarrierFlags.ClientMappedBufferBarrierBit);
-            }
-            else
-            {
-                // Dummy result, just return 0.
-                Marshal.WriteInt64(_bufferMap, 0L);
-            }
-        }
-
-        private bool WaitingForValue(long data)
-        {
-            return data == DefaultValue ||
-                ((ulong)data & HighMask) == (unchecked((ulong)DefaultValue) & HighMask);
-        }
-
-        public bool TryGetResult(out long result)
-        {
-            result = Marshal.ReadInt64(_bufferMap);
-
-            return !WaitingForValue(result);
-        }
-
-        public long AwaitResult(AutoResetEvent wakeSignal = null)
-        {
-            long data = DefaultValue;
-
-            if (wakeSignal == null)
-            {
-                while (WaitingForValue(data))
-                {
-                    data = Marshal.ReadInt64(_bufferMap);
-                }
-            }
-            else
-            {
-                int iterations = 0;
-                while (WaitingForValue(data) && iterations++ < MaxQueryRetries)
-                {
-                    data = Marshal.ReadInt64(_bufferMap);
-                    if (WaitingForValue(data))
-                    {
-                        wakeSignal.WaitOne(1);
-                    }
-                }
-
-                if (iterations >= MaxQueryRetries)
-                {
-                    Logger.Error?.Print(LogClass.Gpu, $"Error: Query result timed out. Took more than {MaxQueryRetries} tries.");
-                }
-            }
-
-            return data;
-        }
-
-        public void Dispose()
-        {
-            GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
-            GL.UnmapBuffer(BufferTarget.QueryBuffer);
-            GL.DeleteBuffer(_buffer);
-            GL.DeleteQuery(Query);
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs b/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs
deleted file mode 100644
index e0aafa6f..00000000
--- a/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-using OpenTK.Graphics.OpenGL;
-using Ryujinx.Graphics.GAL;
-using System;
-using System.Collections.Generic;
-using System.Threading;
-
-namespace Ryujinx.Graphics.OpenGL.Queries
-{
-    class CounterQueue : IDisposable
-    {
-        private const int QueryPoolInitialSize = 100;
-
-        public CounterType Type { get; }
-        public bool Disposed { get; private set; }
-
-        private readonly Pipeline _pipeline;
-
-        private Queue<CounterQueueEvent> _events = new Queue<CounterQueueEvent>();
-        private CounterQueueEvent _current;
-
-        private ulong _accumulatedCounter;
-        private int _waiterCount;
-
-        private object _lock = new object();
-
-        private Queue<BufferedQuery> _queryPool;
-        private AutoResetEvent _queuedEvent = new AutoResetEvent(false);
-        private AutoResetEvent _wakeSignal = new AutoResetEvent(false);
-        private AutoResetEvent _eventConsumed = new AutoResetEvent(false);
-
-        private Thread _consumerThread;
-
-        internal CounterQueue(Pipeline pipeline, CounterType type)
-        {
-            Type = type;
-
-            _pipeline = pipeline;
-
-            QueryTarget glType = GetTarget(Type);
-
-            _queryPool = new Queue<BufferedQuery>(QueryPoolInitialSize);
-            for (int i = 0; i < QueryPoolInitialSize; i++)
-            {
-                _queryPool.Enqueue(new BufferedQuery(glType));
-            }
-
-            _current = new CounterQueueEvent(this, glType, 0);
-
-            _consumerThread = new Thread(EventConsumer);
-            _consumerThread.Start();
-        }
-
-        private void EventConsumer()
-        {
-            while (!Disposed)
-            {
-                CounterQueueEvent evt = null;
-                lock (_lock)
-                {
-                    if (_events.Count > 0)
-                    {
-                        evt = _events.Dequeue();
-                    }
-                }
-
-                if (evt == null)
-                {
-                    _queuedEvent.WaitOne(); // No more events to go through, wait for more.
-                }
-                else
-                {
-                    // Spin-wait rather than sleeping if there are any waiters, by passing null instead of the wake signal.
-                    evt.TryConsume(ref _accumulatedCounter, true, _waiterCount == 0 ? _wakeSignal : null);
-                }
-
-                if (_waiterCount > 0)
-                {
-                    _eventConsumed.Set();
-                }
-            }
-        }
-
-        internal BufferedQuery GetQueryObject()
-        {
-            // Creating/disposing query objects on a context we're sharing with will cause issues.
-            // So instead, make a lot of query objects on the main thread and reuse them.
-
-            lock (_lock)
-            {
-                if (_queryPool.Count > 0)
-                {
-                    BufferedQuery result = _queryPool.Dequeue();
-                    return result;
-                }
-                else
-                {
-                    return new BufferedQuery(GetTarget(Type));
-                }
-            }
-        }
-
-        internal void ReturnQueryObject(BufferedQuery query)
-        {
-            lock (_lock)
-            {
-                _queryPool.Enqueue(query);
-            }
-        }
-
-        public CounterQueueEvent QueueReport(EventHandler<ulong> resultHandler, ulong lastDrawIndex, bool hostReserved)
-        {
-            CounterQueueEvent result;
-            ulong draws = lastDrawIndex - _current.DrawIndex;
-
-            lock (_lock)
-            {
-                // A query's result only matters if more than one draw was performed during it.
-                // Otherwise, dummy it out and return 0 immediately.
-
-                if (hostReserved)
-                {
-                    // This counter event is guaranteed to be available for host conditional rendering.
-                    _current.ReserveForHostAccess();
-                }
-
-                _current.Complete(draws > 0, _pipeline.GetCounterDivisor(Type));
-                _events.Enqueue(_current);
-
-                _current.OnResult += resultHandler;
-
-                result = _current;
-
-                _current = new CounterQueueEvent(this, GetTarget(Type), lastDrawIndex);
-            }
-
-            _queuedEvent.Set();
-
-            return result;
-        }
-
-        public void QueueReset()
-        {
-            lock (_lock)
-            {
-                _current.Clear();
-            }
-        }
-
-        private static QueryTarget GetTarget(CounterType type)
-        {
-            switch (type)
-            {
-                case CounterType.SamplesPassed: return QueryTarget.SamplesPassed;
-                case CounterType.PrimitivesGenerated: return QueryTarget.PrimitivesGenerated;
-                case CounterType.TransformFeedbackPrimitivesWritten: return QueryTarget.TransformFeedbackPrimitivesWritten;
-            }
-
-            return QueryTarget.SamplesPassed;
-        }
-
-        public void Flush(bool blocking)
-        {
-            if (!blocking)
-            {
-                // Just wake the consumer thread - it will update the queries.
-                _wakeSignal.Set();
-                return;
-            }
-
-            lock (_lock)
-            {
-                // Tell the queue to process all events.
-                while (_events.Count > 0)
-                {
-                    CounterQueueEvent flush = _events.Peek();
-                    if (!flush.TryConsume(ref _accumulatedCounter, true))
-                    {
-                        return; // If not blocking, then return when we encounter an event that is not ready yet.
-                    }
-                    _events.Dequeue();
-                }
-            }
-        }
-
-        public void FlushTo(CounterQueueEvent evt)
-        {
-            // Flush the counter queue on the main thread.
-
-            Interlocked.Increment(ref _waiterCount);
-
-            _wakeSignal.Set();
-
-            while (!evt.Disposed)
-            {
-                _eventConsumed.WaitOne(1);
-            }
-
-            Interlocked.Decrement(ref _waiterCount);
-        }
-
-        public void Dispose()
-        {
-            lock (_lock)
-            {
-                while (_events.Count > 0)
-                {
-                    CounterQueueEvent evt = _events.Dequeue();
-
-                    evt.Dispose();
-                }
-
-                Disposed = true;
-            }
-
-            _queuedEvent.Set();
-
-            _consumerThread.Join();
-
-            foreach (BufferedQuery query in _queryPool)
-            {
-                query.Dispose();
-            }
-
-            _queuedEvent.Dispose();
-            _wakeSignal.Dispose();
-            _eventConsumed.Dispose();
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs b/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs
deleted file mode 100644
index 7297baab..00000000
--- a/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs
+++ /dev/null
@@ -1,163 +0,0 @@
-using OpenTK.Graphics.OpenGL;
-using Ryujinx.Graphics.GAL;
-using System;
-using System.Threading;
-
-namespace Ryujinx.Graphics.OpenGL.Queries
-{
-    class CounterQueueEvent : ICounterEvent
-    {
-        public event EventHandler<ulong> OnResult;
-
-        public QueryTarget Type { get; }
-        public bool ClearCounter { get; private set; }
-        public int Query => _counter.Query;
-
-        public bool Disposed { get; private set; }
-        public bool Invalid { get; set; }
-
-        public ulong DrawIndex { get; }
-
-        private CounterQueue _queue;
-        private BufferedQuery _counter;
-
-        private bool _hostAccessReserved = false;
-        private int _refCount = 1; // Starts with a reference from the counter queue.
-
-        private object _lock = new object();
-        private ulong _result = ulong.MaxValue;
-        private double _divisor = 1f;
-
-        public CounterQueueEvent(CounterQueue queue, QueryTarget type, ulong drawIndex)
-        {
-            _queue = queue;
-
-            _counter = queue.GetQueryObject();
-            Type = type;
-
-            DrawIndex = drawIndex;
-
-            _counter.Begin();
-        }
-
-        internal void Clear()
-        {
-            _counter.Reset();
-            ClearCounter = true;
-        }
-
-        internal void Complete(bool withResult, double divisor)
-        {
-            _counter.End(withResult);
-
-            _divisor = divisor;
-        }
-
-        internal bool TryConsume(ref ulong result, bool block, AutoResetEvent wakeSignal = null)
-        {
-            lock (_lock)
-            {
-                if (Disposed)
-                {
-                    return true;
-                }
-
-                if (ClearCounter || Type == QueryTarget.Timestamp)
-                {
-                    result = 0;
-                }
-
-                long queryResult;
-
-                if (block)
-                {
-                    queryResult = _counter.AwaitResult(wakeSignal);
-                }
-                else
-                {
-                    if (!_counter.TryGetResult(out queryResult))
-                    {
-                        return false;
-                    }
-                }
-
-                result += _divisor == 1 ? (ulong)queryResult : (ulong)Math.Ceiling(queryResult / _divisor);
-
-                _result = result;
-
-                OnResult?.Invoke(this, result);
-
-                Dispose(); // Return the our resources to the pool.
-
-                return true;
-            }
-        }
-
-        public void Flush()
-        {
-            if (Disposed)
-            {
-                return;
-            }
-
-            // Tell the queue to process all events up to this one.
-            _queue.FlushTo(this);
-        }
-
-        public void DecrementRefCount()
-        {
-            if (Interlocked.Decrement(ref _refCount) == 0)
-            {
-                DisposeInternal();
-            }
-        }
-
-        public bool ReserveForHostAccess()
-        {
-            if (_hostAccessReserved)
-            {
-                return true;
-            }
-
-            if (IsValueAvailable())
-            {
-                return false;
-            }
-
-            if (Interlocked.Increment(ref _refCount) == 1)
-            {
-                Interlocked.Decrement(ref _refCount);
-
-                return false;
-            }
-
-            _hostAccessReserved = true;
-
-            return true;
-        }
-
-        public void ReleaseHostAccess()
-        {
-            _hostAccessReserved = false;
-
-            DecrementRefCount();
-        }
-
-        private void DisposeInternal()
-        {
-            _queue.ReturnQueryObject(_counter);
-        }
-
-        private bool IsValueAvailable()
-        {
-            return _result != ulong.MaxValue || _counter.TryGetResult(out _);
-        }
-
-        public void Dispose()
-        {
-            Disposed = true;
-
-            DecrementRefCount();
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/Counters.cs b/Ryujinx.Graphics.OpenGL/Queries/Counters.cs
deleted file mode 100644
index e6c7ab2b..00000000
--- a/Ryujinx.Graphics.OpenGL/Queries/Counters.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using Ryujinx.Graphics.GAL;
-using System;
-
-namespace Ryujinx.Graphics.OpenGL.Queries
-{
-    class Counters : IDisposable
-    {
-        private CounterQueue[] _counterQueues;
-
-        public Counters()
-        {
-            int count = Enum.GetNames<CounterType>().Length;
-
-            _counterQueues = new CounterQueue[count];
-        }
-
-        public void Initialize(Pipeline pipeline)
-        {
-            for (int index = 0; index < _counterQueues.Length; index++)
-            {
-                CounterType type = (CounterType)index;
-                _counterQueues[index] = new CounterQueue(pipeline, type);
-            }
-        }
-
-        public CounterQueueEvent QueueReport(CounterType type, EventHandler<ulong> resultHandler, ulong lastDrawIndex, bool hostReserved)
-        {
-            return _counterQueues[(int)type].QueueReport(resultHandler, lastDrawIndex, hostReserved);
-        }
-
-        public void QueueReset(CounterType type)
-        {
-            _counterQueues[(int)type].QueueReset();
-        }
-
-        public void Update()
-        {
-            foreach (var queue in _counterQueues)
-            {
-                queue.Flush(false);
-            }
-        }
-
-        public void Flush(CounterType type)
-        {
-            _counterQueues[(int)type].Flush(true);
-        }
-
-        public void Dispose()
-        {
-            foreach (var queue in _counterQueues)
-            {
-                queue.Dispose();
-            }
-        }
-    }
-}
\ No newline at end of file