Add IRenderAnnotations(WhenSelected) interfaces.

OpenRA.Game/Graphics/WorldRenderer.cs

@@ -41,6 +41,7 @@ namespace OpenRA.Graphics
 
 		readonly List<IFinalizedRenderable> preparedRenderables = new List<IFinalizedRenderable>();
 		readonly List<IFinalizedRenderable> preparedOverlayRenderables = new List<IFinalizedRenderable>();
+		readonly List<IFinalizedRenderable> preparedAnnotationRenderables = new List<IFinalizedRenderable>();
 
 		bool lastDepthPreviewEnabled;
 
@@ -130,29 +131,44 @@ namespace OpenRA.Graphics
 
 		IEnumerable<IFinalizedRenderable> GenerateOverlayRenderables()
 		{
-			var aboveShroud = World.ActorsWithTrait<IRenderAboveShroud>()
+			var actors = World.ActorsWithTrait<IRenderAboveShroud>()
 				.Where(a => a.Actor.IsInWorld && !a.Actor.Disposed && (!a.Trait.SpatiallyPartitionable || onScreenActors.Contains(a.Actor)))
 					.SelectMany(a => a.Trait.RenderAboveShroud(a.Actor, this));
 
-			var aboveShroudSelected = World.Selection.Actors.Where(a => a.IsInWorld && !a.Disposed)
+			var selected = World.Selection.Actors.Where(a => a.IsInWorld && !a.Disposed)
 				.SelectMany(a => a.TraitsImplementing<IRenderAboveShroudWhenSelected>()
 					.Where(t => !t.SpatiallyPartitionable || onScreenActors.Contains(a))
 					.SelectMany(t => t.RenderAboveShroud(a, this)));
 
-			var aboveShroudEffects = World.Effects.Select(e => e as IEffectAboveShroud)
+			var effects = World.Effects.Select(e => e as IEffectAboveShroud)
 				.Where(e => e != null)
 				.SelectMany(e => e.RenderAboveShroud(this));
 
-			var aboveShroudOrderGenerator = SpriteRenderable.None;
+			var orderGenerator = SpriteRenderable.None;
 			if (World.OrderGenerator != null)
-				aboveShroudOrderGenerator = World.OrderGenerator.RenderAboveShroud(this, World);
+				orderGenerator = World.OrderGenerator.RenderAboveShroud(this, World);
 
-			var overlayRenderables = aboveShroud
-				.Concat(aboveShroudSelected)
-				.Concat(aboveShroudEffects)
-				.Concat(aboveShroudOrderGenerator);
+			return actors
+				.Concat(selected)
+				.Concat(effects)
+				.Concat(orderGenerator)
+				.Select(r => r.PrepareRender(this));
+		}
 
-			return overlayRenderables.Select(r => r.PrepareRender(this));
+		IEnumerable<IFinalizedRenderable> GenerateAnnotationRenderables()
+		{
+			var actors = World.ActorsWithTrait<IRenderAnnotations>()
+				.Where(a => a.Actor.IsInWorld && !a.Actor.Disposed && (!a.Trait.SpatiallyPartitionable || onScreenActors.Contains(a.Actor)))
+				.SelectMany(a => a.Trait.RenderAnnotations(a.Actor, this));
+
+			var selected = World.Selection.Actors.Where(a => a.IsInWorld && !a.Disposed)
+				.SelectMany(a => a.TraitsImplementing<IRenderAnnotationsWhenSelected>()
+					.Where(t => !t.SpatiallyPartitionable || onScreenActors.Contains(a))
+					.SelectMany(t => t.RenderAnnotations(a, this)));
+
+			return actors
+				.Concat(selected)
+				.Select(r => r.PrepareRender(this));
 		}
 
 		public void PrepareRenderables()
@@ -166,6 +182,7 @@ namespace OpenRA.Graphics
 			onScreenActors.UnionWith(World.ScreenMap.RenderableActorsInBox(Viewport.TopLeft, Viewport.BottomRight));
 			preparedRenderables.AddRange(GenerateRenderables());
 			preparedOverlayRenderables.AddRange(GenerateOverlayRenderables());
+			preparedAnnotationRenderables.AddRange(GenerateAnnotationRenderables());
 			onScreenActors.Clear();
 		}
 
@@ -245,9 +262,19 @@ namespace OpenRA.Graphics
 						1 / Viewport.Zoom, Color.OrangeRed);
 			}
 
+			Game.Renderer.Flush();
+
+			for (var i = 0; i < preparedAnnotationRenderables.Count; i++)
+				preparedAnnotationRenderables[i].Render(this);
+
+			if (debugVis.Value != null && debugVis.Value.RenderGeometry)
+				for (var i = 0; i < preparedAnnotationRenderables.Count; i++)
+					preparedAnnotationRenderables[i].RenderDebugGeometry(this);
+
 			Game.Renderer.Flush();
 			preparedRenderables.Clear();
 			preparedOverlayRenderables.Clear();
+			preparedAnnotationRenderables.Clear();
 		}
 
 		public void RefreshPalette()

OpenRA.Game/Traits/TraitsInterfaces.cs

@@ -427,6 +427,18 @@ namespace OpenRA.Traits
 		bool SpatiallyPartitionable { get; }
 	}
 
+	public interface IRenderAnnotations
+	{
+		IEnumerable<IRenderable> RenderAnnotations(Actor self, WorldRenderer wr);
+		bool SpatiallyPartitionable { get; }
+	}
+
+	public interface IRenderAnnotationsWhenSelected
+	{
+		IEnumerable<IRenderable> RenderAnnotations(Actor self, WorldRenderer wr);
+		bool SpatiallyPartitionable { get; }
+	}
+
 	public interface ISelection
 	{
 		int Hash { get; }