Take YSortAdjust into account for animations, improve handling of depth for bibs and animations

Rampastring · Rampastring · commit 9ccdf3a2241c · 2026-02-20T21:01:33.000+02:00
diff --git a/src/TSMapEditor/Models/Animation.cs b/src/TSMapEditor/Models/Animation.cs
@@ -85,6 +85,7 @@ public struct BuildingAnimDrawConfig
         public int X { get; set; }
         public int YSort { get; set; }
         public int ZAdjust { get; set; }
-        public readonly int SortValue => YSort - ZAdjust * ZAdjustMult;
+
+        public int SortValue(int ySortAdjust) => YSort + ySortAdjust - ZAdjust * ZAdjustMult;
     }
 }
diff --git a/src/TSMapEditor/Models/ArtConfig/AnimArtConfig.cs b/src/TSMapEditor/Models/ArtConfig/AnimArtConfig.cs
@@ -10,6 +10,7 @@ public AnimArtConfig() { }
         public string Image { get; set; }
         public int YDrawOffset { get; set; }
         public int XDrawOffset { get; set; } // Phobos
+        public int YSortAdjust { get; set; }
         public bool NewTheater { get; set; }
         public bool Theater { get; set; }
         public bool AltPalette { get; set; }
@@ -40,6 +41,7 @@ public void ReadFromIniSection(IniSection iniSection)
             Image = iniSection.GetStringValue(nameof(Image), Image);
             YDrawOffset = iniSection.GetIntValue(nameof(YDrawOffset), YDrawOffset);
             XDrawOffset = iniSection.GetIntValue(nameof(XDrawOffset), XDrawOffset);
+            YSortAdjust = iniSection.GetIntValue(nameof(YSortAdjust), YSortAdjust);
             NewTheater = iniSection.GetBooleanValue(nameof(NewTheater), NewTheater);
             Theater = iniSection.GetBooleanValue(nameof(Theater), Theater);
             AltPalette = iniSection.GetBooleanValue(nameof(AltPalette), AltPalette);
diff --git a/src/TSMapEditor/Rendering/ObjectRenderers/BuildingRenderer.cs b/src/TSMapEditor/Rendering/ObjectRenderers/BuildingRenderer.cs
@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.Xna.Framework;
 using System.Collections.Generic;
 using TSMapEditor.CCEngine;
@@ -16,7 +17,9 @@ public BuildingRenderer(RenderDependencies renderDependencies) : base(renderDepe
 
         private List<Animation> animationList = new List<Animation>();
 
-        DepthRectangle cachedDepth;
+        private DepthRectangle cachedDepth;
+
+        private bool isDrawingBib = false;
 
         public override void InitDrawForObject(Structure gameObject)
         {
@@ -114,7 +117,7 @@ private float GetFoundationCenterXPoint(Structure gameObject)
             return (float)foundation.Width / (foundation.Width + foundation.Height);
         }
 
-        private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle drawingBounds)
+        private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle drawingBounds, bool isBelowBuilding)
         {
             float foundationCenterXPoint = GetFoundationCenterXPoint(gameObject);
             int distRight = (int)(drawingBounds.Width * (1.0f - foundationCenterXPoint));
@@ -132,7 +135,11 @@ private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle draw
                 bottom += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
+            int yReference;
+            if (isBelowBuilding)
+                yReference = CellMath.CellTopLeftPointFromCellCoords(gameObject.Position, Map).Y;
+            else
+                yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
 
             float topDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);
             float bottomDepth = CellMath.GetDepthForPixelInCube(bottom, 0, yReference, heightReferenceCell, Map);
@@ -181,23 +188,35 @@ protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rec
 
             // drawingBounds includes effect of height, which is undesirable for depth rendering
             int y = drawingBounds.Y;
+            int bottom = drawingBounds.Bottom;
 
             if (heightReferenceCell != null && !RenderDependencies.EditorState.Is2DMode)
             {
                 y += heightReferenceCell.Level * Constants.CellHeight;
+                bottom += heightReferenceCell.Level * Constants.CellHeight;
             }
 
-            int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);
+            if (isDrawingBib)
+            {
+                int topYReference = CellMath.CellTopLeftPointFromCellCoords(gameObject.Position, Map).Y;
+                float topDepth = CellMath.GetDepthForPixelInCube(y, 0, topYReference, heightReferenceCell, Map);
+                float bottomDepth = CellMath.GetDepthForPixelInCube(bottom, 0, topYReference, heightReferenceCell, Map);
+                return new DepthRectangle(topDepth, bottomDepth);
+            }
+            else
+            {
+                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);
+                // 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;
+                if (maxDepth < cachedDepth.TopLeft)
+                    return cachedDepth;
 
-            cachedDepth = new DepthRectangle(maxDepth);
+                cachedDepth = new DepthRectangle(maxDepth);
 
-            return cachedDepth;
+                return cachedDepth;
+            }
         }
 
         private (DepthRectangle depthRectangle, Rectangle sourceRect) GetLeftDepthRectangle(Structure gameObject, PositionedTexture texture, Rectangle drawingBounds)
@@ -285,8 +304,10 @@ protected override float GetDepthAddition(Structure gameObject)
 
         private void DrawBibGraphics(Structure gameObject, ShapeImage bibGraphics, Point2D drawPoint, in CommonDrawParams drawParams, bool affectedByLighting)
         {
+            isDrawingBib = true;
             DrawShapeImage(gameObject, bibGraphics, 0, Color.White, true, gameObject.GetRemapColor(),
                 affectedByLighting, !drawParams.ShapeImage.SubjectToLighting, drawPoint);
+            isDrawingBib = false;
         }
 
         protected override void Render(Structure gameObject, Point2D drawPoint, in CommonDrawParams drawParams)
@@ -314,7 +335,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo
 
             // Sort the anims according to their settings
             animationList.Sort((anim1, anim2) =>
-                anim1.BuildingAnimDrawConfig.SortValue.CompareTo(anim2.BuildingAnimDrawConfig.SortValue));
+                anim1.BuildingAnimDrawConfig.SortValue(anim1.AnimType.ArtConfig.YSortAdjust).CompareTo(anim2.BuildingAnimDrawConfig.SortValue(anim2.AnimType.ArtConfig.YSortAdjust)));
 
             bool affectedByAmbient = !affectedByLighting;
 
@@ -323,14 +344,14 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo
             {
                 var anim = animationList[i];
 
-                if (anim.BuildingAnimDrawConfig.SortValue < 0)
+                if (anim.BuildingAnimDrawConfig.SortValue(anim.AnimType.ArtConfig.YSortAdjust) < 0)
                 {
                     var animShape = TheaterGraphics.AnimTextures[anim.AnimType.Index];
                     if (animShape != null)
                     {
                         DrawAnimationImage(gameObject, anim, animShape, anim.GetFrameIndex(animShape.GetFrameCount()),
                             nonRemapColor, true, gameObject.GetRemapColor(), affectedByLighting, affectedByAmbient,
-                            drawPoint, depthAddition);
+                            drawPoint, Constants.DepthEpsilon, true);
                     }
                 }
             }
@@ -356,7 +377,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo
             {
                 var anim = animationList[i];
 
-                if (anim.BuildingAnimDrawConfig.SortValue >= 0)
+                if (anim.BuildingAnimDrawConfig.SortValue(anim.AnimType.ArtConfig.YSortAdjust) >= 0)
                 {
                     // It gets challenging to handle depth if the anim renderer draws anims that are "above" the building, 
                     // as it does not have proper context of the building it's drawing on.
@@ -367,7 +388,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo
                     {
                         DrawAnimationImage(gameObject, anim, animShape, anim.GetFrameIndex(animShape.GetFrameCount()),
                             nonRemapColor, true, gameObject.GetRemapColor(), affectedByLighting, affectedByAmbient,
-                            drawPoint, depthAddition);
+                            drawPoint, 0, false);
                     }
                 }
             }
@@ -462,7 +483,7 @@ private void DrawBuildingImage(Structure gameObject, ShapeImage image, int frame
 
         private void DrawAnimationImage(Structure gameObject, Animation animation, ShapeImage image, int frameIndex, Color color,
             bool drawRemap, Color remapColor, bool affectedByLighting, bool affectedByAmbient, Point2D drawPoint,
-            float depthAddition = 0f)
+            float depthAddition, bool isBelowBuilding)
         {
             if (image == null)
                 return;
@@ -496,9 +517,11 @@ private void DrawAnimationImage(Structure gameObject, Animation animation, Shape
                 }
             }
 
-            var depthRectangle = GetDepthForAnimation(gameObject, drawingBounds);
+            var depthRectangle = GetDepthForAnimation(gameObject, drawingBounds, isBelowBuilding);
             depthRectangle += depthAddition;
-            depthRectangle += GetDepthAddition(gameObject);
+
+            if (!isBelowBuilding)
+                depthRectangle += GetDepthAddition(gameObject);
 
             RenderFrame(gameObject, frame, remapFrame, color, drawRemap, remapColor,
                 drawingBounds, image.GetPaletteTexture(), lighting, depthRectangle);

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,7 @@ public struct BuildingAnimDrawConfig`
`85`	`85`	`public int X { get; set; }`
`86`	`86`	`public int YSort { get; set; }`
`87`	`87`	`public int ZAdjust { get; set; }`
`88`		`- public readonly int SortValue => YSort - ZAdjust * ZAdjustMult;`
	`88`	`+`
	`89`	`+ public int SortValue(int ySortAdjust) => YSort + ySortAdjust - ZAdjust * ZAdjustMult;`
`89`	`90`	`}`
`90`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using Microsoft.CodeAnalysis.CSharp.Syntax;`
`1`	`2`	`using Microsoft.Xna.Framework;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using TSMapEditor.CCEngine;`
`@@ -16,7 +17,9 @@ public BuildingRenderer(RenderDependencies renderDependencies) : base(renderDepe`
`16`	`17`
`17`	`18`	`private List<Animation> animationList = new List<Animation>();`
`18`	`19`
`19`		`- DepthRectangle cachedDepth;`
	`20`	`+ private DepthRectangle cachedDepth;`
	`21`	`+`
	`22`	`+ private bool isDrawingBib = false;`
`20`	`23`
`21`	`24`	`public override void InitDrawForObject(Structure gameObject)`
`22`	`25`	`{`
`@@ -114,7 +117,7 @@ private float GetFoundationCenterXPoint(Structure gameObject)`
`114`	`117`	`return (float)foundation.Width / (foundation.Width + foundation.Height);`
`115`	`118`	`}`
`116`	`119`
`117`		`- private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle drawingBounds)`
	`120`	`+ private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle drawingBounds, bool isBelowBuilding)`
`118`	`121`	`{`
`119`	`122`	`float foundationCenterXPoint = GetFoundationCenterXPoint(gameObject);`
`120`	`123`	`int distRight = (int)(drawingBounds.Width * (1.0f - foundationCenterXPoint));`
`@@ -132,7 +135,11 @@ private DepthRectangle GetDepthForAnimation(Structure gameObject, Rectangle draw`
`132`	`135`	`bottom += heightReferenceCell.Level * Constants.CellHeight;`
`133`	`136`	`}`
`134`	`137`
`135`		`- int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);`
	`138`	`+ int yReference;`
	`139`	`+ if (isBelowBuilding)`
	`140`	`+ yReference = CellMath.CellTopLeftPointFromCellCoords(gameObject.Position, Map).Y;`
	`141`	`+ else`
	`142`	`+ yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);`
`136`	`143`
`137`	`144`	`float topDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);`
`138`	`145`	`float bottomDepth = CellMath.GetDepthForPixelInCube(bottom, 0, yReference, heightReferenceCell, Map);`
`@@ -181,23 +188,35 @@ protected override DepthRectangle GetDepthFromPosition(Structure gameObject, Rec`
`181`	`188`
`182`	`189`	`// drawingBounds includes effect of height, which is undesirable for depth rendering`
`183`	`190`	`int y = drawingBounds.Y;`
	`191`	`+ int bottom = drawingBounds.Bottom;`
`184`	`192`
`185`	`193`	`if (heightReferenceCell != null && !RenderDependencies.EditorState.Is2DMode)`
`186`	`194`	`{`
`187`	`195`	`y += heightReferenceCell.Level * Constants.CellHeight;`
	`196`	`+ bottom += heightReferenceCell.Level * Constants.CellHeight;`
`188`	`197`	`}`
`189`	`198`
`190`		`- int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);`
	`199`	`+ if (isDrawingBib)`
	`200`	`+ {`
	`201`	`+ int topYReference = CellMath.CellTopLeftPointFromCellCoords(gameObject.Position, Map).Y;`
	`202`	`+ float topDepth = CellMath.GetDepthForPixelInCube(y, 0, topYReference, heightReferenceCell, Map);`
	`203`	`+ float bottomDepth = CellMath.GetDepthForPixelInCube(bottom, 0, topYReference, heightReferenceCell, Map);`
	`204`	`+ return new DepthRectangle(topDepth, bottomDepth);`
	`205`	`+ }`
	`206`	`+ else`
	`207`	`+ {`
	`208`	`+ int yReference = CellMath.CellBottomPointFromCellCoords(southernmostFoundationCellCoords, Map);`
`191`	`209`
`192`		`- // Used for drawing turrets and stuff, just return maximum depth since they must be on top of the building`
`193`		`- float maxDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);`
	`210`	`+ // Used for drawing turrets and stuff, just return maximum depth since they must be on top of the building`
	`211`	`+ float maxDepth = CellMath.GetDepthForPixelInCube(y, 0, yReference, heightReferenceCell, Map);`
`194`	`212`
`195`		`- if (maxDepth < cachedDepth.TopLeft)`
`196`		`- return cachedDepth;`
	`213`	`+ if (maxDepth < cachedDepth.TopLeft)`
	`214`	`+ return cachedDepth;`
`197`	`215`
`198`		`- cachedDepth = new DepthRectangle(maxDepth);`
	`216`	`+ cachedDepth = new DepthRectangle(maxDepth);`
`199`	`217`
`200`		`- return cachedDepth;`
	`218`	`+ return cachedDepth;`
	`219`	`+ }`
`201`	`220`	`}`
`202`	`221`
`203`	`222`	`private (DepthRectangle depthRectangle, Rectangle sourceRect) GetLeftDepthRectangle(Structure gameObject, PositionedTexture texture, Rectangle drawingBounds)`
`@@ -285,8 +304,10 @@ protected override float GetDepthAddition(Structure gameObject)`
`285`	`304`
`286`	`305`	`private void DrawBibGraphics(Structure gameObject, ShapeImage bibGraphics, Point2D drawPoint, in CommonDrawParams drawParams, bool affectedByLighting)`
`287`	`306`	`{`
	`307`	`+ isDrawingBib = true;`
`288`	`308`	`DrawShapeImage(gameObject, bibGraphics, 0, Color.White, true, gameObject.GetRemapColor(),`
`289`	`309`	`affectedByLighting, !drawParams.ShapeImage.SubjectToLighting, drawPoint);`
	`310`	`+ isDrawingBib = false;`
`290`	`311`	`}`
`291`	`312`
`292`	`313`	`protected override void Render(Structure gameObject, Point2D drawPoint, in CommonDrawParams drawParams)`
`@@ -314,7 +335,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo`
`314`	`335`
`315`	`336`	`// Sort the anims according to their settings`
`316`	`337`	`animationList.Sort((anim1, anim2) =>`
`317`		`- anim1.BuildingAnimDrawConfig.SortValue.CompareTo(anim2.BuildingAnimDrawConfig.SortValue));`
	`338`	`+ anim1.BuildingAnimDrawConfig.SortValue(anim1.AnimType.ArtConfig.YSortAdjust).CompareTo(anim2.BuildingAnimDrawConfig.SortValue(anim2.AnimType.ArtConfig.YSortAdjust)));`
`318`	`339`
`319`	`340`	`bool affectedByAmbient = !affectedByLighting;`
`320`	`341`
`@@ -323,14 +344,14 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo`
`323`	`344`	`{`
`324`	`345`	`var anim = animationList[i];`
`325`	`346`
`326`		`- if (anim.BuildingAnimDrawConfig.SortValue < 0)`
	`347`	`+ if (anim.BuildingAnimDrawConfig.SortValue(anim.AnimType.ArtConfig.YSortAdjust) < 0)`
`327`	`348`	`{`
`328`	`349`	`var animShape = TheaterGraphics.AnimTextures[anim.AnimType.Index];`
`329`	`350`	`if (animShape != null)`
`330`	`351`	`{`
`331`	`352`	`DrawAnimationImage(gameObject, anim, animShape, anim.GetFrameIndex(animShape.GetFrameCount()),`
`332`	`353`	`nonRemapColor, true, gameObject.GetRemapColor(), affectedByLighting, affectedByAmbient,`
`333`		`- drawPoint, depthAddition);`
	`354`	`+ drawPoint, Constants.DepthEpsilon, true);`
`334`	`355`	`}`
`335`	`356`	`}`
`336`	`357`	`}`
`@@ -356,7 +377,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo`
`356`	`377`	`{`
`357`	`378`	`var anim = animationList[i];`
`358`	`379`
`359`		`- if (anim.BuildingAnimDrawConfig.SortValue >= 0)`
	`380`	`+ if (anim.BuildingAnimDrawConfig.SortValue(anim.AnimType.ArtConfig.YSortAdjust) >= 0)`
`360`	`381`	`{`
`361`	`382`	`// It gets challenging to handle depth if the anim renderer draws anims that are "above" the building,`
`362`	`383`	`// as it does not have proper context of the building it's drawing on.`
`@@ -367,7 +388,7 @@ protected override void Render(Structure gameObject, Point2D drawPoint, in Commo`
`367`	`388`	`{`
`368`	`389`	`DrawAnimationImage(gameObject, anim, animShape, anim.GetFrameIndex(animShape.GetFrameCount()),`
`369`	`390`	`nonRemapColor, true, gameObject.GetRemapColor(), affectedByLighting, affectedByAmbient,`
`370`		`- drawPoint, depthAddition);`
	`391`	`+ drawPoint, 0, false);`
`371`	`392`	`}`
`372`	`393`	`}`
`373`	`394`	`}`
`@@ -462,7 +483,7 @@ private void DrawBuildingImage(Structure gameObject, ShapeImage image, int frame`
`462`	`483`
`463`	`484`	`private void DrawAnimationImage(Structure gameObject, Animation animation, ShapeImage image, int frameIndex, Color color,`
`464`	`485`	`bool drawRemap, Color remapColor, bool affectedByLighting, bool affectedByAmbient, Point2D drawPoint,`
`465`		`- float depthAddition = 0f)`
	`486`	`+ float depthAddition, bool isBelowBuilding)`
`466`	`487`	`{`
`467`	`488`	`if (image == null)`
`468`	`489`	`return;`
`@@ -496,9 +517,11 @@ private void DrawAnimationImage(Structure gameObject, Animation animation, Shape`
`496`	`517`	`}`
`497`	`518`	`}`
`498`	`519`
`499`		`- var depthRectangle = GetDepthForAnimation(gameObject, drawingBounds);`
	`520`	`+ var depthRectangle = GetDepthForAnimation(gameObject, drawingBounds, isBelowBuilding);`
`500`	`521`	`depthRectangle += depthAddition;`
`501`		`- depthRectangle += GetDepthAddition(gameObject);`
	`522`	`+`
	`523`	`+ if (!isBelowBuilding)`
	`524`	`+ depthRectangle += GetDepthAddition(gameObject);`
`502`	`525`
`503`	`526`	`RenderFrame(gameObject, frame, remapFrame, color, drawRemap, remapColor,`
`504`	`527`	`drawingBounds, image.GetPaletteTexture(), lighting, depthRectangle);`