Sped up shroud rendering.

- Only update shroud within the visible screen area, rather than the whole map. This improves performance on larger maps significantly when scrolling around since large portions of the shroud do not need to be updated.
- Provide methods in Shroud to return delegates to check for explored/visibility for tiles within a certain region. This allows it to return more efficient delegates whenever the region is within the map bounds, or shroud/fog is disabled. In the typical case where the region is in bounds and shroud/fog is enabled, the fast check is almost twice as fast as the slow check.
- Use the Shroud delegate functions in shroud rendering, frozen actors, minimap rendering and resource layer areas to provide a speedup since these areas of code can often take advantage of the fact they perform checks within the map boundary.
- Cache current element in CellRegionEnumerator to prevent repeated work if the element is accessed more than once.
- Decrease the size of elements in some arrays in hopes of reducing memory needs and improving cache hits.

OpenRA.Game/Traits/World/Shroud.cs

@@ -26,8 +26,8 @@ namespace OpenRA.Traits
 		readonly Actor self;
 		readonly Map map;
 
-		readonly CellLayer<int> visibleCount;
-		readonly CellLayer<int> generatedShroudCount;
+		readonly CellLayer<short> visibleCount;
+		readonly CellLayer<short> generatedShroudCount;
 		readonly CellLayer<bool> explored;
 
 		readonly Lazy<IFogVisibilityModifier[]> fogVisibilities;
@@ -39,13 +39,19 @@ namespace OpenRA.Traits
 
 		public int Hash { get; private set; }
 
+		static readonly Func<CPos, bool> TruthPredicate = cell => true;
+		readonly Func<CPos, bool> fastExploredTest;
+		readonly Func<CPos, bool> slowExploredTest;
+		readonly Func<CPos, bool> fastVisibleTest;
+		readonly Func<CPos, bool> slowVisibleTest;
+
 		public Shroud(Actor self)
 		{
 			this.self = self;
 			map = self.World.Map;
 
-			visibleCount = new CellLayer<int>(map);
-			generatedShroudCount = new CellLayer<int>(map);
+			visibleCount = new CellLayer<short>(map);
+			generatedShroudCount = new CellLayer<short>(map);
 			explored = new CellLayer<bool>(map);
 
 			self.World.ActorAdded += AddVisibility;
@@ -55,6 +61,11 @@ namespace OpenRA.Traits
 			self.World.ActorRemoved += RemoveShroudGeneration;
 
 			fogVisibilities = Exts.Lazy(() => self.TraitsImplementing<IFogVisibilityModifier>().ToArray());
+
+			fastExploredTest = IsExploredCore;
+			slowExploredTest = IsExplored;
+			fastVisibleTest = IsVisibleCore;
+			slowVisibleTest = IsVisible;
 		}
 
 		void Invalidate()
@@ -223,10 +234,32 @@ namespace OpenRA.Traits
 			if (!map.Contains(cell))
 				return false;
 
-			if (Disabled || !self.World.LobbyInfo.GlobalSettings.Shroud)
+			if (!ShroudEnabled)
 				return true;
 
-			return explored[cell] && (generatedShroudCount[cell] == 0 || visibleCount[cell] > 0);
+			return IsExploredCore(cell);
+		}
+
+		bool ShroudEnabled { get { return !Disabled && self.World.LobbyInfo.GlobalSettings.Shroud; } }
+
+		bool IsExploredCore(CPos cell)
+		{
+			var uv = Map.CellToMap(map.TileShape, cell);
+			return explored[uv.X, uv.Y] && (generatedShroudCount[uv.X, uv.Y] == 0 || visibleCount[uv.X, uv.Y] > 0);
+		}
+
+		public Func<CPos, bool> IsExploredTest(CellRegion region)
+		{
+			// If the region to test extends outside the map we must use the slow test that checks the map boundary every time.
+			if (!map.Cells.Contains(region))
+				return slowExploredTest;
+
+			// If shroud isn't enabled, then we can see everything.
+			if (!ShroudEnabled)
+				return TruthPredicate;
+
+			// If shroud is enabled, we can use the fast test that just does the core check.
+			return fastExploredTest;
 		}
 
 		public bool IsExplored(Actor a)
@@ -239,12 +272,33 @@ namespace OpenRA.Traits
 			if (!map.Contains(cell))
 				return false;
 
-			if (Disabled || !self.World.LobbyInfo.GlobalSettings.Fog)
+			if (!FogEnabled)
 				return true;
 
+			return IsVisibleCore(cell);
+		}
+
+		bool FogEnabled { get { return !Disabled && self.World.LobbyInfo.GlobalSettings.Fog; } }
+
+		bool IsVisibleCore(CPos cell)
+		{
 			return visibleCount[cell] > 0;
 		}
 
+		public Func<CPos, bool> IsVisibleTest(CellRegion region)
+		{
+			// If the region to test extends outside the map we must use the slow test that checks the map boundary every time.
+			if (!map.Cells.Contains(region))
+				return slowVisibleTest;
+
+			// If fog isn't enabled, then we can see everything.
+			if (!FogEnabled)
+				return TruthPredicate;
+
+			// If fog is enabled, we can use the fast test that just does the core check.
+			return fastVisibleTest;
+		}
+
 		// Actors are hidden under shroud, but not under fog by default
 		public bool IsVisible(Actor a)
 		{