Combine individual object textures into sprite sheets and use custom batcher for rendering objects

Massively increases performance

Author: Rampastring

src/TSMapEditor/Content/Content.mgcb

@@ -16,13 +16,13 @@
 #begin Shaders/AlphaImageToAlphaMap.fx
 /importer:EffectImporter
 /processor:EffectProcessor
-/processorParam:DebugMode=Debug
+/processorParam:DebugMode=Auto
 /build:Shaders/AlphaImageToAlphaMap.fx
 
 #begin Shaders/AlphaMapApply.fx
 /importer:EffectImporter
 /processor:EffectProcessor
-/processorParam:DebugMode=Debug
+/processorParam:DebugMode=Auto
 /build:Shaders/AlphaMapApply.fx
 
 #begin Shaders/ColorDraw.fx
@@ -43,6 +43,12 @@
 /processorParam:DebugMode=Auto
 /build:Shaders/DepthApply.fx
 
+#begin Shaders/LegacyPalettedColorDraw.fx
+/importer:EffectImporter
+/processor:EffectProcessor
+/processorParam:DebugMode=Auto
+/build:Shaders/LegacyPalettedColorDraw.fx
+
 #begin Shaders/PalettedColorDraw.fx
 /importer:EffectImporter
 /processor:EffectProcessor

src/TSMapEditor/Content/Shaders/LegacyPalettedColorDraw.fx

@@ -0,0 +1,165 @@
+#pragma enable_d3d11_debug_symbols
+
+#if OPENGL
+#define SV_POSITION POSITION
+#define VS_SHADERMODEL vs_3_0
+#define PS_SHADERMODEL ps_3_0
+#else
+#define VS_SHADERMODEL vs_4_0
+#define PS_SHADERMODEL ps_4_0
+#endif
+
+// Legacy version of the PalettedColorDraw shader used for drawing objects.
+// PalettedColorDraw relies on a custom vertex shader with custom data that
+// makes it incompatible with MonoGame's regular SpriteBatch.
+
+// This shader does not include a custom vertex shader, keeping it compatible
+// with MonoGame's SpriteBatch. It is used for drawing lines, text, and
+// other more complicated elements that we do not have custom batching code for.
+
+float WorldTextureHeight;
+bool ComplexDepth;
+bool IncreaseDepthUpwards;
+bool DecreaseDepthUpwards;
+bool IsShadow;
+bool UsePalette;
+bool UseRemap;
+float Opacity;
+
+Texture2D MainTexture;
+SamplerState MainSampler
+{
+    Texture = <MainTexture>;
+    AddressU = clamp;
+    AddressV = clamp;
+    MipFilter = Point;
+    MinFilter = Point;
+    MagFilter = Point;
+};
+
+Texture2D PaletteTexture;
+SamplerState PaletteSampler
+{
+    Texture = <PaletteTexture>;
+    AddressU = clamp;
+    AddressV = clamp;
+    MipFilter = Point;
+    MinFilter = Point;
+    MagFilter = Point;
+};
+
+struct VertexShaderOutput
+{
+    float4 Position : SV_POSITION;
+    float4 Color : COLOR0;
+    float2 TextureCoordinates : TEXCOORD0;
+};
+
+struct PixelShaderOutput
+{
+    float4 color : SV_Target0;
+    float depthTarget : SV_Target1;
+    float depthEmbedded : SV_Depth;
+};
+
+
+PixelShaderOutput MainPS(VertexShaderOutput input)
+{
+    PixelShaderOutput output = (PixelShaderOutput) 0;
+
+    // We need to read from the main texture first,
+    // otherwise the output will be black!
+    float4 tex = MainTexture.Sample(MainSampler, input.TextureCoordinates);
+
+    // Discard transparent areas
+    clip(tex.a == 0.0f ? -1 : 1);
+
+    float totalDepth = input.Position.z;
+
+    if (IsShadow)
+    {
+        output.color = float4(0, 0, 0, 0.5);
+
+        output.depthTarget = totalDepth;
+        output.depthEmbedded = totalDepth;
+    }
+    else
+    {
+        if (ComplexDepth || IncreaseDepthUpwards || DecreaseDepthUpwards)
+        {
+            // This branch and its sub-branches do not support sprite sheets!
+            // Only used for drawing objects - terrain uses sprite sheets to increase performance,
+            // but terrain but does not need complex depth.
+            uint width;
+            uint height;
+            MainTexture.GetDimensions(width, height);
+
+            float depthMultiplier = 0.9;
+
+            float distanceFromTop = input.TextureCoordinates.y * height;
+            float distanceFromBottom = height - distanceFromTop;
+
+            if (ComplexDepth)
+            {
+                float centralX = width * input.Color.a;
+                float dx = abs((width * input.TextureCoordinates.x) - centralX);
+                totalDepth = input.Position.z + (((distanceFromBottom - dx) / WorldTextureHeight) * depthMultiplier);
+            }
+            else if (IncreaseDepthUpwards)
+            {
+                totalDepth = input.Position.z + ((distanceFromBottom / WorldTextureHeight) * depthMultiplier);
+            }
+            else if (DecreaseDepthUpwards)
+            {
+                totalDepth = input.Position.z - ((distanceFromBottom / WorldTextureHeight) * depthMultiplier);
+            }
+        }
+
+        output.depthTarget = totalDepth;
+        output.depthEmbedded = totalDepth;
+
+        if (UsePalette)
+        {
+            // Get color from palette
+            float4 paletteColor = PaletteTexture.Sample(PaletteSampler, float2(tex.a, 0.5));
+
+            // We need to convert the grayscale into remap
+            if (UseRemap)
+            {
+                float brightness = max(paletteColor.r, max(paletteColor.g, paletteColor.b));
+
+                // Brigthen it up a bit
+                brightness = brightness * 1.25;
+
+                output.color = float4(brightness * input.Color.r, brightness * input.Color.g, brightness * input.Color.b, paletteColor.a) * Opacity;
+            }
+            else
+            {
+                // Multiply the color by 2. This is done because unlike map lighting which can exceed 1.0 and go up to 2.0,
+                // the color values passed in the pixel shader input are capped at 1.0.
+                // So the multiplication is done to translate pixel shader input color space into in-game color space.
+                // We lose a bit of precision from doing this, but we'll have to accept that.
+                output.color = float4(paletteColor.r * input.Color.r * 2.0,
+                    paletteColor.g * input.Color.g * 2.0,
+                    paletteColor.b * input.Color.b * 2.0,
+                    paletteColor.a) * Opacity;
+            }
+        }
+        else
+        {
+            output.color = float4(tex.r * input.Color.r * 2.0,
+                tex.g * input.Color.g * 2.0,
+                tex.b * input.Color.b * 2.0, tex.a) * Opacity;
+        }
+    }
+
+    return output;
+}
+
+technique SpriteDrawing
+{
+    pass P0
+    {
+        PixelShader = compile PS_SHADERMODEL MainPS();
+    }
+};

src/TSMapEditor/Content/Shaders/PalettedColorDraw.fx

@@ -9,10 +9,14 @@
 #define PS_SHADERMODEL ps_4_0
 #endif
 
-// The "main shader" of the editor.
+// Flexible shader for rendering objects.
 // Can render objects in either paletted or RGBA mode,
 // takes depth into account, and can also draw shadows.
 
+// Relies on custom data in the vertex shader,
+// meaning it is not compatible with SpriteBatch
+// and needs a custom batcher instead.
+
 float WorldTextureHeight;
 bool ComplexDepth;
 bool IncreaseDepthUpwards;
@@ -44,11 +48,22 @@ SamplerState PaletteSampler
     MagFilter = Point;
 };
 
+struct VertexShaderInput
+{
+    float3 Position : POSITION;
+    float4 Color : COLOR0;
+    float2 TextureCoordinates : TEXCOORD0;
+    float4 CustomData : TEXCOORD1;
+};
+
+matrix WorldViewProj : register(c0);
+
 struct VertexShaderOutput
 {
     float4 Position : SV_POSITION;
     float4 Color : COLOR0;
     float2 TextureCoordinates : TEXCOORD0;
+    float4 CustomData : TEXCOORD1;
 };
 
 struct PixelShaderOutput
@@ -59,6 +74,17 @@ struct PixelShaderOutput
 };
 
 
+VertexShaderOutput MainVS(VertexShaderInput input)
+{
+    VertexShaderOutput output;
+    output.Position = mul(float4(input.Position, 1.0), WorldViewProj);
+    output.Color = input.Color;
+    output.TextureCoordinates = input.TextureCoordinates;
+    output.CustomData = input.CustomData;
+    return output;
+}
+
+
 PixelShaderOutput MainPS(VertexShaderOutput input)
 {
     PixelShaderOutput output = (PixelShaderOutput) 0;
@@ -70,37 +96,36 @@ PixelShaderOutput MainPS(VertexShaderOutput input)
     // Discard transparent areas
     clip(tex.a == 0.0f ? -1 : 1);
 
-    float totalDepth;
+    float totalDepth = input.Position.z;
 
     if (IsShadow)
     {
         output.color = float4(0, 0, 0, 0.5);
 
-        totalDepth = input.Position.z;
-
         output.depthTarget = totalDepth;
         output.depthEmbedded = totalDepth;
     }
     else
     {
         if (ComplexDepth || IncreaseDepthUpwards || DecreaseDepthUpwards)
         {
-            // This branch and its sub-branches do not support sprite sheets!
-            // Only used for drawing objects - terrain uses sprite sheets to increase performance,
-            // but terrain but does not need complex depth.
-            uint width;
-            uint height;
-            MainTexture.GetDimensions(width, height);
+            float imageHeight = input.CustomData.y;
+
+            uint spriteSheetWidth;
+            uint spriteSheetHeight;
+            MainTexture.GetDimensions(spriteSheetWidth, spriteSheetHeight);
 
-            float depthMultiplier = 0.75;
+            float depthMultiplier = 0.9;
 
-            float distanceFromTop = input.TextureCoordinates.y * height;
-            float distanceFromBottom = height - distanceFromTop;
+            float distanceFromTop = (input.TextureCoordinates.y - input.CustomData.w) * spriteSheetHeight;
+            float distanceFromBottom = imageHeight - distanceFromTop;
 
             if (ComplexDepth)
             {
-                float centralX = width * input.Color.a;
-                float dx = abs((width * input.TextureCoordinates.x) - centralX);
+                float imageWidth = input.CustomData.x;
+
+                float centralX = imageWidth * input.Color.a;
+                float dx = abs((spriteSheetWidth * (input.TextureCoordinates.x - input.CustomData.z)) - centralX);
                 totalDepth = input.Position.z + (((distanceFromBottom - dx) / WorldTextureHeight) * depthMultiplier);
             }
             else if (IncreaseDepthUpwards)
@@ -112,10 +137,6 @@ PixelShaderOutput MainPS(VertexShaderOutput input)
                 totalDepth = input.Position.z - ((distanceFromBottom / WorldTextureHeight) * depthMultiplier);
             }
         }
-        else
-        {
-            totalDepth = input.Position.z;
-        }
 
         output.depthTarget = totalDepth;
         output.depthEmbedded = totalDepth;
@@ -162,6 +183,7 @@ technique SpriteDrawing
 {
     pass P0
     {
+        VertexShader = compile VS_SHADERMODEL MainVS();
         PixelShader = compile PS_SHADERMODEL MainPS();
     }
 };

src/TSMapEditor/Properties/AssemblyInfo.cs

@@ -34,4 +34,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.5.*")]
+[assembly: AssemblyVersion("1.6.*")]