feat: new ITextureProvider, ITextureSubstitutionProvider, TextureManager services

Ref-counts textures and evicts when not used

Dalamud/Interface/Internal/DalamudTextureWrap.cs

@@ -4,11 +4,19 @@ using ImGuiScene;
 
 namespace Dalamud.Interface.Internal;
 
+/// <summary>
+/// Base TextureWrap interface for all Dalamud-owned texture wraps.
+/// Used to avoid referencing ImGuiScene.
+/// </summary>
+public interface IDalamudTextureWrap : TextureWrap
+{
+}
+
 /// <summary>
 /// Safety harness for ImGuiScene textures that will defer destruction until
 /// the end of the frame.
 /// </summary>
-public class DalamudTextureWrap : TextureWrap
+public class DalamudTextureWrap : IDalamudTextureWrap
 {
     private readonly TextureWrap wrappedWrap;
 

Dalamud/Interface/Internal/TextureManager.cs

@@ -0,0 +1,458 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+using Dalamud.Data;
+using Dalamud.Game;
+using Dalamud.IoC;
+using Dalamud.IoC.Internal;
+using Dalamud.Logging.Internal;
+using Dalamud.Plugin.Services;
+using ImGuiScene;
+using Lumina.Data;
+using Lumina.Data.Files;
+
+namespace Dalamud.Interface.Internal;
+
+/// <summary>
+/// Service responsible for loading and disposing ImGui texture wraps.
+/// </summary>
+[PluginInterface]
+[InterfaceVersion("1.0")]
+[ServiceManager.BlockingEarlyLoadedService]
+#pragma warning disable SA1015
+[ResolveVia<ITextureSubstitutionProvider>]
+#pragma warning restore SA1015
+internal class TextureManager : IDisposable, IServiceType, ITextureSubstitutionProvider
+{
+    private const string IconFileFormat = "ui/icon/{0:D3}000/{1}{2:D6}.tex";
+    private const string HighResolutionIconFileFormat = "ui/icon/{0:D3}000/{1}{2:D6}_hr1.tex";
+
+    private const uint MillisecondsEvictionTime = 2000;
+    
+    private static readonly ModuleLog Log = new("TEXM");
+
+    private readonly Framework framework;
+    private readonly DataManager dataManager;
+    private readonly DalamudStartInfo startInfo;
+    
+    private readonly Dictionary<string, TextureInfo> activeTextures = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TextureManager"/> class.
+    /// </summary>
+    /// <param name="framework">Framework instance.</param>
+    /// <param name="dataManager">DataManager instance.</param>
+    /// <param name="startInfo">DalamudStartInfo instance.</param>
+    [ServiceManager.ServiceConstructor]
+    public TextureManager(Framework framework, DataManager dataManager, DalamudStartInfo startInfo)
+    {
+        this.framework = framework;
+        this.dataManager = dataManager;
+        this.startInfo = startInfo;
+
+        this.framework.Update += this.FrameworkOnUpdate;
+    }
+
+    /// <inheritdoc/>
+    public event ITextureSubstitutionProvider.TextureDataInterceptorDelegate? InterceptTexDataLoad;
+    
+    /// <summary>
+    /// Get a texture handle for a specific icon.
+    /// </summary>
+    /// <param name="iconId">The ID of the icon to load.</param>
+    /// <param name="flags">Options to be considered when loading the icon.</param>
+    /// <param name="language">
+    /// The language to be considered when loading the icon, if the icon has versions for multiple languages.
+    /// If null, default to the game's current language.
+    /// </param>
+    /// <param name="keepAlive">
+    /// Prevent Dalamud from automatically unloading this icon to save memory. Usually does not need to be set.
+    /// </param>
+    /// <returns>
+    /// Null, if the icon does not exist in the specified configuration, or a texture wrap that can be used
+    /// to render the icon.
+    /// </returns>
+    public TextureManagerTextureWrap? GetIcon(uint iconId, ITextureProvider.IconFlags flags = ITextureProvider.IconFlags.ItemHighQuality, ClientLanguage? language = null, bool keepAlive = false)
+    {
+        var hiRes = flags.HasFlag(ITextureProvider.IconFlags.HiRes);
+        
+        // 1. Item
+        var path = FormatIconPath(
+            iconId,
+            flags.HasFlag(ITextureProvider.IconFlags.ItemHighQuality) ? "hq/" : string.Empty,
+            hiRes);
+        if (this.dataManager.FileExists(path))
+            return this.CreateWrap(path, keepAlive);
+        
+        language ??= this.startInfo.Language;
+        var languageFolder = language switch
+        {
+            ClientLanguage.Japanese => "ja/",
+            ClientLanguage.English => "en/",
+            ClientLanguage.German => "de/",
+            ClientLanguage.French => "fr/",
+            _ => throw new ArgumentOutOfRangeException(nameof(language), $"Unknown Language: {language}"),
+        };
+        
+        // 2. Regular icon, with language, hi-res
+        path = FormatIconPath(
+            iconId,
+            languageFolder,
+            hiRes);
+        if (this.dataManager.FileExists(path))
+            return this.CreateWrap(path, keepAlive);
+
+        if (hiRes)
+        {
+            // 3. Regular icon, with language, no hi-res
+            path = FormatIconPath(
+                iconId,
+                languageFolder,
+                false);
+            if (this.dataManager.FileExists(path))
+                return this.CreateWrap(path, keepAlive);
+        }
+
+        // 4. Regular icon, without language, hi-res
+        path = FormatIconPath(
+            iconId,
+            null,
+            hiRes);
+        if (this.dataManager.FileExists(path))
+            return this.CreateWrap(path, keepAlive);
+        
+        // 4. Regular icon, without language, no hi-res
+        if (hiRes)
+        {
+            path = FormatIconPath(
+                iconId,
+                null,
+                false);
+            if (this.dataManager.FileExists(path))
+                return this.CreateWrap(path, keepAlive);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Get a texture handle for the texture at the specified path.
+    /// You may only specify paths in the game's VFS.
+    /// </summary>
+    /// <param name="path">The path to the texture in the game's VFS.</param>
+    /// <param name="keepAlive">Prevent Dalamud from automatically unloading this texture to save memory. Usually does not need to be set.</param>
+    /// <returns>Null, if the icon does not exist, or a texture wrap that can be used to render the texture.</returns>
+    public TextureManagerTextureWrap? GetTextureFromGamePath(string path, bool keepAlive)
+    {
+        return !this.dataManager.FileExists(path) ? null : this.CreateWrap(path, keepAlive);
+    }
+    
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        this.framework.Update -= this.FrameworkOnUpdate;
+        
+        Log.Verbose("Disposing {Num} left behind textures.");
+        
+        foreach (var activeTexture in this.activeTextures)
+        {
+            activeTexture.Value.Wrap?.Dispose();
+        }
+        
+        this.activeTextures.Clear();
+    }
+
+    /// <summary>
+    /// Get texture info.
+    /// </summary>
+    /// <param name="path">Path to the texture.</param>
+    /// <param name="refresh">Whether or not the texture should be reloaded if it was unloaded.</param>
+    /// <returns>Info object storing texture metadata.</returns>
+    internal TextureInfo GetInfo(string path, bool refresh = true)
+    {
+        TextureInfo? info;
+        lock (this.activeTextures)
+        {
+            this.activeTextures.TryGetValue(path, out info);
+        }
+
+        if (info == null)
+        {
+            info = new TextureInfo();
+            lock (this.activeTextures)
+            {
+                if (!this.activeTextures.TryAdd(path, info))
+                    Log.Warning("Texture {Path} tracked twice, this might not be an issue", path);
+            }
+        }
+        
+        if (refresh && info.KeepAliveCount == 0)
+            info.LastAccess = DateTime.Now;
+        
+        if (info is { Wrap: not null })
+            return info;
+
+        if (refresh)
+        {
+            byte[]? interceptData = null;
+            this.InterceptTexDataLoad?.Invoke(path, ref interceptData);
+
+            // TODO: Do we also want to support loading from actual fs here? Doesn't seem to be a big deal, collect interest
+            
+            TexFile? file;
+            if (interceptData != null)
+            {
+                // TODO: upstream to lumina
+                file = Activator.CreateInstance<TexFile>();
+                var type = typeof(TexFile);
+                type.GetProperty("Data", BindingFlags.NonPublic | BindingFlags.Instance)!.GetSetMethod()!
+                    .Invoke(file, new object[] { interceptData });
+                type.GetProperty("Reader", BindingFlags.NonPublic | BindingFlags.Instance)!.GetSetMethod()!
+                    .Invoke(file, new object[] { new LuminaBinaryReader(file.Data) });
+                file.LoadFile();
+            }
+            else
+            {
+                file = this.dataManager.GetFile<TexFile>(path);
+            }
+            
+            var wrap = this.dataManager.GetImGuiTexture(file);
+            info.Wrap = wrap;
+        }
+
+        return info;
+    }
+
+    /// <summary>
+    /// Notify the system about an instance of a texture wrap being disposed.
+    /// If required conditions are met, the texture will be unloaded at the next update.
+    /// </summary>
+    /// <param name="path">The path to the texture.</param>
+    /// <param name="keepAlive">Whether or not this handle was created in keep-alive mode.</param>
+    internal void NotifyTextureDisposed(string path, bool keepAlive)
+    {
+        var info = this.GetInfo(path, false);
+        info.RefCount--;
+
+        if (keepAlive)
+            info.KeepAliveCount--;
+
+        // Clean it up by the next update. If it's re-requested in-between, we don't reload it.
+        if (info.RefCount <= 0)
+            info.LastAccess = default;
+    }
+
+    private static string FormatIconPath(uint iconId, string? type, bool highResolution)
+    {
+        var format = highResolution ? HighResolutionIconFileFormat : IconFileFormat;
+        
+        type ??= string.Empty;
+        if (type.Length > 0 && !type.EndsWith("/"))
+            type += "/";
+
+        return string.Format(format, iconId / 1000, type, iconId);
+    }
+    
+    private TextureManagerTextureWrap? CreateWrap(string path, bool keepAlive)
+    {
+        // This will create the texture.
+        // That's fine, it's probably used immediately and this will let the plugin catch load errors.
+        var info = this.GetInfo(path, keepAlive);
+        info.RefCount++;
+
+        if (keepAlive)
+            info.KeepAliveCount++;
+
+        return new TextureManagerTextureWrap(path, keepAlive, this);
+    }
+
+    private void FrameworkOnUpdate(Framework fw)
+    {
+        lock (this.activeTextures)
+        {
+            var toRemove = new List<string>();
+
+            foreach (var texInfo in this.activeTextures)
+            {
+                if (texInfo.Value.RefCount == 0)
+                {
+                    Log.Verbose("Evicting {Path} since no refs", texInfo.Key);
+
+                    Debug.Assert(texInfo.Value.KeepAliveCount == 0, "texInfo.Value.KeepAliveCount == 0");
+                    
+                    texInfo.Value.Wrap?.Dispose();
+                    texInfo.Value.Wrap = null;
+                    toRemove.Add(texInfo.Key);
+                    continue;
+                }
+                
+                if (texInfo.Value.KeepAliveCount > 0 || texInfo.Value.Wrap == null)
+                    continue;
+
+                if (DateTime.Now - texInfo.Value.LastAccess > TimeSpan.FromMilliseconds(MillisecondsEvictionTime))
+                {
+                    Log.Verbose("Evicting {Path} since too old", texInfo.Key);
+                    texInfo.Value.Wrap.Dispose();
+                    texInfo.Value.Wrap = null;
+                }
+            }
+
+            foreach (var path in toRemove)
+            {
+                this.activeTextures.Remove(path);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Internal representation of a managed texture.
+    /// </summary>
+    internal class TextureInfo
+    {
+        /// <summary>
+        /// Gets or sets the actual texture wrap. May be unpopulated.
+        /// </summary>
+        public TextureWrap? Wrap { get; set; }
+        
+        /// <summary>
+        /// Gets or sets the time the texture was last accessed.
+        /// </summary>
+        public DateTime LastAccess { get; set; }
+
+        /// <summary>
+        /// Gets or sets the number of active holders of this texture.
+        /// </summary>
+        public uint RefCount { get; set; }
+        
+        /// <summary>
+        /// Gets or sets the number of active holders that want this texture to stay alive forever.
+        /// </summary>
+        public uint KeepAliveCount { get; set; }
+    }
+}
+
+/// <summary>
+/// Plugin-scoped version of a texture manager.
+/// </summary>
+[PluginInterface]
+[InterfaceVersion("1.0")]
+[ServiceManager.ScopedService]
+#pragma warning disable SA1015
+[ResolveVia<ITextureProvider>]
+#pragma warning restore SA1015
+internal class TextureManagerPluginScoped : ITextureProvider, IServiceType, IDisposable
+{
+    private readonly DataManager dataManager;
+    private readonly TextureManager textureManager;
+
+    private readonly List<TextureManagerTextureWrap> trackedTextures = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TextureManagerPluginScoped"/> class.
+    /// </summary>
+    /// <param name="dataManager">DataManager instance.</param>
+    /// <param name="textureManager">TextureManager instance.</param>
+    public TextureManagerPluginScoped(DataManager dataManager, TextureManager textureManager)
+    {
+        this.dataManager = dataManager;
+        this.textureManager = textureManager;
+    }
+
+    /// <inheritdoc/>
+    public IDalamudTextureWrap? GetIcon(
+        uint iconId,
+        ITextureProvider.IconFlags flags = ITextureProvider.IconFlags.ItemHighQuality,
+        ClientLanguage? language = null,
+        bool keepAlive = false)
+    {
+        var wrap = this.textureManager.GetIcon(iconId, flags, language, keepAlive);
+        if (wrap == null)
+            return null;
+        
+        this.trackedTextures.Add(wrap);
+        return wrap;
+    }
+
+    /// <inheritdoc/>
+    public IDalamudTextureWrap? GetTextureFromGamePath(string path, bool keepAlive = false)
+    {
+        var wrap = this.textureManager.GetTextureFromGamePath(path, keepAlive);
+        if (wrap == null)
+            return null;
+        
+        this.trackedTextures.Add(wrap);
+        return wrap;
+    }
+
+    /// <inheritdoc/>
+    public IDalamudTextureWrap GetTexture(TexFile file)
+    {
+        return this.dataManager.GetImGuiTexture(file) as DalamudTextureWrap ?? throw new ArgumentException("Could not load texture");
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        // Dispose all leaked textures
+        foreach (var textureWrap in this.trackedTextures.Where(x => !x.IsDisposed))
+        {
+            textureWrap.Dispose();
+        }
+    }
+}
+
+/// <summary>
+/// Wrap.
+/// </summary>
+internal class TextureManagerTextureWrap : IDalamudTextureWrap
+{
+    private readonly TextureManager manager;
+    private readonly string path;
+    private readonly bool keepAlive;
+
+    private int? width;
+    private int? height;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TextureManagerTextureWrap"/> class.
+    /// </summary>
+    /// <param name="path">The path to the texture.</param>
+    /// <param name="keepAlive">Keep alive or not.</param>
+    /// <param name="manager">Manager that we obtained this from.</param>
+    internal TextureManagerTextureWrap(string path, bool keepAlive, TextureManager manager)
+    {
+        this.path = path;
+        this.keepAlive = keepAlive;
+        this.manager = manager;
+    }
+
+    /// <inheritdoc/>
+    public IntPtr ImGuiHandle => this.manager.GetInfo(this.path).Wrap!.ImGuiHandle;
+
+    /// <inheritdoc/>
+    public int Width => this.width ??= this.manager.GetInfo(this.path).Wrap!.Width;
+
+    /// <inheritdoc/>
+    public int Height => this.height ??= this.manager.GetInfo(this.path).Wrap!.Height;
+
+    /// <summary>
+    /// Gets a value indicating whether or not this wrap has already been disposed.
+    /// If true, the handle may be invalid.
+    /// </summary>
+    internal bool IsDisposed { get; private set; }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        lock (this)
+        {
+            if (!this.IsDisposed)
+                this.manager.NotifyTextureDisposed(this.path, this.keepAlive);
+        
+            this.IsDisposed = true;   
+        }
+    }
+}

Dalamud/Interface/Internal/Windows/Data/Widgets/TexWidget.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Numerics;
 
 using Dalamud.Data;
+using Dalamud.Plugin.Services;
 using Dalamud.Utility;
 using ImGuiNET;
 using ImGuiScene;
@@ -14,13 +16,18 @@ namespace Dalamud.Interface.Internal.Windows.Data;
 /// </summary>
 internal class TexWidget : IDataWindowWidget
 {
+    private readonly List<TextureWrap> addedTextures = new();
+    
+    private string iconId = "18";
+    private bool hiRes = true;
+    private bool hq = false;
+    private bool keepAlive = false;
     private string inputTexPath = string.Empty;
-    private TextureWrap? debugTex;
     private Vector2 inputTexUv0 = Vector2.Zero;
     private Vector2 inputTexUv1 = Vector2.One;
     private Vector4 inputTintCol = Vector4.One;
     private Vector2 inputTexScale = Vector2.Zero;
-    
+
     /// <inheritdoc/>
     public DataKind DataKind { get; init; } = DataKind.Tex;
 
@@ -36,34 +43,75 @@ internal class TexWidget : IDataWindowWidget
     /// <inheritdoc/>
     public void Draw()
     {
-        var dataManager = Service<DataManager>.Get();
+        var texManager = Service<TextureManager>.Get();
 
-        ImGui.InputText("Tex Path", ref this.inputTexPath, 255);
-        ImGui.InputFloat2("UV0", ref this.inputTexUv0);
-        ImGui.InputFloat2("UV1", ref this.inputTexUv1);
-        ImGui.InputFloat4("Tint", ref this.inputTintCol);
-        ImGui.InputFloat2("Scale", ref this.inputTexScale);
-
-        if (ImGui.Button("Load Tex"))
+        ImGui.InputText("Icon ID", ref this.iconId, 32);
+        ImGui.Checkbox("HQ Item", ref this.hq);
+        ImGui.Checkbox("Hi-Res", ref this.hiRes);
+        ImGui.Checkbox("Keep alive", ref this.keepAlive);
+        if (ImGui.Button("Load Icon"))
         {
             try
             {
-                this.debugTex = dataManager.GetImGuiTexture(this.inputTexPath);
-                this.inputTexScale = new Vector2(this.debugTex?.Width ?? 0, this.debugTex?.Height ?? 0);
+                var flags = ITextureProvider.IconFlags.None;
+                if (this.hq)
+                    flags |= ITextureProvider.IconFlags.ItemHighQuality;
+
+                if (this.hiRes)
+                    flags |= ITextureProvider.IconFlags.HiRes;
+                
+                this.addedTextures.Add(texManager.GetIcon(uint.Parse(this.iconId), flags, keepAlive: this.keepAlive));
             }
             catch (Exception ex)
             {
                 Log.Error(ex, "Could not load tex");
             }
         }
+        
+        ImGui.Separator();
+        ImGui.InputText("Tex Path", ref this.inputTexPath, 255);
+        if (ImGui.Button("Load Tex"))
+        {
+            try
+            {
+                this.addedTextures.Add(texManager.GetTextureFromGamePath(this.inputTexPath, this.keepAlive));
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Could not load tex");
+            }
+        }
+        
+        ImGui.Separator();
+        ImGui.InputFloat2("UV0", ref this.inputTexUv0);
+        ImGui.InputFloat2("UV1", ref this.inputTexUv1);
+        ImGui.InputFloat4("Tint", ref this.inputTintCol);
+        ImGui.InputFloat2("Scale", ref this.inputTexScale);
 
         ImGuiHelpers.ScaledDummy(10);
 
-        if (this.debugTex != null)
+        TextureWrap? toRemove = null;
+        for (var i = 0; i < this.addedTextures.Count; i++)
         {
-            ImGui.Image(this.debugTex.ImGuiHandle, this.inputTexScale, this.inputTexUv0, this.inputTexUv1, this.inputTintCol);
-            ImGuiHelpers.ScaledDummy(5);
-            Util.ShowObject(this.debugTex);
+            if (ImGui.CollapsingHeader($"Tex #{i}"))
+            {
+                var tex = this.addedTextures[i];
+
+                var scale = new Vector2(tex.Width, tex.Height);
+                if (this.inputTexScale != Vector2.Zero)
+                    scale = this.inputTexScale;
+                    
+                ImGui.Image(tex.ImGuiHandle, scale, this.inputTexUv0, this.inputTexUv1, this.inputTintCol);
+
+                if (ImGui.Button($"X##{i}"))
+                    toRemove = tex;
+            }
+        }
+
+        if (toRemove != null)
+        {
+            toRemove.Dispose();
+            this.addedTextures.Remove(toRemove);
         }
     }
 }

Dalamud/Plugin/Services/IDataManager.cs

@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System;
+using System.Collections.ObjectModel;
 
 using ImGuiScene;
 using Lumina;
@@ -91,6 +92,7 @@ public interface IDataManager
     /// <param name="iconId">The icon ID.</param>
     /// <param name="highResolution">Return high resolution version.</param>
     /// <returns>The <see cref="TexFile"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TexFile? GetIcon(uint iconId, bool highResolution = false);
 
     /// <summary>
@@ -100,6 +102,7 @@ public interface IDataManager
     /// <param name="iconId">The icon ID.</param>
     /// <param name="highResolution">Return high resolution version.</param>
     /// <returns>The <see cref="TexFile"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TexFile? GetIcon(ClientLanguage iconLanguage, uint iconId, bool highResolution = false);
 
     /// <summary>
@@ -109,6 +112,7 @@ public interface IDataManager
     /// <param name="iconId">The icon ID.</param>
     /// <param name="highResolution">Return high resolution version.</param>
     /// <returns>The <see cref="TexFile"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TexFile? GetIcon(string? type, uint iconId, bool highResolution = false);
     
     /// <summary>
@@ -117,6 +121,7 @@ public interface IDataManager
     /// <param name="iconId">The icon ID.</param>
     /// <param name="highResolution">Return the high resolution version.</param>
     /// <returns>The <see cref="TextureWrap"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTextureIcon(uint iconId, bool highResolution = false);
 
     /// <summary>
@@ -125,6 +130,7 @@ public interface IDataManager
     /// <param name="isHq">A value indicating whether the icon should be HQ.</param>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TexFile"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TexFile? GetIcon(bool isHq, uint iconId);
     
     /// <summary>
@@ -132,6 +138,7 @@ public interface IDataManager
     /// </summary>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TexFile"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TexFile? GetHqIcon(uint iconId);
 
     /// <summary>
@@ -139,6 +146,7 @@ public interface IDataManager
     /// </summary>
     /// <param name="tex">The Lumina <see cref="TexFile"/>.</param>
     /// <returns>A <see cref="TextureWrap"/> that can be used to draw the texture.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTexture(TexFile? tex);
 
     /// <summary>
@@ -146,6 +154,7 @@ public interface IDataManager
     /// </summary>
     /// <param name="path">The internal path to the texture.</param>
     /// <returns>A <see cref="TextureWrap"/> that can be used to draw the texture.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTexture(string path);
 
     /// <summary>
@@ -154,6 +163,7 @@ public interface IDataManager
     /// <param name="isHq">A value indicating whether the icon should be HQ.</param>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TextureWrap"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTextureIcon(bool isHq, uint iconId);
 
     /// <summary>
@@ -162,6 +172,7 @@ public interface IDataManager
     /// <param name="iconLanguage">The requested language.</param>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TextureWrap"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTextureIcon(ClientLanguage iconLanguage, uint iconId);
 
     /// <summary>
@@ -170,6 +181,7 @@ public interface IDataManager
     /// <param name="type">The type of the icon (e.g. 'hq' to get the HQ variant of an item icon).</param>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TextureWrap"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTextureIcon(string type, uint iconId);
 
     /// <summary>
@@ -177,5 +189,6 @@ public interface IDataManager
     /// </summary>
     /// <param name="iconId">The icon ID.</param>
     /// <returns>The <see cref="TextureWrap"/> containing the icon.</returns>
+    [Obsolete("Use ITextureManager instead")]
     public TextureWrap? GetImGuiTextureHqIcon(uint iconId);
 }

Dalamud/Plugin/Services/ITextureProvider.cs

@@ -0,0 +1,69 @@
+using System;
+
+using Dalamud.Interface.Internal;
+using Lumina.Data.Files;
+
+namespace Dalamud.Plugin.Services;
+
+/// <summary>
+/// Service that grants you access to textures you may render via ImGui.
+/// </summary>
+public interface ITextureProvider
+{
+    /// <summary>
+    /// Flags describing the icon you wish to receive.
+    /// </summary>
+    [Flags]
+    public enum IconFlags
+    {
+        /// <summary>
+        /// Low-resolution, standard quality icon.
+        /// </summary>
+        None = 0,
+        
+        /// <summary>
+        /// If this icon is an item icon, and it has a high-quality variant, receive the high-quality version.
+        /// Null if the item does not have a high-quality variant.
+        /// </summary>
+        ItemHighQuality = 1 << 0,
+        
+        /// <summary>
+        /// Get the hi-resolution version of the icon, if it exists.
+        /// </summary>
+        HiRes = 1 << 1,
+    }
+    
+    /// <summary>
+    /// Get a texture handle for a specific icon.
+    /// </summary>
+    /// <param name="iconId">The ID of the icon to load.</param>
+    /// <param name="flags">Options to be considered when loading the icon.</param>
+    /// <param name="language">
+    /// The language to be considered when loading the icon, if the icon has versions for multiple languages.
+    /// If null, default to the game's current language.
+    /// </param>
+    /// <param name="keepAlive">
+    /// Prevent Dalamud from automatically unloading this icon to save memory. Usually does not need to be set.
+    /// </param>
+    /// <returns>
+    /// Null, if the icon does not exist in the specified configuration, or a texture wrap that can be used
+    /// to render the icon.
+    /// </returns>
+    public IDalamudTextureWrap? GetIcon(uint iconId, IconFlags flags = IconFlags.HiRes, ClientLanguage? language = null, bool keepAlive = false);
+
+    /// <summary>
+    /// Get a texture handle for the texture at the specified path.
+    /// You may only specify paths in the game's VFS.
+    /// </summary>
+    /// <param name="path">The path to the texture in the game's VFS.</param>
+    /// <param name="keepAlive">Prevent Dalamud from automatically unloading this texture to save memory. Usually does not need to be set.</param>
+    /// <returns>Null, if the icon does not exist, or a texture wrap that can be used to render the texture.</returns>
+    public IDalamudTextureWrap? GetTextureFromGamePath(string path, bool keepAlive = false);
+    
+    /// <summary>
+    /// Get a texture handle for the specified Lumina TexFile.
+    /// </summary>
+    /// <param name="file">The texture to obtain a handle to.</param>
+    /// <returns>A texture wrap that can be used to render the texture.</returns>
+    public IDalamudTextureWrap GetTexture(TexFile file);
+}

Dalamud/Plugin/Services/ITextureSubstitutionProvider.cs

@@ -0,0 +1,21 @@
+namespace Dalamud.Plugin.Services;
+
+/// <summary>
+/// Service that grants you the ability to replace texture data that is to be loaded by Dalamud.
+/// </summary>
+public interface ITextureSubstitutionProvider
+{
+    /// <summary>
+    /// Delegate describing a function that may be used to intercept and replace texture data.
+    /// </summary>
+    /// <param name="path">The path to the texture that is to be loaded.</param>
+    /// <param name="data">The texture data. Null by default, assign something if you wish to replace the data from the game dats.</param>
+    public delegate void TextureDataInterceptorDelegate(string path, ref byte[]? data);
+    
+    /// <summary>
+    /// Event that will be called once Dalamud wants to load texture data.
+    /// If you have data that should replace the data from the game dats, assign it to the
+    /// data argument.
+    /// </summary>
+    public event TextureDataInterceptorDelegate? InterceptTexDataLoad;
+}