image loader for imgui and optional nuget icons for plugins in browse tab

CringePlugins/Services/ImGuiImageService.cs

@@ -0,0 +1,243 @@
+using System.Diagnostics;
+using System.Net;
+using System.Net.Http.Headers;
+using System.Numerics;
+using System.Security.Cryptography;
+using System.Text;
+using NLog;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using VRage.Collections;
+using VRageRender;
+
+namespace CringePlugins.Services;
+
+public interface IImGuiImageService
+{
+    ImGuiImage GetFromUrl(Uri url);
+    ImGuiImage GetFromPath(string path);
+}
+
+internal sealed class ImGuiImageService(HttpClient client) : IImGuiImageService
+{
+    private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+    private readonly string _dir = Directory.CreateDirectory(
+        Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "CringeLauncher", "cache", "images")).FullName;
+    private readonly CachingDictionary<ImageIdentifier, Image> _images = [];
+    private readonly Dictionary<ImageIdentifier, ImageReference> _imageReferences = [];
+    private readonly Dictionary<WebImageIdentifier, EntityTagHeaderValue> _webCacheEtag = [];
+    private Image? _placeholderImage;
+
+    internal void Initialize()
+    {
+        using var tex = new Texture2D(MyRender11.DeviceInstance, new()
+        {
+            Width = 1,
+            Height = 1,
+            Format = Format.R8G8B8A8_UNorm,
+            MipLevels = 1,
+            ArraySize = 1,
+            SampleDescription = new()
+            {
+                Count = 1
+            },
+            Usage = ResourceUsage.Default,
+            BindFlags = BindFlags.ShaderResource,
+            CpuAccessFlags = CpuAccessFlags.None,
+            OptionFlags = ResourceOptionFlags.None,
+        });
+
+        var srv = new ShaderResourceView(MyRender11.DeviceInstance, tex);
+        
+        _placeholderImage = new Image(null!, srv, new(1, 1));
+    }
+
+    internal void Update()
+    {
+        foreach (var (identifier, image) in _images)
+        {
+            if (!image.IsUnused)
+                continue;
+
+            _images.Remove(identifier);
+            _imageReferences.Remove(identifier);
+            image.Dispose();
+        }
+        _images.ApplyRemovals();
+    }
+
+    public ImGuiImage GetFromUrl(Uri url)
+    {
+        var identifier = new WebImageIdentifier(url);
+        if (_images.TryGetValue(identifier, out var image))
+            return image;
+        if (_imageReferences.TryGetValue(identifier, out var imageReference))
+            return imageReference;
+
+        var cachePath = Path.Join(_dir,
+            Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(url.ToString()))));
+
+        var reference = new ImageReference(_placeholderImage!);
+        LoadAsync(url, cachePath, reference);
+        _imageReferences.Add(identifier, reference);
+        return reference;
+    }
+
+    private async void LoadAsync(Uri url, string cachePath, ImageReference reference)
+    {
+        try
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, url);
+            if (_webCacheEtag.TryGetValue(new(url), out var existingEtag)) 
+                request.Headers.IfNoneMatch.Add(existingEtag);
+            using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+
+            response.EnsureSuccessStatusCode();
+            
+            if (response.Headers.ETag is { } etag)
+                _webCacheEtag[new(url)] = etag;
+
+            if (!File.Exists(cachePath) || (response.StatusCode != HttpStatusCode.NotModified &&
+                                            !CompareCache(cachePath, response.Headers)))
+            {
+                await using var stream = await response.Content.ReadAsStreamAsync();
+                await using var file = File.Create(cachePath);
+                await stream.CopyToAsync(file);
+            }
+
+            reference.Image = GetFromPath(cachePath);
+        }
+        catch (Exception e)
+        {
+            Log.Error(e, "Failed to load image {Url}", url);
+            reference.ErrorImage = null; // todo make an error image
+        }
+    }
+
+    private static bool CompareCache(string path, HttpResponseHeaders headers)
+    {
+        if (headers.CacheControl is not { } cacheControl)
+            return false;
+
+        if (cacheControl.NoCache)
+            return false;
+
+        if (cacheControl.MaxAge.HasValue)
+        {
+            var responseAge = DateTimeOffset.UtcNow - cacheControl.MaxAge.Value;
+            return File.GetLastWriteTimeUtc(path) > responseAge; 
+        }
+
+        return true;
+    }
+
+    public ImGuiImage GetFromPath(string path)
+    {
+        path = Path.GetFullPath(path);
+        var identifier = new FileImageIdentifier(path);
+        if (_images.TryGetValue(identifier, out var image))
+            return image;
+
+        if (!File.Exists(path))
+            throw new FileNotFoundException(null, path);
+
+        using var img = SharpDX.Toolkit.Graphics.Image.Load(path);
+
+        var desc = img.Description;
+        using var tex = new Texture2D(MyRender11.DeviceInstance, new()
+        {
+            Width = desc.Width,
+            Height = desc.Height,
+            Format = desc.Format,
+            MipLevels = desc.MipLevels,
+            ArraySize = desc.ArraySize,
+            SampleDescription = new()
+            {
+                Count = 1
+            },
+            Usage = ResourceUsage.Default,
+            BindFlags = BindFlags.ShaderResource,
+            CpuAccessFlags = CpuAccessFlags.None,
+            OptionFlags = ResourceOptionFlags.None,
+        }, img.ToDataBox());
+        
+        var srv = new ShaderResourceView(MyRender11.DeviceInstance, tex);
+        
+        image = new Image(identifier, srv, new(desc.Width, desc.Height));
+        _images.Add(identifier, image, true);
+        return image;
+    }
+    
+    private class ImageReference(ImGuiImage placeholderImage) : ImGuiImage
+    {
+        public ImGuiImage? Image;
+        public ImGuiImage? ErrorImage;
+
+        public override nint TextureId => Image ?? ErrorImage ?? placeholderImage;
+        public override Vector2 Size => Image ?? ErrorImage ?? placeholderImage;
+        
+        public override void Dispose()
+        {
+            Image?.Dispose();
+            ErrorImage?.Dispose();
+        }
+    }
+    
+    private class Image(ImageIdentifier identifier, ShaderResourceView srv, Vector2 size) : ImGuiImage
+    {
+        private bool _disposed;
+        private long _lastUse = Stopwatch.GetTimestamp();
+
+        public override nint TextureId
+        {
+            get
+            {
+                OnUse();
+                return srv.NativePointer;
+            }
+        }
+
+        public override Vector2 Size
+        {
+            get
+            {
+                OnUse();
+                return size;
+            }
+        }
+
+        public bool IsUnused => _disposed || Stopwatch.GetElapsedTime(_lastUse) > TimeSpan.FromMinutes(5);
+
+        private void OnUse()
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this); 
+            _lastUse = Stopwatch.GetTimestamp();
+        }
+
+        public override void Dispose()
+        {
+            if (_disposed) return;
+            _disposed = true;
+            srv.Dispose();
+        }
+
+        public override string ToString()
+        {
+            return $"Image {{ {identifier} {size} }}"; 
+        }
+    }
+
+    private abstract record ImageIdentifier;
+    private record WebImageIdentifier(Uri Url) : ImageIdentifier;
+    private record FileImageIdentifier(string Path) : ImageIdentifier; 
+}
+
+public abstract class ImGuiImage : IDisposable
+{
+    public abstract nint TextureId { get; }
+    public abstract Vector2 Size { get; }
+    
+    public static implicit operator nint(ImGuiImage image) => image.TextureId;
+    public static implicit operator Vector2(ImGuiImage image) => image.Size;
+    public abstract void Dispose();
+}