feat: texture management

Intersect (Core)/Compression/GzipCompression.cs → Framework/Intersect.Framework.Core/Compression/GzipCompression.cs

@@ -11,7 +11,7 @@
 {
 
     // Our cryptographic provider, and the key to be used to encrypt. Note, it NEEDS to be 16 characters or more!
     private static AesCryptoServiceProvider cryptoProvider;
     private static string cryptoKey = "T3ZncHUsIGdueHIgdmcgYmUgeXJuaXIgdmcu";
 
     /// <summary>
@@ -23,7 +23,7 @@
 
         // Take a few bytes out of this delicious morsel and grow stronk.
         var keyBytes = ASCIIEncoding.ASCII.GetBytes(cryptoKey);
-        cryptoProvider.Key = keyBytes.Take(16).ToArray();    
+        cryptoProvider.Key = keyBytes.Take(16).ToArray();
         cryptoProvider.IV = keyBytes.Reverse().Take(16).ToArray();
     }
 
@@ -56,11 +56,11 @@
     }
 
     /// <summary>
-    /// Read decompressed unencrypted data from an existing filestream.
+    /// Read decompressed unencrypted data from an existing <see cref="Stream"/>.
     /// </summary>
-    /// <param name="stream">The Filestream to write data from.</param>
+    /// <param name="stream">The <see cref="Stream"/> to write data from.</param>
     /// <returns>Returns a decompressed <see cref="CryptoStream"/> of the stream's content.</returns>
-    public static CryptoStream CreateDecompressedFileStream(FileStream stream)
+    public static CryptoStream CreateDecompressedFileStream(Stream stream)
     {
         if (cryptoProvider == null)
         {

Framework/Intersect.Framework.Core/Core/IApplicationContext.cs

@@ -51,6 +51,11 @@ bool IsDebug
     /// </summary>
     bool IsRunning { get; }
 
+    /// <summary>
+    /// The name of the application.
+    /// </summary>
+    string Name { get; }
+
     /// <summary>
     /// The options the application was started with.
     /// </summary>

Framework/Intersect.Framework.Core/Intersect.Framework.Core.csproj

@@ -28,6 +28,7 @@
 
     <ItemGroup>
       <PackageReference Include="Ceras" Version="4.1.7" />
+      <PackageReference Include="CommandLineParser" Version="2.9.1" />
       <PackageReference Include="K4os.Compression.LZ4" Version="1.3.6" />
       <PackageReference Include="MessagePack" Version="2.5.187" />
       <PackageReference Include="MessagePackAnalyzer" Version="2.6.100-alpha">

Framework/Intersect.Framework.Core/Point.cs

@@ -76,4 +76,9 @@ public static Point FromString(string val)
 
     public static Point operator /(Point point, float scalar) => new((int)(point.X / scalar), (int)(point.Y / scalar));
 
+    public void Deconstruct(out int x, out int y)
+    {
+        x = X;
+        y = Y;
+    }
 }

Intersect (Core)/Utilities/Timing.cs → Framework/Intersect.Framework.Core/Timing.cs

@@ -1,6 +1,6 @@
 using System.Runtime.CompilerServices;
 
-namespace Intersect.Utilities;
+namespace Intersect.Framework.Core;
 
 /// <summary>
 /// Utility class for timing.

Framework/Intersect.Framework/Collections/ConcurrentConditionalDequeue.cs

@@ -0,0 +1,127 @@
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Intersect.Framework.Collections;
+
+public class ConcurrentConditionalDequeue<TValue> : IReadOnlyCollection<TValue>, IProducerConsumerCollection<TValue>
+{
+    private static readonly Func<TValue, TValue, bool> IsEqual =
+        typeof(TValue).IsValueType ? StructEquals : (a, b) => ReferenceEquals(a, b);
+
+    private readonly object _dequeueLock = new();
+    private readonly ConcurrentQueue<TValue> _queue = [];
+
+    private ICollection QueueAsGenericCollection => _queue;
+
+    private IProducerConsumerCollection<TValue> QueueAsProducerConsumerCollection => _queue;
+
+    public bool IsReadOnly => false;
+
+    public void CopyTo(TValue[] array, int arrayIndex)
+    {
+        _queue.CopyTo(array, arrayIndex);
+    }
+
+    public TValue[] ToArray()
+    {
+        return _queue.ToArray();
+    }
+
+    bool IProducerConsumerCollection<TValue>.TryAdd(TValue item)
+    {
+        return QueueAsProducerConsumerCollection.TryAdd(item);
+    }
+
+    bool IProducerConsumerCollection<TValue>.TryTake([MaybeNullWhen(false)] out TValue item)
+    {
+        lock (_dequeueLock)
+        {
+            return QueueAsProducerConsumerCollection.TryTake(out item);
+        }
+    }
+
+    void ICollection.CopyTo(Array array, int index)
+    {
+        QueueAsGenericCollection.CopyTo(array, index);
+    }
+
+    bool ICollection.IsSynchronized => QueueAsProducerConsumerCollection.IsSynchronized;
+
+    object ICollection.SyncRoot => QueueAsProducerConsumerCollection.SyncRoot;
+
+    public int Count => _queue.Count;
+
+    public IEnumerator<TValue> GetEnumerator()
+    {
+        return _queue.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+
+    public void Clear()
+    {
+        lock (_dequeueLock)
+        {
+            _queue.Clear();
+        }
+    }
+
+    public void Enqueue(TValue item)
+    {
+        _queue.Enqueue(item);
+    }
+
+    public bool TryDequeueIf(Func<TValue, bool> consumer)
+    {
+        return TryDequeueIf(consumer, out _);
+    }
+
+    public bool TryDequeueIf(Func<TValue, bool> consumer, [NotNullWhen(true)] out TValue? value)
+    {
+        ArgumentNullException.ThrowIfNull(consumer);
+
+        lock (_dequeueLock)
+        {
+            if (!_queue.TryPeek(out value))
+            {
+                return false;
+            }
+
+            if (value == null)
+            {
+                return false;
+            }
+
+            if (!consumer(value))
+            {
+                return false;
+            }
+
+            if (!_queue.TryDequeue(out var dequeuedValue))
+            {
+                throw new InvalidOperationException("Dequeue failed, collection may have been removed from or cleared without being locked.");
+            }
+
+            if (!IsEqual(value, dequeuedValue))
+            {
+                throw new InvalidOperationException("Unexpected dequeued value, collection may have been removed from or cleared without being locked.");
+            }
+
+            return true;
+        }
+    }
+
+    public bool TryPeek([NotNullWhen(true)] out TValue? value)
+    {
+        lock (_dequeueLock)
+        {
+            return _queue.TryPeek(out value);
+        }
+    }
+
+    private static bool StructEquals(TValue a, TValue b) => a!.Equals(b);
+}

Framework/Intersect.Framework/Collections/ListExtensions.cs

@@ -0,0 +1,109 @@
+namespace Intersect.Framework.Collections;
+
+public static class ListExtensions
+{
+    public static void AddSorted<T>(this List<T> @this, T item) where T : IComparable<T>
+    {
+        if (@this.Count == 0)
+        {
+            @this.Add(item);
+            return;
+        }
+
+        if (@this[^1].CompareTo(item) <= 0)
+        {
+            @this.Add(item);
+            return;
+        }
+
+        if (@this[0].CompareTo(item) >= 0)
+        {
+            @this.Insert(0, item);
+            return;
+        }
+
+        int index = @this.BinarySearch(item);
+        if (index < 0)
+        {
+            index = ~index;
+        }
+        @this.Insert(index, item);
+    }
+
+    public static void Resort<T>(this List<T> @this, T item) where T : IComparable<T>
+    {
+        if (@this.Count < 1)
+        {
+            @this.AddSorted(item);
+            return;
+        }
+
+        @this.Remove(item);
+        @this.AddSorted(item);
+    }
+
+    private sealed class KeyComparer<TItem, TKey>(Func<TItem?, TKey?> keySelector)
+        : IComparer<TItem> where TKey : IComparable<TKey>
+    {
+        public int Compare(TItem? x, TItem? y)
+        {
+            var keyX = keySelector(x);
+            var keyY = keySelector(y);
+
+            if (keyX is not null)
+            {
+                return keyX.CompareTo(keyY);
+            }
+
+            if (keyY is null)
+            {
+                return 0;
+            }
+
+            return -keyY.CompareTo(keyX);
+        }
+    }
+
+    public static void AddSorted<TItem, TKey>(this List<TItem> @this, TItem item, Func<TItem?, TKey?> keySelector) where TKey : IComparable<TKey>
+    {
+        if (@this.Count == 0)
+        {
+            @this.Add(item);
+            return;
+        }
+
+        KeyComparer<TItem, TKey> comparer = new(keySelector);
+
+        if (comparer.Compare(@this[^1], item) <= 0)
+        {
+            @this.Add(item);
+            return;
+        }
+
+        if (comparer.Compare(@this[0], item) >= 0)
+        {
+            @this.Insert(0, item);
+            return;
+        }
+
+        int index = @this.BinarySearch(item, comparer);
+        if (index < 0)
+        {
+            index = ~index;
+        }
+        @this.Insert(index, item);
+    }
+
+    public static void Resort<TItem, TKey>(this List<TItem> @this, TItem item, Func<TItem?, TKey?> keySelector)
+        where TKey : IComparable<TKey>
+    {
+        if (@this.Count < 1)
+        {
+            @this.AddSorted(item, keySelector);
+            return;
+        }
+
+        @this.Remove(item);
+        @this.AddSorted(item, keySelector);
+    }
+}

Framework/Intersect.Framework/Eventing/EventHandler`2.cs

@@ -0,0 +1,3 @@
+namespace Intersect.Framework.Eventing;
+
+public delegate void EventHandler<in TSender, in TArgs>(TSender sender, TArgs args) where TArgs : EventArgs;

Framework/Intersect.Framework/Intersect.Framework.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <ItemGroup>
+      <PackageReference Include="Hardware.Info" Version="101.0.1" />
       <PackageReference Include="MessagePack.Annotations" Version="2.6.100-alpha" />
       <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="7.0.14" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.2" />
@@ -32,4 +33,8 @@
     </EmbeddedResource>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="System\" />
+  </ItemGroup>
+
 </Project>

Framework/Intersect.Framework/SystemInformation/IGPUStatisticsProvider.cs

@@ -0,0 +1,8 @@
+namespace Intersect.Framework.SystemInformation;
+
+public interface IGPUStatisticsProvider
+{
+    long? AvailableMemory { get; }
+
+    long? TotalMemory { get; }
+}