fix: avoid city map visually overlapping the active lot in many cases

Author: riperiperi

TSOClient/tso.client/Rendering/City/CityFoliage.cs

@@ -1,4 +1,5 @@
-using FSO.Common.Utils;
+using FSO.Common.Domain.Realestate;
+using FSO.Common.Utils;
 using FSO.Content.Model;
 using FSO.Files.RC;
 using Microsoft.Xna.Framework;
@@ -46,14 +47,16 @@ private readonly struct TreeGroup(string name, int index, int count)
             public readonly int Count = count;
         }
 
-        public int ChunkSize = 16;
+        public const int ChunkSize = 16;
         public CityMap MapData;
         public Dictionary<int, CityFoliageChunk> Chunks = new Dictionary<int, CityFoliageChunk>();
 
         public DGRP3DVert[][] TreeVerts;
         public int[][] TreeInds;
         public readonly Matrix[] RotationMatrices;
 
+        private uint ActiveLocation;
+
         private readonly TreeGroup[] TreeGroups =
         [
             new("pine", 0, 4), //4 models
@@ -144,7 +147,7 @@ public void InvalidateChunks(Rectangle rect)
                 var x = i % 32;
                 var y = i / 32;
 
-                var chunkRect = new Rectangle(x * 16, y * 16, 16, 16);
+                var chunkRect = new Rectangle(x * ChunkSize, y * ChunkSize, ChunkSize, ChunkSize);
 
                 if (rect.Intersects(chunkRect))
                 {
@@ -153,25 +156,46 @@ public void InvalidateChunks(Rectangle rect)
             }
         }
 
+        private void SetActiveLocation(uint location)
+        {
+            if (ActiveLocation != location)
+            {
+                foreach (var chunk in Chunks.Values)
+                {
+                    uint filtered = chunk.FilterActiveLocation(location);
+
+                    if (filtered != chunk.ActiveLocation)
+                    {
+                        chunk.ActiveLocation = filtered;
+                        chunk.Dirty = true;
+                    }
+                }
+
+                ActiveLocation = location;
+            }
+        }
+
         public void Draw(Terrain terrain, GraphicsDevice gd, CityContent content, Effect VertexShader, Effect PixelShader, int passIndex, int size, BoundingFrustum frustrum)
         {
             var camPos = terrain.Camera.CalculateR();
+            SetActiveLocation(terrain.ActiveLocation);
 
-            var cx = (int)Math.Round(camPos.X / 16);
-            var cy = (int)Math.Round(camPos.Y / 16);
+            var cx = (int)Math.Round(camPos.X / ChunkSize);
+            var cy = (int)Math.Round(camPos.Y / ChunkSize);
 
-            var invalid = Chunks.Keys.Where(i =>
+            var invalid = Chunks.Where(chunkPair =>
             {
-                var x = i % 32;
-                var y = i / 32;
+                var x = chunkPair.Value.X;
+                var y = chunkPair.Value.Y;
+
                 return (x < cx - 2) || (x > cx + 2) || (y < cy - 2) || (y > cy + 2);
             }).ToList();
 
             foreach (var c in invalid)
             {
-                var chunk = Chunks[c];
+                var chunk = c.Value;
                 chunk.Dispose();
-                Chunks.Remove(c);
+                Chunks.Remove(c.Key);
             }
 
             gd.RasterizerState = RasterizerState.CullNone;
@@ -225,7 +249,7 @@ public void Draw(Terrain terrain, GraphicsDevice gd, CityContent content, Effect
             }
         }
 
-        private (DGRP3DVert[], int[]) GetChunkData(int x, int y, HashSet<int> noTrees)
+        private (DGRP3DVert[], int[]) GetChunkData(int x, int y, HashSet<int> noTrees, uint activeLocation)
         {
             var verts = new List<DGRP3DVert>();
             var inds = new List<int>();
@@ -242,13 +266,16 @@ public void Draw(Terrain terrain, GraphicsDevice gd, CityContent content, Effect
             var forestDensityData = MapData.ForestDensityData;
             var roadData = MapData.RoadData;
 
+            var locationCoords = MapCoordinates.Unpack(activeLocation);
+            var treeCut = activeLocation == 0 ? Rectangle.Empty : new Rectangle(locationCoords.X - 1, locationCoords.Y - 1, 3, 3);
+
             for (int oy = starty; oy < endy; oy++)
             {
                 for (int ox = startx; ox < endx; ox++)
                 {
                     var ind = oy * 512 + ox;
                     var forestType = forestTypeData[ind];
-                    if (forestType != ForestType.NULL && !noTrees.Contains(ind))
+                    if (forestType != ForestType.NULL && !noTrees.Contains(ind) && !treeCut.Contains(ox, oy))
                     {
                         if (forestType == 0 && terrainTypeData[ind] == TerrainType.SNOW) forestType = ForestType.SNOW;
                         var densityN = ((forestDensityData[ind] * 4) / 255);
@@ -338,11 +365,13 @@ private void RegenerateChunk(CityFoliageChunk chunk, GraphicsDevice gd, int x, i
                 return;
             }
 
+            chunk.ActiveLocation = ActiveLocation;
+
             chunk.Regenerating = true;
 
             Task.Run(() =>
             {
-                var (verts, inds) = GetChunkData(x, y, noTrees);
+                var (verts, inds) = GetChunkData(x, y, noTrees, chunk.ActiveLocation);
                 GameThread.NextUpdate(state =>
                 {
                     if (verts.Length > 0 && !chunk.Dead)
@@ -385,7 +414,7 @@ public CityFoliageChunk GenerateChunk(GraphicsDevice gd, int x, int y, HashSet<i
         {
             var chunk = new CityFoliageChunk
             {
-                Bounds = new BoundingBox(new Vector3(x * ChunkSize, 0, y * ChunkSize), new Vector3((x + 1) * 32, 255 / 12f, (y + 1) * 32))
+                Bounds = new BoundingBox(new Vector3(x * ChunkSize, 0, y * ChunkSize), new Vector3((x + 1) * 32, 255 / 12f, (y + 1) * 32)),
             };
 
             RegenerateChunk(chunk, gd, x, y, noTrees);
@@ -416,11 +445,31 @@ public class CityFoliageChunk
         public IndexBuffer Indices;
         public BoundingBox Bounds;
 
+        /// <summary>
+        /// Properties around the active location have their city view trees removed to avoid overlapping lot graphics.
+        /// If the active location doesn't overlap this chunk, it's set to 0.
+        /// </summary>
+        public uint ActiveLocation;
+
         public bool Dirty;
         public bool Regenerating;
 
         public bool Dead;
 
+        public uint FilterActiveLocation(uint location)
+        {
+            if (location == 0)
+            {
+                return 0;
+            }
+
+            var coords = MapCoordinates.Unpack(location);
+
+            var chunkRect = new Rectangle(X * 16, Y * 16, 16, 16);
+
+            return chunkRect.Contains(coords.X, coords.Y) ? location : 0;
+        }
+
         public bool ShouldRegenerate()
         {
             if (Dirty && !Regenerating)

TSOClient/tso.client/Rendering/City/CityGeometry.cs

@@ -1,14 +1,35 @@
-using FSO.Common.Utils;
+using FSO.Common.Domain.Realestate;
+using FSO.Common.Utils;
 using FSO.Content.Model;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
-using System;
-using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
 
 namespace FSO.Client.Rendering.City
 {
+    public readonly record struct CitySliceKey
+    {
+        public readonly int SliceID;
+        public readonly Rectangle? FlattenRect;
+
+        public CitySliceKey(int sliceID, uint lotId)
+        {
+            SliceID = sliceID;
+            FlattenRect = null;
+
+            if (lotId != 0)
+            {
+                // Try and build a flatten rect around the target lot.
+                // If surrounding lots are disabled, it only affects the current lot.
+                // If they're enabled, it affects the surrounding lots too.
+
+                var pos = MapCoordinates.Unpack(lotId);
+
+                FlattenRect = new Rectangle(pos.ToPoint(), new Point(1));
+            }
+        }
+    }
+
     public class CityGeometry
     {
         //draw order:
@@ -25,7 +46,7 @@ public class CityGeometry
         public int Width;
         public int Height;
         public int Ready = -1;
-        public int CurrentSlice = -1;
+        public CitySliceKey? CurrentSlice = null;
 
         private bool MeshRegenInProgress;
         private bool MeshDirty;
@@ -529,14 +550,42 @@ public void RegenMeshVerts(GraphicsDevice gd, bool async)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private int O(int x, int y, int minx, int maxx)
+        private static int O(int x, int y, int minx, int maxx)
         {
             return (Math.Max(0, Math.Min(511, y)) * 512 + Math.Max(minx, Math.Min(maxx, x)));
         }
 
-        public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle? range, int subdiv, int cpos)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static float GetContinuity(int x, int y, in Rectangle range, in Rectangle? flattenRect)
         {
-            CurrentSlice = cpos;
+            if (x <= range.X || x >= range.Right || y <= range.Y || y >= range.Bottom)
+            {
+                return -1;
+            }
+
+            if (flattenRect.HasValue)
+            {
+                Rectangle rect = flattenRect.Value;
+
+                if (x >= rect.X && x <= rect.Right && y >= rect.Y && y <= rect.Bottom)
+                {
+                    return -1;
+                }
+            }
+
+            return 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static float Lerp(float a, float b, float t)
+        {
+            return a * (1 - t) + b * t;
+        }
+
+        public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle range, int subdiv, CitySliceKey slice)
+        {
+            var cpos = slice.SliceID;
+            CurrentSlice = slice;
             var indices = new List<int>[5];
             var vertices = new List<TLayerVertex>[5];
 
@@ -560,11 +609,8 @@ public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle? range, int subdiv, i
             float subd1f = 1f / subdiv;
             int vertCount = subd1 * subd1;
 
-            if (range.HasValue)
-            {
-                yStart = range.Value.Y;
-                yEnd = range.Value.Bottom;
-            }
+            yStart = range.Y;
+            yEnd = range.Bottom;
 
             Task.Run(() =>
             {
@@ -599,11 +645,8 @@ public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle? range, int subdiv, i
                     xStart -= fadeRange;
                     xEnd += fadeRange;
 
-                    if (range.HasValue)
-                    {
-                        xStart = Math.Max(range.Value.X, xStart);
-                        xEnd = Math.Min(range.Value.Right, xEnd);
-                    }
+                    xStart = Math.Max(range.X, xStart);
+                    xEnd = Math.Min(range.Right, xEnd);
 
                     for (int j = xStart; j < xEnd; j++)
                     { //where the magic happens
@@ -639,11 +682,12 @@ public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle? range, int subdiv, i
                         var normalRoad = roadByte & 15;
                         var cornerRoad = roadByte >> 4;
 
-                        var yEdge = (j == range.Value.X) ? -1f : 0f;
-                        var yEdge2 = (j == range.Value.Right - 1) ? -1f : 0f;
+                        // Also enforce continuity when within the FlattenRect
 
-                        var xEdge = (i == range.Value.Y) ? -1f : 0f;
-                        var xEdge2 = (i == range.Value.Bottom - 1) ? -1f : 0f;
+                        var cont00 = GetContinuity(j, i, range, in slice.FlattenRect);
+                        var cont10 = GetContinuity(j + 1, i, range, in slice.FlattenRect);
+                        var cont01 = GetContinuity(j, i + 1, range, in slice.FlattenRect);
+                        var cont11 = GetContinuity(j + 1, i + 1, range, in slice.FlattenRect);
 
                         Span<float> d =
                         [
@@ -658,15 +702,18 @@ public void SubRegenMeshVerts(GraphicsDevice gd, Rectangle? range, int subdiv, i
                         var yi = 0f;
                         for (int y = 0; y < subd1; y++)
                         {
-                            var lXE = (yi * xEdge2) + ((1 - yi) * xEdge);
                             var xi = 0f;
                             for (int x = 0; x < subd1; x++)
                             {
+                                var yEdge = Lerp(cont00, cont01, yi);
+                                var yEdge2 = Lerp(cont10, cont11, yi);
+
                                 float y1 = Cubic(d[0], d[1], d[2], d[3], yi, yEdge);
                                 float y2 = Cubic(d[4], d[5], d[6], d[7], yi, yEdge);
                                 float y3 = Cubic(d[8], d[9], d[10], d[11], yi, yEdge2);
                                 float y4 = Cubic(d[12], d[13], d[14], d[15], yi, yEdge2);
 
+                                var lXE = Lerp(yEdge, yEdge2, xi);
                                 var h = Cubic(y1, y2, y3, y4, xi, lXE);
 
                                 var lerpNX = Vector3.Lerp(norm1, norm2, xi);