Fix edge cases where depth was incorrect, use bottom of object's cell as reference instead of top of the cell

Author: Rampastring

src/TSMapEditor/GameMath/CellMath.cs

@@ -8,6 +8,14 @@ namespace TSMapEditor.GameMath
     /// </summary>
     public static class CellMath
     {
+        public static int CellBottomPointFromCellCoords(Point2D cellCoords, Map map)
+        {
+            int cy = (cellCoords.X - 1) * (Constants.CellSizeY / 2);
+            int diff = map.Size.X - cellCoords.Y;
+            cy -= diff * (Constants.CellSizeY / 2);
+            return cy + Constants.MapYBaseline + Constants.CellSizeY;
+        }
+
         public static Point2D CellTopLeftPointFromCellCoords_NoBaseline(Point2D cellCoords, Map map)
         {
             int cx = (cellCoords.X - 1) * (Constants.CellSizeX / 2);

src/TSMapEditor/Rendering/MapView.cs

@@ -291,7 +291,7 @@ public void RefreshRenderTargets()
         {
             ClearRenderTargets();
 
-            mapRenderTarget = CreateFullMapRenderTarget(SurfaceFormat.Color, DepthFormat.Depth24);
+            mapRenderTarget = CreateFullMapRenderTarget(SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
             transparencyRenderTarget = CreateFullMapRenderTarget(SurfaceFormat.Color);
             transparencyPerFrameRenderTarget = CreateFullMapRenderTarget(SurfaceFormat.Color);
             compositeRenderTarget = CreateFullMapRenderTarget(SurfaceFormat.Color, DepthFormat.Depth24);
@@ -347,7 +347,7 @@ private void CreateDepthStencilStates()
                 {
                     DepthBufferEnable = true,
                     DepthBufferWriteEnable = true,
-                    DepthBufferFunction = CompareFunction.GreaterEqual,
+                    DepthBufferFunction = CompareFunction.Greater,
                     StencilEnable = true,
                     StencilFail = StencilOperation.Keep,
                     StencilPass = StencilOperation.Replace,
@@ -1031,7 +1031,7 @@ private void ProcessObjectSpriteRecord(bool noDepthWriting, bool processShadows,
             if (objectSpriteRecord.LineEntries.Count > 0)
             {
                 SetPaletteEffectParams(palettedColorDrawEffect, null, false, false, false);
-                Renderer.PushSettings(new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.Opaque, null, noDepthWriting ? depthReadStencilState : objectRenderStencilState, null, palettedColorDrawEffect));
+                Renderer.PushSettings(new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, noDepthWriting ? depthReadStencilState : objectRenderStencilState, null, palettedColorDrawEffect));
 
                 for (int i = 0; i < objectSpriteRecord.LineEntries.Count; i++)
                 {
@@ -1081,15 +1081,15 @@ private void ProcessObjectSpriteRecord(bool noDepthWriting, bool processShadows,
             if (processShadows && objectSpriteRecord.ShadowEntries.Count > 0)
             {
                 SetPaletteEffectParams(palettedColorDrawEffect, null, false, false, true);
-                gameObjectBatcher.Begin(palettedColorDrawEffect, noDepthWriting ? depthReadStencilState : objectRenderStencilState);
-                GraphicsDevice.BlendState = BlendState.AlphaBlend;
+                gameObjectBatcher.Begin(palettedColorDrawEffect, shadowRenderStencilState);
+                // GraphicsDevice.BlendState = BlendState.AlphaBlend;
 
                 for (int i = 0; i < objectSpriteRecord.ShadowEntries.Count; i++)
                 {
                     var spriteEntry = objectSpriteRecord.ShadowEntries[i];
 
-                    // It doesn't really matter what we give as color to the shadow. Shadows also have no use for the custom data
-                    gameObjectBatcher.Draw(spriteEntry.Texture, spriteEntry.DrawingBounds, spriteEntry.SourceRectangle, new Color(1.0f, 1.0f, 1.0f, 0f),
+                    // It doesn't really matter what we give as color to the shadow
+                    gameObjectBatcher.Draw(spriteEntry.Texture, spriteEntry.DrawingBounds, spriteEntry.SourceRectangle, Color.White,
                         spriteEntry.DepthRectangle);
                 }
 
@@ -1099,7 +1099,7 @@ private void ProcessObjectSpriteRecord(bool noDepthWriting, bool processShadows,
             if (objectSpriteRecord.TextEntries.Count > 0)
             {
                 SetPaletteEffectParams(palettedColorDrawEffect, null, false, false, false);
-                Renderer.PushSettings(new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.Opaque, null, depthRenderStencilState, null, palettedColorDrawEffect));
+                Renderer.PushSettings(new SpriteBatchSettings(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, depthRenderStencilState, null, palettedColorDrawEffect));
 
                 for (int i = 0; i < objectSpriteRecord.TextEntries.Count; i++)
                 {

src/TSMapEditor/Rendering/ObjectRenderers/BuildingRenderer.cs

@@ -17,12 +17,10 @@ public BuildingRenderer(RenderDependencies renderDependencies) : base(renderDepe
 
         private AnimRenderer buildingAnimRenderer;
 
-        Rectangle lowestDrawRectangle;
         DepthRectangle cachedDepth;
 
         public override void InitDrawForObject(Structure gameObject)
         {
-            lowestDrawRectangle = Rectangle.Empty;
             cachedDepth = new DepthRectangle(-1f, -1f);
         }
 
@@ -135,29 +133,49 @@ private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle draw
                 bottom += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellTopLeftPointFromCellCoords(southernmostFoundationCellCoords, Map).Y;
+            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
 
             float topDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);
             float bottomDepth = CellMath.GetDepthForPixelInCube(bottom, 0, yReference, heightReferenceCell, Map);
 
             return new DepthRectangle(topDepth, bottomDepth);
         }
 
+        protected override DepthRectangle GetShadowDepthFromPosition(Structure gameObject, Rectangle drawingBounds)
+        {
+            // The default behaviour for shadows is to call GetDepthFromPosition,
+            // but the adjusted behaviour of GetDepthFromPosition intended for the rendering
+            // of turrets and other on-top-of-the-building objects results in shadows
+            // being too close to the "camera".
+
+            // This implementation fixes the issue by calculating depth from the building's
+            // lowest pixel (at the building's base), not from its highest pixel.
+
+            var southernmostFoundationCellCoords = gameObject.GetSouthernmostFoundationCell();
+            var heightReferenceCell = Map.GetTile(gameObject.Position);
+
+            // drawingBounds includes effect of height, which is undesirable for depth rendering
+            int bottom = drawingBounds.Bottom;
+
+            if (heightReferenceCell != null && !RenderDependencies.EditorState.Is2DMode)
+            {
+                bottom += heightReferenceCell.Level * Constants.CellHeight;
+            }
+
+            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
+
+            float depthAtBottom = CellMath.GetDepthForPixelInCube(bottom, 0, yReference, heightReferenceCell, Map);
+            return new DepthRectangle(depthAtBottom, depthAtBottom);
+        }
+
         protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rectangle drawingBounds)
         {
-            // Because buildings can include turrets, the default implementation
+            // Because buildings have a customized depth implementation and can layer several
+            // sprites on top of each other, the default implementation
             // is not suitable. For example, bodies can be larger than turrets,
             // leading the bodies to have higher depth and overlapping turrets.
             //
-            // To fix this, we normalize everything to use the maximum depth based on the frame
-            // that is drawn southernmost.
-            if (lowestDrawRectangle.Bottom >= drawingBounds.Bottom)
-            {
-                return cachedDepth;
-            }
-
-            float foundationCenterXPoint = GetFoundationCenterXPoint(gameObject);
-            int distRight = (int)(drawingBounds.Width * (1.0f - foundationCenterXPoint));
+            // To fix this, we normalize everything to use the maximum depth.
 
             var southernmostFoundationCellCoords = gameObject.GetSouthernmostFoundationCell();
             var heightReferenceCell = Map.GetTile(gameObject.Position);
@@ -170,12 +188,15 @@ protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rec
                 y += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellTopLeftPointFromCellCoords(southernmostFoundationCellCoords, Map).Y;
+            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
 
             // Used for drawing turrets and stuff, just return maximum depth since they must be on top of the building
             float maxDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);
+
+            if (maxDepth < cachedDepth.TopLeft)
+                return cachedDepth;
+
             cachedDepth = new DepthRectangle(maxDepth, maxDepth);
-            lowestDrawRectangle = drawingBounds;
 
             return cachedDepth;
         }
@@ -198,7 +219,7 @@ protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rec
                 bottom += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellTopLeftPointFromCellCoords(southernmostFoundationCellCoords, Map).Y;
+            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
 
             float depthTopLeft = CellMath.GetDepthForPixelInCube(y, distLeft, yReference, heightReferenceCell, Map);
             float depthTopRight = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);
@@ -234,7 +255,7 @@ protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rec
                 bottom += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellTopLeftPointFromCellCoords(southernmostFoundationCellCoords, Map).Y;
+            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
 
             float depthTopLeft = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);
             float depthTopRight = CellMath.GetDepthForPixelInCube(y, distRight, yReference, heightReferenceCell, Map);
@@ -504,11 +525,11 @@ private void DrawVoxelTurret(Structure gameObject, Point2D drawPoint, in CommonD
                 {
                     DrawVoxelModel(gameObject, drawParams.TurretVoxel,
                         gameObject.Facing, RampType.None, nonRemapColor, true, gameObject.GetRemapColor(),
-                        affectedByLighting, turretDrawPoint, Constants.DepthEpsilon * 2);
+                        affectedByLighting, turretDrawPoint, Constants.DepthEpsilon);
 
                     DrawVoxelModel(gameObject, drawParams.BarrelVoxel,
                         gameObject.Facing, RampType.None, nonRemapColor, true, gameObject.GetRemapColor(),
-                        affectedByLighting, turretDrawPoint, Constants.DepthEpsilon * 3);
+                        affectedByLighting, turretDrawPoint, Constants.DepthEpsilon * 3); // appears to need a 3x multiplier due to float imprecision
                 }
                 else
                 {

src/TSMapEditor/Rendering/ObjectRenderers/ObjectDepthAdjustments.cs

@@ -10,5 +10,6 @@ public static class ObjectDepthAdjustments
         public const int Overlay = 150;
         public const int Terrain = 300;
         public const int Vehicle = 150;
+        public const int Shadow = 0;
     }
 }

src/TSMapEditor/Rendering/ObjectRenderers/ObjectRenderer.cs

@@ -308,10 +308,10 @@ public virtual void DrawShadow(T gameObject)
 
             Rectangle drawingBounds = GetTextureDrawCoords(gameObject, shadowFrame, drawPoint);
 
-            float textureHeight = (regularFrame != null && regularFrame.Texture != null) ? (float)regularFrame.SourceRectangle.Height : shadowFrame.SourceRectangle.Height;
+            float textureHeight = (regularFrame != null && regularFrame.Texture != null) ? regularFrame.SourceRectangle.Height : shadowFrame.SourceRectangle.Height;
 
             DepthRectangle depth = GetShadowDepthFromPosition(gameObject, drawingBounds);
-            depth += GetDepthAddition(gameObject);
+            depth += Constants.DepthEpsilon * ObjectDepthAdjustments.Shadow;
 
             RenderDependencies.ObjectSpriteRecord.AddGraphicsEntry(new ObjectSpriteEntry(null, shadowFrame, drawingBounds, new Color(255, 255, 255, 128), false, true, depth));
         }
@@ -322,7 +322,7 @@ protected virtual DepthRectangle GetDepthFromPosition(T gameObject, Rectangle dr
             var cell = Map.GetTile(gameObject.Position);
             int y = drawingBounds.Y;
             int bottom = drawingBounds.Bottom;
-            int yReference = CellMath.CellTopLeftPointFromCellCoords(gameObject.Position, Map).Y;
+            int yReference = CellMath.CellBottomPointFromCellCoords(gameObject.Position, Map);
             if (cell != null && !RenderDependencies.EditorState.Is2DMode)
             {
                 y += cell.Level * Constants.CellHeight;

src/TSMapEditor/Rendering/ObjectRenderers/UnitRenderer.cs

@@ -35,24 +35,6 @@ public override void InitDrawForObject(Unit gameObject)
             cachedDepth = new DepthRectangle(-1f, -1f);
         }
 
-        protected override DepthRectangle GetDepthFromPosition(Unit gameObject, Rectangle drawingBounds)
-        {
-            // Because vehicles can include turrets, the default implementation
-            // is not suitable. For example, bodies can be rendered southward of turrets
-            // facing north, leading the bodies to have higher depth and overlapping turrets.
-            //
-            // To fix this, we normalize everything to use the maximum depth based on the frame
-            // that is drawn southernmost.
-            if (lowestDrawRectangle.Bottom >= drawingBounds.Bottom)
-            {
-                return cachedDepth;
-            }
-
-            lowestDrawRectangle = drawingBounds;
-            cachedDepth = base.GetDepthFromPosition(gameObject, drawingBounds);
-            return cachedDepth;
-        }
-
         protected override float GetDepthAddition(Unit gameObject)
         {
             if (gameObject.High)
@@ -73,10 +55,9 @@ protected override void Render(Unit gameObject, Point2D drawPoint, in CommonDraw
         {
             bool affectedByLighting = RenderDependencies.EditorState.IsLighting;
 
-            // We need to calculate depth earlier so it can also be used for potential turrets
             if (gameObject.UnitType.ArtConfig.Voxel)
             {
-                RenderVoxelModel(gameObject, drawPoint, drawParams.MainVoxel, affectedByLighting, 0, true);
+                RenderVoxelModel(gameObject, drawPoint, drawParams.MainVoxel, affectedByLighting, 0);
             }
             else
             {
@@ -103,18 +84,18 @@ protected override void Render(Unit gameObject, Point2D drawPoint, in CommonDraw
                 if (gameObject.Facing is > facingStartDrawAbove and <= facingEndDrawAbove)
                 {
                     if (gameObject.UnitType.ArtConfig.Voxel)
-                        RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.TurretVoxel, affectedByLighting, Constants.DepthEpsilon, true);
+                        RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.TurretVoxel, affectedByLighting, Constants.DepthEpsilon);
                     else
                         RenderTurretShape(gameObject, drawPoint, drawParams, Constants.DepthEpsilon);
 
-                    RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.BarrelVoxel, affectedByLighting, Constants.DepthEpsilon * 2, true);
+                    RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.BarrelVoxel, affectedByLighting, Constants.DepthEpsilon * 2);
                 }
                 else
                 {
-                    RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.BarrelVoxel, affectedByLighting, Constants.DepthEpsilon, true);
+                    RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.BarrelVoxel, affectedByLighting, Constants.DepthEpsilon);
 
                     if (gameObject.UnitType.ArtConfig.Voxel)
-                        RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.TurretVoxel, affectedByLighting, Constants.DepthEpsilon * 2, true);
+                        RenderVoxelModel(gameObject, drawPoint + turretOffset, drawParams.TurretVoxel, affectedByLighting, Constants.DepthEpsilon * 2);
                     else
                         RenderTurretShape(gameObject,  drawPoint, drawParams, Constants.DepthEpsilon * 2);
                 }
@@ -151,8 +132,7 @@ private void RenderTurretShape(Unit gameObject, Point2D drawPoint,
         }
 
         private void RenderVoxelModel(Unit gameObject, Point2D drawPoint, 
-            VoxelModel model, bool affectedByLighting, float depthAddition,
-            bool compensateForBottomGap)
+            VoxelModel model, bool affectedByLighting, float depthAddition)
         {
             var unitTile = Map.GetTile(gameObject.Position.X, gameObject.Position.Y);