Global texture tracking and reference counting

This is a preliminary step to putting all the textures in a big array on the GPU so they don't have to be bound repeatedly during rendering. That should improve performance, and it should also make it easier to implement draw indirect earlier.

Author: Moneyl

Nanoforge/Gui/ViewModels/Documents/ChunkViewer/ChunkViewerDocumentViewModel.cs

@@ -18,6 +18,7 @@
 using Nanoforge.Render.Resources;
 using Nanoforge.Rfg;
 using RFGM.Formats.Materials;
+using RFGM.Formats.Math;
 using RFGM.Formats.Meshes;
 using RFGM.Formats.Meshes.Chunks;
 using RFGM.Formats.Meshes.Shared;
@@ -339,6 +340,11 @@ private RenderChunk CreateRenderChunkFromDestroyable(RenderContext context, Mesh
     {
         try
         {
+            if (TextureManager.GetTexture(tgaName) is { } cachedTexture)
+            {
+                return cachedTexture;
+            }
+            
             if (chunkFileEntry.Parent is not DirectoryEntry parent)
             {
                 Log.Error($"Passed chunk file entry with no parent directory into TryLoadTextureFromTgaName(). This should never happen. Chunks should always be in a vpp_pc or str2_pc.");
@@ -379,6 +385,7 @@ private RenderChunk CreateRenderChunkFromDestroyable(RenderContext context, Mesh
                 texture.SetPixels(pixels, pool, queue);
                 texture.CreateTextureSampler();
                 texture.CreateImageView();
+                TextureManager.NewTexture(tgaName, texture);
 
                 return texture;
             }

Nanoforge/Gui/ViewModels/Documents/RendererTestDocumentViewModel.cs

@@ -210,6 +210,12 @@ private Texture2D LoadTextureFromPackfile(RenderContext context, string cpuFileP
         List<LogicalTexture> textures = result.LogicalTextures.ToList();
         LogicalTexture logicalTexture = textures[logicalTextureIndex];
 
+        string tgaName = logicalTexture.Name;
+        if (TextureManager.GetTexture(tgaName) is { } cachedTexture)
+        {
+            return cachedTexture;
+        }
+
         using var memoryStream = new MemoryStream();
         logicalTexture.Data.CopyTo(memoryStream);
         byte[] pixels = memoryStream.ToArray();
@@ -233,6 +239,7 @@ private Texture2D LoadTextureFromPackfile(RenderContext context, string cpuFileP
         texture.SetPixels(pixels, context.TransferCommandPool, context.TransferQueue);
         texture.CreateTextureSampler();
         texture.CreateImageView();
+        TextureManager.NewTexture(tgaName, texture);
 
         return texture;
     }

Nanoforge/Render/Renderer.cs

@@ -118,6 +118,11 @@ public void Cleanup()
             scene.Destroy();
         }
 
+        if (TextureManager.Textures.Count > 0)
+        {
+            Log.Warning($"There are {TextureManager.Textures.Count} textures that haven't been destroyed.");
+        }
+        
         if (_perFrameUniformBuffers != null)
         {
             foreach (VkBuffer buffer in _perFrameUniformBuffers)

Nanoforge/Render/Resources/RenderChunk.cs

@@ -125,10 +125,7 @@ public override void Destroy()
         {
             foreach (Texture2D texture in textures)
             {
-                if (texture != Texture2D.DefaultTexture && texture != Texture2D.MissingTexture && texture != Texture2D.FlatNormalMap)
-                {
-                    texture.Destroy();
-                }
+                TextureManager.RemoveReference(texture);
             }
         }
     }

Nanoforge/Render/Resources/SimpleRenderObject.cs

@@ -81,11 +81,7 @@ public override void Destroy()
         Mesh.Destroy();
         foreach (Texture2D texture in Textures)
         {
-            //TODO: Add reference counting system for renderer resources to avoid needing checks like this
-            if (texture != Texture2D.DefaultTexture && texture != Texture2D.MissingTexture && texture != Texture2D.FlatNormalMap)
-            {
-                texture.Destroy();
-            }
+            TextureManager.RemoveReference(texture);
         }
     }
 }

Nanoforge/Render/Scene.cs

@@ -235,6 +235,7 @@ public void Destroy()
 
         PrimitiveRenderer.Destroy();
         CleanupRenderTextures();
+        TextureManager.DestroyUnusedTextures();
         Destroyed = true;
     }
 }

Nanoforge/Render/TextureManager.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Nanoforge.Render.Resources;
+
+namespace Nanoforge.Render;
+
+//Tracks all textures used by the renderer and their reference count
+public static class TextureManager
+{
+    public class TextureMetadata
+    {
+        public string Name;
+        public readonly Texture2D Texture;
+        public int ReferenceCount;
+
+        public TextureMetadata(string name, Texture2D texture)
+        {
+            Name = name;
+            Texture = texture;
+            ReferenceCount = 0;
+        }
+    }
+
+    public static List<TextureMetadata> Textures = new();
+
+    public static bool IsTextureLoaded(string textureName)
+    {
+        return Textures.Any(t => t.Name == textureName);
+    }
+
+    public static void NewTexture(string textureName, Texture2D texture)
+    {
+        var metadata = new TextureMetadata(textureName, texture)
+        {
+            ReferenceCount = 1,
+        };
+        Textures.Add(metadata);
+    }
+
+    public static Texture2D? GetTexture(string textureName)
+    {
+        TextureMetadata? metadata = Textures.FirstOrDefault(t => t.Name == textureName);
+        if (metadata != null)
+        {
+            metadata.ReferenceCount++;
+        }
+        
+        return metadata?.Texture;
+    }
+
+    public static void RemoveReference(Texture2D texture)
+    {
+        TextureMetadata? metadata = Textures.FirstOrDefault(t => t.Texture == texture);
+        if (metadata == null) 
+            return;
+        
+        metadata.ReferenceCount = Math.Clamp(--metadata.ReferenceCount, 0, int.MaxValue);
+        if (metadata.ReferenceCount == 0)
+        {
+            metadata.Texture.Destroy();
+            Textures.Remove(metadata);
+        }
+    }
+
+    public static void DestroyUnusedTextures()
+    {
+        foreach (TextureMetadata metadata in Textures.Where(metadata => metadata.ReferenceCount == 0).ToArray())
+        {
+            Textures.Remove(metadata);
+            metadata.Texture.Destroy();
+        }
+    }
+}

Nanoforge/Rfg/ProjectTexture.cs

@@ -57,6 +57,10 @@ public static Silk.NET.Vulkan.Format PegFormatToVulkanFormat(RfgCpeg.Entry.Bitma
     {
         if (Data == null)
             return null;
+        if (TextureManager.GetTexture(Name) is { } cachedTexture)
+        {
+            return cachedTexture;
+        }
 
         byte[] pixels = Data.Load();
         Texture2D texture = new(renderer.Context, (uint)Width, (uint)Height, (uint)NumMipLevels, Format, ImageTiling.Optimal,
@@ -66,6 +70,7 @@ public static Silk.NET.Vulkan.Format PegFormatToVulkanFormat(RfgCpeg.Entry.Bitma
         texture.SetPixels(pixels, pool, queue);
         texture.CreateTextureSampler();
         texture.CreateImageView();
+        TextureManager.NewTexture(Name, texture);
 
         return texture;
     }

Nanoforge/Rfg/Territory.cs

@@ -37,14 +37,13 @@ public bool Load(Renderer renderer, Scene scene)
             //TODO: Maybe make a wrapper class for command pools / command buffers that knows which pool and queue it belongs to so less params need to get passed around.
             //TODO: Maybe even have a separate "ThreadRenderContext" that gets passed around
             Dictionary<ProjectMesh, Mesh> meshCache = new();
-            Dictionary<ProjectTexture, Texture2D> textureCache = new();
 
             //Load low lod terrain meshes
             foreach (Zone zone in Zones)
             {
                 ZoneTerrain terrain = zone.Terrain ?? throw new Exception("Zone.Terrain is null");
                 List<Texture2D> lowLodTextures = new List<Texture2D>();
-                Texture2D? combTexture = LoadTexture(terrain.CombTexture, textureCache, renderer, scene);
+                Texture2D? combTexture = LoadTexture(terrain.CombTexture, renderer, scene);
                 if (combTexture != null)
                 {
                     lowLodTextures.Add(combTexture);
@@ -55,7 +54,7 @@ public bool Load(Renderer renderer, Scene scene)
                     Log.Warning("Failed to load comb texture for {}. Terrain may look wrong.", Name);
                 }
 
-                Texture2D? ovlTexture = LoadTexture(terrain.OvlTexture, textureCache, renderer, scene);
+                Texture2D? ovlTexture = LoadTexture(terrain.OvlTexture, renderer, scene);
                 if (ovlTexture != null)
                 {
                     lowLodTextures.Add(ovlTexture);
@@ -66,7 +65,7 @@ public bool Load(Renderer renderer, Scene scene)
                     Log.Warning("Failed to load ovl texture for {}. Terrain may look wrong.", Name);
                 }
 
-                Texture2D? splatmap = LoadTexture(terrain.Splatmap, textureCache, renderer, scene);
+                Texture2D? splatmap = LoadTexture(terrain.Splatmap, renderer, scene);
                 if (splatmap != null)
                 {
                     lowLodTextures.Add(splatmap);
@@ -101,7 +100,7 @@ public bool Load(Renderer renderer, Scene scene)
                     for (int textureIndex = 2; textureIndex < 10; textureIndex++)
                     {
                         ProjectTexture? projectTexture = terrain.SplatmapTextures[textureIndex - 2];
-                        Texture2D? texture = LoadTexture(projectTexture, textureCache, renderer, scene);
+                        Texture2D? texture = LoadTexture(projectTexture, renderer, scene);
                         if (texture != null)
                         {
                             subzoneTextures[textureIndex] = texture;
@@ -147,7 +146,7 @@ public bool Load(Renderer renderer, Scene scene)
 
             foreach (Rock rock in Rocks)
             {
-                Texture2D? diffuse = LoadTexture(rock.DiffuseTexture, textureCache, renderer, scene);
+                Texture2D? diffuse = LoadTexture(rock.DiffuseTexture, renderer, scene);
                 if (diffuse is null)
                 {
                     diffuse = Texture2D.MissingTexture;
@@ -182,7 +181,7 @@ public bool Load(Renderer renderer, Scene scene)
                 {
                     //RenderChunk only works with chunks with destroyables currently. So in this case we render the chunk as a normal mesh
                     Log.Warning($"Mover ({mover.UID}, {mover.Handle}, {mover.Num}) has a chunk no destroyables ({mover.ChunkData.Name}). Rendering as simple render object.");
-                    LoadChunkAsSimpleMesh(mover, mover.ChunkData, renderer, scene, meshCache, textureCache);
+                    LoadChunkAsSimpleMesh(mover, mover.ChunkData, renderer, scene, meshCache);
                     continue;                    
                 }
                 Chunk? chunk = mover.ChunkData;
@@ -222,7 +221,7 @@ public bool Load(Renderer renderer, Scene scene)
                         var texture = projectTextures[textureIndex];
                         if (texture is not null)
                         {
-                            renderTexture = LoadTexture(texture, textureCache, renderer, scene);
+                            renderTexture = LoadTexture(texture, renderer, scene);
                         }
 
                         renderTexture ??= textureIndex switch
@@ -249,7 +248,7 @@ public bool Load(Renderer renderer, Scene scene)
         }
     }
 
-    private void LoadChunkAsSimpleMesh(ObjectMover mover, Chunk chunk, Renderer renderer, Scene scene, Dictionary<ProjectMesh, Mesh> meshCache, Dictionary<ProjectTexture, Texture2D> textureCache)
+    private void LoadChunkAsSimpleMesh(ObjectMover mover, Chunk chunk, Renderer renderer, Scene scene, Dictionary<ProjectMesh, Mesh> meshCache)
     {
         RfgMaterial material = chunk.Materials[0];
         List<ProjectTexture?> projectTextures = chunk.Textures[0];
@@ -262,7 +261,7 @@ private void LoadChunkAsSimpleMesh(ObjectMover mover, Chunk chunk, Renderer rend
             Texture2D? renderTexture = null;
             if (texture is not null)
             {
-                renderTexture = LoadTexture(texture, textureCache, renderer, scene);
+                renderTexture = LoadTexture(texture, renderer, scene);
             }
 
             renderTexture ??= textureIndex switch
@@ -284,14 +283,12 @@ private void LoadChunkAsSimpleMesh(ObjectMover mover, Chunk chunk, Renderer rend
         scene.CreateRenderObject(chunk.Mesh!.VertexFormat.ToString(), mover.Position, mover.Orient, mesh, renderTextures);
     }
 
-    private Texture2D? LoadTexture(ProjectTexture? projectTexture, Dictionary<ProjectTexture, Texture2D> textureCache, Renderer renderer, Scene scene)
+    private Texture2D? LoadTexture(ProjectTexture? projectTexture, Renderer renderer, Scene scene)
     {
         try
         {
             if (projectTexture == null)
                 return null;
-            if (textureCache.ContainsKey(projectTexture))
-                return textureCache[projectTexture];
 
             Texture2D? texture = projectTexture.CreateRenderTexture(renderer, renderer.Context.TransferCommandPool, renderer.Context.TransferQueue);
             if (texture == null)
@@ -300,7 +297,6 @@ private void LoadChunkAsSimpleMesh(ObjectMover mover, Chunk chunk, Renderer rend
                 return null;
             }
 
-            textureCache[projectTexture] = texture;
             return texture;
         }
         catch (Exception ex)