2D Texture Arrays

Client/Client.Commands.cs

@@ -657,6 +657,21 @@ private void Use(ConsoleCommandEventArgs args) =>
     private static void GarbageCollect(ConsoleCommandEventArgs args) =>
         GCUtil.ForceGarbageCollection();
 
+    [ConsoleCommand("drawcounts", "Logs the draw counts of the renderer.")]
+    private void DrawCounts(ConsoleCommandEventArgs args)
+    {
+        ref var counts = ref m_window.Renderer.LastDrawCounts;
+        HelionLog.Info($"GeometryStatic:   {counts.GeometryStatic}");
+        HelionLog.Info($"GeometryDynamic:  {counts.GeometryDynamic}");
+        HelionLog.Info($"FloodFillStatic:  {counts.FloodFillStatic}");
+        HelionLog.Info($"FloodFillDynamic: {counts.FloodFillDynamic}");
+        HelionLog.Info($"Skies:            {counts.Skies}");
+        HelionLog.Info($"Sprites:          {counts.Sprites}");
+        HelionLog.Info($"HudElements:      {counts.HudElements}");
+        HelionLog.Info($"Level Total:      {counts.LevelTotal()}");
+        HelionLog.Info($"Total:            {counts.Total()}");
+    }
+
     private void DoUseCommand(ConsoleCommandEventArgs args)
     {
         if (m_layerManager.WorldLayer == null || args.Args.Count == 0)

Client/Client.cs

@@ -38,7 +38,6 @@
 using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
-using System.Threading;
 using System.Threading.Tasks;
 using static Helion.Util.Assertion.Assert;
 

Core/Graphics/Image.cs

@@ -2,6 +2,7 @@
 using Helion.Geometry.Vectors;
 using Helion.Graphics.Palettes;
 using Helion.Resources;
+using Helion.Util.Assertion;
 using Helion.Util.Extensions;
 using SixLabors.ImageSharp.PixelFormats;
 using System;
@@ -30,7 +31,7 @@ public class Image
     public Dimension Dimension;
     public ImageType ImageType;
     public ImageType UploadType;
-    public readonly Vec2I Offset;
+    public Vec2I Offset;
     public readonly ResourceNamespace Namespace;
     public uint[] m_pixels; // Stored as argb with a = high byte, b = low byte
     public readonly byte[] m_indices;
@@ -407,6 +408,24 @@ public void SetPixel(int x, int y, Color color, Palette palette)
         }
     }
 
+    public void CopyPixelsFrom(Image image)
+    {
+        Precondition(!(image.Indices.Length > 0 && Indices.Length == 0), "Image type mismatch");
+
+        var width = Math.Min(image.Dimension.Width, Dimension.Width);
+        var height = Math.Min(image.Dimension.Height, Dimension.Height);
+
+        for (int x = 0; x < width; x++)
+        {
+            for (int y = 0; y < height; y++)
+            {
+                SetPixel(x, y, image.GetPixel(x, y));
+                if (image.ImageType == ImageType.PaletteWithArgb)
+                    SetIndex(x, y, image.GetIndex(x, y));
+            }
+        }
+    }
+
     public void ConvertToGrayscale(bool normalize)
     {
         if (ImageType == ImageType.Palette)

Core/Render/OpenGL/Context/GLInfo.cs

@@ -32,11 +32,18 @@ public static class GLInfo
     public static bool MapPersistentBitSupported = true;
     public static bool MemoryBarrierSupported = true;
     public static bool DebugLabel;
+    public static int MaxArrayLayers;
 
     static GLInfo()
     {
         Renderer = GL.GetString(StringName.Renderer);
         ShadingVersion = GL.GetString(StringName.ShadingLanguageVersion);
         Vendor = GL.GetString(StringName.Vendor);
+        MaxArrayLayers = GetMaxArrayLayers();
+    }
+    public static int GetMaxArrayLayers()
+    {
+        GL.GetInteger(GetPName.MaxArrayTextureLayers, out var maxLayers);
+        return maxLayers;
     }
 }

Core/Render/OpenGL/Renderers/Legacy/Hud/LegacyHudRenderer.cs

@@ -13,6 +13,7 @@
 using Helion.Resources.Definitions.Zdoom;
 using Helion.Util;
 using Helion.Util.Configs;
+using Helion.Util.Profiling.Timers;
 using OpenTK.Graphics.OpenGL;
 using static Helion.Util.Assertion.Assert;
 
@@ -25,12 +26,14 @@ public class LegacyHudRenderer : HudRenderer
     private readonly LegacyHudShader m_program;
     private readonly HudDrawBuffer m_drawBuffer;
     private readonly IConfig m_config;
+    private readonly RenderProfiler m_renderProfiler;
     private float DrawDepth = 1.0f;
 
-    public LegacyHudRenderer(IConfig config, LegacyGLTextureManager textureManager, DataCache dataCache)
+    public LegacyHudRenderer(IConfig config, LegacyGLTextureManager textureManager, DataCache dataCache, RenderProfiler renderProfiler)
     {
         m_config = config;
         m_textureManager = textureManager;
+        m_renderProfiler = renderProfiler;
         m_program = new();
         m_pipeline = new(m_program, new StreamVertexBuffer<HudVertex>("Hud"), "Hud");
         m_drawBuffer = new(dataCache);
@@ -175,9 +178,10 @@ public override void Render(Rectangle viewport, Dimension windowDimension, Dimen
             if (data.BrightmapTexture != null)
                 data.BrightmapTexture.Bind();
             else
-                GL.BindTexture(TextureTarget.Texture2D, 0);
+                GL.BindTexture(data.Texture.Target, 0);
             m_pipeline.DrawArrays();
             data.Texture.Unbind();
+            m_renderProfiler.DrawCounts.HudElements++;
         }
 
         m_pipeline.Unbind();

Core/Render/OpenGL/Renderers/Legacy/Hud/LegacyHudShader.cs

@@ -112,7 +112,7 @@ private static string GetBrightmapColorBlend()
 
         return @"
             if (useBrightmaps == 1)
-                fragColor.rgb *= mix(vec3(1.0), min(vec3(1.0), texture(brightmapTexture, uvFrag.st).rgb + rgbMultiplierFrag.rgb), rgbMultiplierFrag.w);
+                fragColor.rgb *= mix(vec3(1.0), min(vec3(1.0), texture(brightmapTexture, vec3(uvFrag.st, 0)).rgb + rgbMultiplierFrag.rgb), rgbMultiplierFrag.w);
             else
                 fragColor.xyz *= mix(vec3(1.0), rgbMultiplierFrag.xyz, rgbMultiplierFrag.w);";
     }
@@ -129,9 +129,9 @@ private static string GetBrightmapColorBlend()
 
         out vec4 fragColor;
 
-        uniform sampler2D boundTexture;
+        uniform sampler2DArray boundTexture;
         uniform sampler2D opaqueTexture;
-        uniform sampler2D brightmapTexture;
+        uniform sampler2DArray brightmapTexture;
         uniform samplerBuffer colormapTexture;
         uniform float fuzzFrac;
         uniform float fuzzDiv;
@@ -145,10 +145,12 @@ private static string GetBrightmapColorBlend()
         uniform vec2 fuzzSampleOffset;
         uniform int fuzzRefraction;
 
+        const int boundTextureIndex = 0;
+
         ${FuzzFunction}
 
         void main() {
-            fragColor = texture(boundTexture, uvFrag.st);
+            fragColor = texture(boundTexture, vec3(uvFrag.st, 0));
             ${ColorMapFetch}
             ${AlphaFlag}
             fragColor.w *= alphaFrag;

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderData.cs

@@ -45,24 +45,25 @@ public void Clear()
         Pipeline.Clear();
     }
 
-    public void Draw()
+    public bool Draw()
     {
         if (Pipeline.Empty)
-            return;
+            return false;
 
         GL.ActiveTexture(BindTextures.BoundTexture);
         Texture.Bind();
         GL.ActiveTexture(BindTextures.BrightmapTexture);
         if (BrightMapTexture != null)
             BrightMapTexture.Bind();
         else
-            GL.BindTexture(TextureTarget.Texture2D, 0);
+            GL.BindTexture(Texture.Target, 0);
 
         Pipeline.Bind(true);
         Pipeline.Vbo.Upload();
         Pipeline.Vbo.DrawArraysInstanced(PrimitiveType.TriangleStrip, 0, 4);
 
         Texture.Unbind();
+        return true;
     }
 
     protected virtual void Dispose(bool disposing)

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderDataCollection.cs

@@ -18,13 +18,15 @@ public class RenderDataCollection<[DynamicallyAccessedMembers(DynamicallyAccesse
     private readonly DynamicArray<RenderData<TVertex>> m_dataToRender = new(2048);
     private readonly RenderProgram m_program;
     private readonly RenderDataPool<TVertex> m_renderDataPool;
+    private readonly Action? m_onDraw;
     private int m_renderCount;
     private bool m_disposed;
 
-    public RenderDataCollection(RenderProgram program, RenderDataPool<TVertex> renderDataPool)
+    public RenderDataCollection(RenderProgram program, RenderDataPool<TVertex> renderDataPool, Action? onDraw = null)
     {
         m_program = program;
         m_renderDataPool = renderDataPool;
+        m_onDraw = onDraw;
     }
 
     ~RenderDataCollection()
@@ -72,7 +74,10 @@ public void Render()
             return;
 
         for (int i = 0; i < m_dataToRender.Length; i++)
-            m_dataToRender[i].Draw();
+        {
+            if (m_dataToRender[i].Draw())
+                m_onDraw?.Invoke();
+        }
     }
 
     protected virtual void Dispose(bool disposing)

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderDataManager.cs

@@ -23,16 +23,18 @@ public class RenderDataManager<[DynamicallyAccessedMembers(DynamicallyAccessedMe
 
     private readonly RenderDataCollection<TVertex>[] m_renderDataStyles;
     private readonly RenderData<TVertex> m_healthBarData;
+    private readonly Action? m_onDraw;
     private bool m_disposed;
 
-    public RenderDataManager(RenderProgram program, GLLegacyTexture healthBarTexture, RenderDataPool<TVertex> renderDataPool)
+    public RenderDataManager(RenderProgram program, GLLegacyTexture healthBarTexture, RenderDataPool<TVertex> renderDataPool, Action? onDraw = null)
     {
         Assert.Precondition(RenderStyleLookup.Length == (int)RenderStyle.Count, "Render style lookup size mismatch");
         m_renderDataStyles = new RenderDataCollection<TVertex>[(int)RenderDataStyle.Count];
         for (int i = 0; i < m_renderDataStyles.Length; i++)
-            m_renderDataStyles[i] = new(program, renderDataPool);
+            m_renderDataStyles[i] = new(program, renderDataPool, onDraw);
 
         m_healthBarData = new(program, healthBarTexture);
+        m_onDraw = onDraw;
     }
 
     ~RenderDataManager()

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderWorldData.cs

@@ -42,10 +42,10 @@ public void Clear()
         Pipeline.Clear();
     }
 
-    public void Draw()
+    public bool Draw()
     {
         if (Pipeline.Empty)
-            return;
+            return false;
 
         // We are doing binding manually since apparently these are all
         // coming up in the memory profiler as a bunch of new 'actions'.
@@ -57,13 +57,14 @@ public void Draw()
         if (BrightmapTexture != null)
             BrightmapTexture.Bind();
         else
-            GL.BindTexture(TextureTarget.Texture2D, 0);
+            GL.BindTexture(Texture.Target, 0);
 
         Pipeline.Bind(true);
         Pipeline.Vbo.Upload();
         Pipeline.DrawArrays();
         Pipeline.Unbind();
         Texture.Unbind();
+        return true;
     }
 
     public void Dispose()

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderWorldDataList.cs

@@ -1,17 +1,17 @@
-using Helion.Render.OpenGL.Shader;
-using Helion.Render.OpenGL.Texture.Legacy;
+using Helion.Render.OpenGL.Texture.Legacy;
 using Helion.Util.Container;
 using System;
 using System.Collections.Generic;
 
 namespace Helion.Render.OpenGL.Renderers.Legacy.World.Data;
 
-public class RenderWorldDataList(RenderWorldDataPool pool)
+public class RenderWorldDataList(RenderWorldDataPool pool, Action? onDraw)
 {
     public List<RenderWorldData> RenderData = [];
     private RenderWorldData?[] m_allRenderData = new RenderWorldData?[1024];
     private readonly DynamicArray<RenderWorldData> m_dataToRender = new(1024);
     private readonly RenderWorldDataPool m_pool = pool;
+    private readonly Action? m_onDraw = onDraw;
     private int m_renderCount;
 
     public void Reset()
@@ -60,7 +60,10 @@ public RenderWorldData Add(GLLegacyTexture texture, GLLegacyTexture? brightmapTe
     public void Draw()
     {
         for (int i = 0; i < m_dataToRender.Length; i++)
-            m_dataToRender[i].Draw();
+        {
+            if (m_dataToRender[i].Draw())
+                m_onDraw?.Invoke();
+        }
     }
 
     public void Clear()

Core/Render/OpenGL/Renderers/Legacy/World/Data/RenderWorldDataManager.cs

@@ -12,19 +12,21 @@ public sealed class RenderWorldDataManager : StyleRendererBase, IDisposable
 {
     private readonly RenderWorldDataPool m_pool;
     private readonly GeometryTypeLookup<RenderWorldDataList> m_lookup;
+    private readonly Action? m_onDraw;
     private RenderWorldData? m_coverWalls;
 
     public bool BufferCoverWalls = true;
 
-    public RenderWorldDataManager(RenderProgram program)
+    public RenderWorldDataManager(RenderProgram program, Action? onDraw)
     {
         m_pool = new(program, 1024);
+        m_onDraw = onDraw;
         m_lookup = new(AllocateDataList);
     }
 
     private RenderWorldDataList AllocateDataList()
     {
-        return new RenderWorldDataList(m_pool);
+        return new RenderWorldDataList(m_pool, m_onDraw);
     }
 
     public void Reset()