Implement custom SpriteBatch replacement for batching terrain tiles

Author: Rampastring

src/TSMapEditor/Constants.cs

@@ -4,7 +4,7 @@ namespace TSMapEditor
 {
     public static class Constants
     {
-        public const string ReleaseVersion = "1.6.0";
+        public const string ReleaseVersion = "1.6.1";
 
         public static int CellSizeX = 48;
         public static int CellSizeY = 24;

src/TSMapEditor/Content/Shaders/PalettedTerrainDraw.fx

@@ -34,13 +34,34 @@ SamplerState PaletteSampler
     MagFilter = Point;
 };
 
+// Vertex shader input
+struct VertexShaderInput
+{
+    float3 Position : POSITION;
+    float4 Color : COLOR0;
+    float2 TextureCoordinates : TEXCOORD0;
+};
+
+matrix WorldViewProj : register(c0);
+
 struct VertexShaderOutput
 {
     float4 Position : SV_POSITION;
     float4 Color : COLOR0;
     float2 TextureCoordinates : TEXCOORD0;
 };
 
+
+VertexShaderOutput MainVS(VertexShaderInput input)
+{
+    VertexShaderOutput output;
+    output.Position = mul(float4(input.Position, 1.0), WorldViewProj);
+    output.Color = input.Color;
+    output.TextureCoordinates = input.TextureCoordinates;
+    return output;
+}
+
+
 struct PixelShaderOutput
 {
     float4 color : SV_Target0;
@@ -92,6 +113,7 @@ technique SpriteDrawing
 {
     pass P0
     {
+        VertexShader = compile VS_SHADERMODEL MainVS();
         PixelShader = compile PS_SHADERMODEL MainPS();
     }
 };

src/TSMapEditor/Rendering/Batching/RenderingConstants.cs

@@ -0,0 +1,10 @@
+namespace TSMapEditor.Rendering.Batching
+{
+    class RenderingConstants
+    {
+        public const int MaxVertices = 65535;
+        public const int VerticesPerQuad = 4;
+        public const int IndexesPerQuad = 6;
+        public const int TrianglesPerQuad = 2;
+    }
+}

src/TSMapEditor/Rendering/Batching/TerrainBatcher.cs

@@ -0,0 +1,158 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+
+namespace TSMapEditor.Rendering.Batching
+{
+    /// <summary>
+    /// Custom SpriteBatch replacement for more efficient rendering of terrain tiles.
+    /// </summary>
+    public class TerrainBatcher
+    {
+        private GraphicsDevice _graphicsDevice;
+        private Effect _effect;
+
+        /// <summary>
+        /// Pool for created batches.
+        /// Pooling these means that these big objects don't need to be reconstructed each time a batch is drawn.
+        /// </summary>
+        private Queue<TextureBatch<VertexPositionColorTexture>> inactiveBatches = new Queue<TextureBatch<VertexPositionColorTexture>>();
+
+        /// <summary>
+        /// Batches that are currently queued for drawing.
+        /// </summary>
+        private List<TextureBatch<VertexPositionColorTexture>> queuedBatches = new List<TextureBatch<VertexPositionColorTexture>>();
+
+        private EffectParameter mainTextureParameter;
+        private EffectParameter worldViewProjParameter;
+        private DepthStencilState depthStencilState;
+
+        private bool beginCalled = false;
+
+        public TerrainBatcher(GraphicsDevice graphicsDevice, Effect effect, DepthStencilState depthStencilState)
+        {
+            _graphicsDevice = graphicsDevice;
+            _effect = effect;
+            this.depthStencilState = depthStencilState;
+
+            mainTextureParameter = _effect.Parameters["MainTexture"];
+            worldViewProjParameter = _effect.Parameters["WorldViewProj"];
+        }
+
+        public void Begin()
+        {
+            if (beginCalled)
+                throw new InvalidOperationException("End needs to be called between two successive calls to Begin.");
+
+            beginCalled = true;
+        }
+
+        public void Draw(Texture2D texture, Rectangle destinationRect, Rectangle? sourceRect, Color color, float depth)
+        {
+            Rectangle src = sourceRect ?? new Rectangle(0, 0, texture.Width, texture.Height);
+
+            float u1 = (float)src.X / texture.Width;
+            float v1 = (float)src.Y / texture.Height;
+            float u2 = (float)(src.X + src.Width) / texture.Width;
+            float v2 = (float)(src.Y + src.Height) / texture.Height;
+
+            float x = destinationRect.X;
+            float y = destinationRect.Y;
+            float w = destinationRect.Width;
+            float h = destinationRect.Height;
+
+            TextureBatch<VertexPositionColorTexture> batch = null;
+            for (int i = 0; i < queuedBatches.Count; i++)
+            {
+                if (queuedBatches[i].Texture == texture && !queuedBatches[i].IsFull())
+                    batch = queuedBatches[i];
+            }
+
+            if (batch == null)
+            {
+                if (!inactiveBatches.TryDequeue(out batch))
+                {
+                    batch = new TextureBatch<VertexPositionColorTexture>();
+                }
+
+                queuedBatches.Add(batch);
+                batch.Texture = texture;
+            }
+
+            int vertexOffset = batch.QuadCount * RenderingConstants.VerticesPerQuad;
+
+            if (vertexOffset >= batch.Vertices.Length)
+            {
+                batch.ExtendArrays();
+            }
+
+            int indexOffset = batch.QuadCount * RenderingConstants.IndexesPerQuad;
+
+            unsafe
+            {
+                // 4 vertices of the quad
+                fixed (VertexPositionColorTexture* p = &batch.Vertices[vertexOffset])
+                {
+                    p[0] = new VertexPositionColorTexture { Position = new Vector3(x, y, depth), TextureCoordinate = new Vector2(u1, v1), Color = color };
+                    p[1] = new VertexPositionColorTexture { Position = new Vector3(x + w, y, depth), TextureCoordinate = new Vector2(u2, v1), Color = color };
+                    p[2] = new VertexPositionColorTexture { Position = new Vector3(x, y + h, depth), TextureCoordinate = new Vector2(u1, v2), Color = color };
+                    p[3] = new VertexPositionColorTexture { Position = new Vector3(x + w, y + h, depth), TextureCoordinate = new Vector2(u2, v2), Color = color };
+                }
+
+                // 2 triangles (indices)
+                fixed (short* p = &batch.Indexes[indexOffset])
+                {
+                    p[0] = (short)(vertexOffset + 0);
+                    p[1] = (short)(vertexOffset + 1);
+                    p[2] = (short)(vertexOffset + 2);
+
+                    p[3] = (short)(vertexOffset + 2);
+                    p[4] = (short)(vertexOffset + 1);
+                    p[5] = (short)(vertexOffset + 3);
+                }
+            }
+
+            batch.QuadCount++;
+        }
+
+        public void End()
+        {
+            // Build orthographic projection
+            Matrix projection = Matrix.CreateOrthographicOffCenter(
+                0, _graphicsDevice.Viewport.Width,
+                _graphicsDevice.Viewport.Height, 0,
+                0, -1);
+
+            // Upload it to the shader
+            worldViewProjParameter.SetValue(projection);
+
+            for (int i = 0; i < queuedBatches.Count; i++)
+            {
+                var batch = queuedBatches[i];
+                mainTextureParameter.SetValue(batch.Texture);
+
+                foreach (EffectPass pass in _effect.CurrentTechnique.Passes)
+                {
+                    pass.Apply();
+
+                    _graphicsDevice.DrawUserIndexedPrimitives(
+                        PrimitiveType.TriangleList,
+                        batch.Vertices, 0, batch.QuadCount * RenderingConstants.VerticesPerQuad,
+                        batch.Indexes, 0, batch.QuadCount * RenderingConstants.TrianglesPerQuad,
+                        VertexPositionColorTexture.VertexDeclaration
+                    );
+                }
+            }
+
+            for (int i = 0; i < queuedBatches.Count; i++)
+            {
+                queuedBatches[i].Clear();
+                inactiveBatches.Enqueue(queuedBatches[i]);
+            }
+
+            queuedBatches.Clear();
+            beginCalled = false;
+        }
+    }
+}

src/TSMapEditor/Rendering/Batching/TextureBatch.cs

@@ -0,0 +1,37 @@
+using Microsoft.Xna.Framework.Graphics;
+using System;
+
+namespace TSMapEditor.Rendering.Batching
+{
+    class TextureBatch<T> where T : struct, IVertexType
+    {
+        public Texture2D Texture;
+        public T[] Vertices = new T[16];
+        public short[] Indexes = new short[24];
+
+        public int QuadCount;
+
+        public void Clear()
+        {
+            Texture = null;
+            QuadCount = 0;
+        }
+
+        public void ExtendArrays()
+        {
+            if (IsFull())
+                throw new InvalidOperationException("Cannot extend a texture batch that is already full.");
+
+            // Double array sizes
+            var newVertexArray = new T[Math.Min(Vertices.Length * 2, RenderingConstants.MaxVertices)];
+            Array.Copy(Vertices, newVertexArray, Vertices.Length);
+            Vertices = newVertexArray;
+
+            var newIndexArray = new short[Indexes.Length * 2];
+            Array.Copy(Indexes, newIndexArray, Indexes.Length);
+            Indexes = newIndexArray;
+        }
+
+        public bool IsFull() => QuadCount + RenderingConstants.VerticesPerQuad >= RenderingConstants.MaxVertices / RenderingConstants.VerticesPerQuad;
+    }
+}

src/TSMapEditor/Rendering/MapView.cs

@@ -11,6 +11,7 @@
 using TSMapEditor.GameMath;
 using TSMapEditor.Models;
 using TSMapEditor.Models.Enums;
+using TSMapEditor.Rendering.Batching;
 using TSMapEditor.Rendering.ObjectRenderers;
 using TSMapEditor.Settings;
 using TSMapEditor.UI;
@@ -115,6 +116,8 @@ public MapView(WindowManager windowManager, Map map, TheaterGraphics theaterGrap
         private Effect alphaMapDrawEffect;                           // Effect for rendering the alpha light map
         private Effect alphaImageToAlphaMapEffect;                   // Effect for rendering a single alpha image to the alpha light map
 
+        private TerrainBatcher terrainBatcher;
+
         private bool mapInvalidated;
         private bool cameraMoved;
         private bool minimapNeedsRefresh;
@@ -182,6 +185,7 @@ public void Initialize()
 
             RefreshRenderTargets();
             CreateDepthStencilStates();
+            InitBatchers();
 
             Map.LocalSizeChanged += (s, e) => InvalidateMap();
             Map.MapHeightChanged += (s, e) => InvalidateMap();
@@ -336,6 +340,11 @@ private void CreateDepthStencilStates()
             }
         }
 
+        private void InitBatchers()
+        {
+            terrainBatcher = new TerrainBatcher(GraphicsDevice, palettedTerrainDrawEffect, depthRenderStencilState);
+        }
+
         private RenderDependencies CreateRenderDependencies()
         {
             return new RenderDependencies(Map, TheaterGraphics, EditorState, windowManager.GraphicsDevice, objectSpriteRecord, palettedColorDrawEffect, Camera, GetCameraRightXCoord, GetCameraBottomYCoord);
@@ -382,14 +391,17 @@ public void DrawVisibleMapPortion()
             // Draw terrain tiles in batched mode for performance if we can.
             // In Marble Madness mode we currently need to mix and match paletted and non-paletted graphics, so there's no avoiding immediate mode.
             SetTerrainEffectParams(TheaterGraphics.TheaterPalette.GetTexture());
-            var palettedTerrainDrawSettings = new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.Opaque, null, depthRenderStencilState, null, palettedTerrainDrawEffect);
-            Renderer.PushSettings(palettedTerrainDrawSettings);
+
+            terrainBatcher.Begin();
             DoForVisibleCells(DrawTerrainTileAndRegisterObjects);
+            terrainBatcher.End();
 
             // We do not need to write to the depth render target when drawing smudges and flat overlays.
             // Swap to using only the main map render target.
             // At this point of drawing, depth testing is done on depth buffer embedded in the main map render target.
             Renderer.PopRenderTarget();
+
+            var palettedTerrainDrawSettings = new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.Opaque, null, depthRenderStencilState, null, palettedTerrainDrawEffect);
             Renderer.PushRenderTarget(mapRenderTarget, palettedTerrainDrawSettings);
 
             // Smudges can be drawn as part of regular terrain.
@@ -703,15 +715,15 @@ public void DrawTerrainTile(MapTile tile)
 
             if (subTileIndex >= tileImage.TMPImages.Length)
             {
-                Renderer.DrawString(subTileIndex.ToString(), 0, new Vector2(drawPoint.X, drawPoint.Y), Color.Red);
+                // Renderer.DrawString(subTileIndex.ToString(), 0, new Vector2(drawPoint.X, drawPoint.Y), Color.Red);
                 return;
             }
 
             MGTMPImage tmpImage = tileImage.TMPImages[subTileIndex];
 
             if (tmpImage == null || tmpImage.Texture == null)
             {
-                Renderer.DrawString(subTileIndex.ToString(), 0, new Vector2(drawPoint.X, drawPoint.Y), Color.Red);
+                // Renderer.DrawString(subTileIndex.ToString(), 0, new Vector2(drawPoint.X, drawPoint.Y), Color.Red);
                 return;
             }
 
@@ -740,8 +752,9 @@ public void DrawTerrainTile(MapTile tile)
                 }
             }
 
-            Renderer.DrawTexture(textureToDraw, new Rectangle(drawX, drawY,
-                    Constants.CellSizeX, Constants.CellSizeY), sourceRectangle, color, 0f, Vector2.Zero, SpriteEffects.None, depth);
+            terrainBatcher.Draw(textureToDraw, 
+                new Rectangle(drawX, drawY, Constants.CellSizeX, Constants.CellSizeY),
+                sourceRectangle, color, depth);
 
             if (tmpImage.TmpImage.HasExtraData())
             {
@@ -752,12 +765,7 @@ public void DrawTerrainTile(MapTile tile)
                     tmpImage.ExtraSourceRectangle.Width,
                     tmpImage.ExtraSourceRectangle.Height);
 
-                Renderer.DrawTexture(tmpImage.Texture,
-                    exDrawRectangle,
-                    tmpImage.ExtraSourceRectangle,
-                    color,
-                    0f,
-                    Vector2.Zero, SpriteEffects.None, depth);
+                terrainBatcher.Draw(tmpImage.Texture, exDrawRectangle, tmpImage.ExtraSourceRectangle, color, depth);
             }
         }