Split Renderable into an IRenderable interface and SpriteRenderable implementation.

OpenRA.Game/Actor.cs

@@ -143,9 +143,9 @@ namespace OpenRA
 		OpenRA.FileFormats.Lazy<int2> Size;
 
 		// note: these delegates are cached to avoid massive allocation.
-		Func<IRender, WorldRenderer, IEnumerable<Renderable>> ApplyIRender;
+		Func<IRender, WorldRenderer, IEnumerable<IRenderable>> ApplyIRender;
-		Func<IEnumerable<Renderable>, IRenderModifier, WorldRenderer, IEnumerable<Renderable>> ApplyRenderModifier;
+		Func<IEnumerable<IRenderable>, IRenderModifier, WorldRenderer, IEnumerable<IRenderable>> ApplyRenderModifier;
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			var mods = TraitsImplementing<IRenderModifier>();
 			var sprites = TraitsImplementing<IRender>().SelectMany(x => ApplyIRender(x, wr));

OpenRA.Game/Effects/DelayedAction.cs

@@ -32,6 +32,6 @@ namespace OpenRA.Effects
 				world.AddFrameEndTask(w => { w.Remove(this); a(); });
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr) { yield break; }
+		public IEnumerable<IRenderable> Render(WorldRenderer wr) { yield break; }
 	}
 }

OpenRA.Game/Effects/FlashTarget.cs

@@ -33,7 +33,7 @@ namespace OpenRA.Effects
 				world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!target.IsInWorld)
 				yield break;

OpenRA.Game/Effects/IEffect.cs

@@ -17,6 +17,6 @@ namespace OpenRA.Effects
 	public interface IEffect
 	{
 		void Tick(World world);
-		IEnumerable<Renderable> Render(WorldRenderer r);
+		IEnumerable<IRenderable> Render(WorldRenderer r);
 	}
 }

OpenRA.Game/Graphics/AnimationWithOffset.cs

@@ -31,18 +31,18 @@ namespace OpenRA.Graphics
 			this.ZOffset = zOffset;
 		}
 
-		public Renderable Image(Actor self, WorldRenderer wr, PaletteReference pal)
+		public IRenderable Image(Actor self, WorldRenderer wr, PaletteReference pal)
 		{
 			return Image(self, wr, pal, 1f);
 		}
 
-		public Renderable Image(Actor self, WorldRenderer wr, PaletteReference pal, float scale)
+		public IRenderable Image(Actor self, WorldRenderer wr, PaletteReference pal, float scale)
 		{
 			var p = self.CenterPosition;
 			if (OffsetFunc != null)
 				p += OffsetFunc();
 
-			return new Renderable(Animation.Image, p, ZOffset, pal, scale);
+			return new SpriteRenderable(Animation.Image, p, ZOffset, pal, scale);
 		}
 
 		public static implicit operator AnimationWithOffset(Animation a)

OpenRA.Game/Graphics/Renderable.cs

@@ -13,7 +13,7 @@ using System.Drawing;
 
 namespace OpenRA.Graphics
 {
-	public class RenderableComparer : IComparer<Renderable>
+	public class RenderableComparer : IComparer<IRenderable>
 	{
 		WorldRenderer wr;
 		public RenderableComparer(WorldRenderer wr)
@@ -21,54 +21,74 @@ namespace OpenRA.Graphics
 			this.wr = wr;
 		}
 
-		public int Compare(Renderable x, Renderable y)
+		public int Compare(IRenderable x, IRenderable y)
 		{
-			return x.SortOrder(wr).CompareTo(y.SortOrder(wr));
+			var xOrder = wr.ScreenZPosition(x.Pos) + x.ZOffset;
+			var yOrder = wr.ScreenZPosition(y.Pos) + y.ZOffset;
+			return xOrder.CompareTo(yOrder);
 		}
 	}
 
-	public struct Renderable
+	public interface IRenderable
 	{
-		public readonly WPos Pos;
+		WPos Pos { get; }
-		public readonly float Scale;
+		float Scale { get; }
-		public readonly PaletteReference Palette;
+		PaletteReference Palette { get; }
-		public readonly int ZOffset;
+		int ZOffset { get; }
-		readonly Sprite Sprite;
 
-		public Renderable(Sprite sprite, WPos pos, int zOffset, PaletteReference palette, float scale)
+		IRenderable WithScale(float newScale);
+		IRenderable WithPalette(PaletteReference newPalette);
+		IRenderable WithZOffset(int newOffset);
+		IRenderable WithPos(WPos pos);
+		void Render(WorldRenderer wr);
+		WVec Size(WorldRenderer wr);
+	}
+
+	public struct SpriteRenderable : IRenderable
+	{
+		readonly Sprite sprite;
+		readonly WPos pos;
+		readonly int zOffset;
+		readonly PaletteReference palette;
+		readonly float scale;
+		readonly float2 pxCenter;
+
+		public SpriteRenderable(Sprite sprite, WPos pos, int zOffset, PaletteReference palette, float scale)
+			: this(sprite, pos, zOffset, palette, scale, 0.5f*scale*sprite.size) {}
+
+		public SpriteRenderable(Sprite sprite, WPos pos, int zOffset, PaletteReference palette, float scale, float2 pxCenter)
 		{
-			Sprite = sprite;
+			this.sprite = sprite;
-			Pos = pos;
+			this.pos = pos;
-			Palette = palette;
+			this.zOffset = zOffset;
-			ZOffset = zOffset;
+			this.palette = palette;
-			Scale = scale;
+			this.scale = scale;
+			this.pxCenter = pxCenter;
 		}
 
-		public Renderable(Sprite sprite, float2 pos, PaletteReference palette, int z)
+		// Provided for legacy support only - Don't use for new things!
+		public SpriteRenderable(Sprite sprite, float2 pos, PaletteReference palette, int z)
 			: this(sprite, new PPos((int)pos.X, (int)pos.Y).ToWPos(0), z, palette, 1f) { }
 
-		public Renderable WithScale(float newScale) { return new Renderable(Sprite, Pos, ZOffset, Palette, newScale); }
+		public WPos Pos { get { return pos; } }
-		public Renderable WithPalette(PaletteReference newPalette) { return new Renderable(Sprite, Pos, ZOffset, newPalette, Scale); }
+		public float Scale { get { return scale; } }
-		public Renderable WithZOffset(int newOffset) { return new Renderable(Sprite, Pos, newOffset, Palette, Scale); }
+		public PaletteReference Palette { get { return palette; } }
-		public Renderable WithPos(WPos pos) { return new Renderable(Sprite, pos, ZOffset, Palette, Scale); }
+		public int ZOffset { get { return zOffset; } }
+
+		public IRenderable WithScale(float newScale) { return new SpriteRenderable(sprite, pos, zOffset, palette, newScale); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new SpriteRenderable(sprite, pos, zOffset, newPalette, scale); }
+		public IRenderable WithZOffset(int newOffset) { return new SpriteRenderable(sprite, pos, newOffset, palette, scale); }
+		public IRenderable WithPos(WPos pos) { return new SpriteRenderable(sprite, pos, zOffset, palette, scale); }
 
 		public void Render(WorldRenderer wr)
 		{
-			Sprite.DrawAt(wr.ScreenPxPosition(Pos) - 0.5f*Scale*Sprite.size, Palette.Index, Scale);
+			sprite.DrawAt(wr.ScreenPxPosition(pos) - pxCenter, palette.Index, scale);
 		}
 
-		public Size Size
+		public WVec Size(WorldRenderer wr)
 		{
-			get
+			var size = (scale*sprite.size).ToInt2();
-			{
+			return new WVec(size.X, size.Y, size.Y);
-				var size = (Scale*Sprite.size).ToInt2();
-				return new Size(size.X, size.Y);
-			}
-		}
-
-		public int SortOrder(WorldRenderer wr)
-		{ 
-			return (int)wr.ScreenZPosition(Pos) + ZOffset;
 		}
 	}
 }

OpenRA.Game/Traits/Render/RenderSimple.cs

@@ -34,12 +34,12 @@ namespace OpenRA.Traits
 		public readonly WAngle CameraPitch = WAngle.FromDegrees(40);
 		public virtual object Create(ActorInitializer init) { return new RenderSimple(init.self); }
 
-		public virtual IEnumerable<Renderable> RenderPreview(ActorInfo ai, PaletteReference pr)
+		public virtual IEnumerable<IRenderable> RenderPreview(ActorInfo ai, PaletteReference pr)
 		{
 			var anim = new Animation(RenderSimple.GetImage(ai), () => 0);
 			anim.PlayRepeating("idle");
 
-			yield return new Renderable(anim.Image, WPos.Zero, 0, pr, 1f);
+			yield return new SpriteRenderable(anim.Image, WPos.Zero, 0, pr, 1f);
 		}
 	}
 
@@ -99,7 +99,7 @@ namespace OpenRA.Traits
 		protected void UpdatePalette() { initializePalette = true; }
 		public void OnOwnerChanged(Actor self, Player oldOwner, Player newOwner) { UpdatePalette(); }
 
-		public virtual IEnumerable<Renderable> Render(Actor self, WorldRenderer wr)
+		public virtual IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr)
 		{
 			if (initializePalette)
 			{

OpenRA.Game/Traits/TraitsInterfaces.cs

@@ -35,7 +35,7 @@ namespace OpenRA.Traits
 
 	public interface ITick { void Tick(Actor self); }
 	public interface ITickRender { void TickRender(WorldRenderer wr, Actor self); }
-	public interface IRender { IEnumerable<Renderable> Render(Actor self, WorldRenderer wr); }
+	public interface IRender { IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr); }
 	public interface IAutoSelectionSize { int2 SelectionSize(Actor self); }
 
 	public interface IIssueOrder
@@ -116,7 +116,7 @@ namespace OpenRA.Traits
 	}
 
 	public interface INotifyAttack { void Attacking(Actor self, Target target); }
-	public interface IRenderModifier { IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r); }
+	public interface IRenderModifier { IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r); }
 	public interface IDamageModifier { float GetDamageModifier(Actor attacker, WarheadInfo warhead); }
 	public interface ISpeedModifier { decimal GetSpeedModifier(); }
 	public interface IFirepowerModifier { float GetFirepowerModifier(); }
@@ -179,7 +179,7 @@ namespace OpenRA.Traits
 
 	public interface IPostRenderSelection { void RenderAfterWorld(WorldRenderer wr); }
 	public interface IPreRenderSelection { void RenderBeforeWorld(WorldRenderer wr, Actor self); }
-	public interface IRenderAsTerrain { IEnumerable<Renderable> RenderAsTerrain(WorldRenderer wr, Actor self); }
+	public interface IRenderAsTerrain { IEnumerable<IRenderable> RenderAsTerrain(WorldRenderer wr, Actor self); }
 	public interface ILocalCoordinatesModel
 	{
 		WVec LocalToWorld(WVec vec);

OpenRA.Mods.Cnc/Effects/IonCannon.cs

@@ -32,9 +32,9 @@ namespace OpenRA.Mods.Cnc.Effects
 
 		public void Tick(World world) { anim.Tick(); }
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(anim.Image,
+			yield return new SpriteRenderable(anim.Image,
 				target.CenterLocation.ToFloat2() - new float2(0, 0.5f*anim.Image.size.Y - Game.CellSize),
 				wr.Palette("effect"), (int)target.CenterLocation.Y);
 		}

OpenRA.Mods.Cnc/WithCargo.cs

@@ -51,7 +51,7 @@ namespace OpenRA.Mods.Cnc
 				positions[i] = new WVec(info.LocalOffset[3*i], info.LocalOffset[3*i + 1], info.LocalOffset[3*i + 2]);
 		}
 
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			foreach (var rr in r)
 				yield return rr;

OpenRA.Mods.RA/BelowUnits.cs

@@ -19,9 +19,9 @@ namespace OpenRA.Mods.RA
 
 	class BelowUnits : IRenderModifier
 	{
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
-			return r.Select(a => a.WithZOffset(-a.Size.Height));
+			return r.Select(a => a.WithZOffset(-a.Size(wr).Z));
 		}
 	}
 }

OpenRA.Mods.RA/Bridge.cs

@@ -142,7 +142,7 @@ namespace OpenRA.Mods.RA
 
 		bool initializePalettes = true;
 		PaletteReference terrainPalette;
-		public IEnumerable<Renderable> RenderAsTerrain(WorldRenderer wr, Actor self)
+		public IEnumerable<IRenderable> RenderAsTerrain(WorldRenderer wr, Actor self)
 		{
 			if (initializePalettes)
 			{
@@ -151,7 +151,7 @@ namespace OpenRA.Mods.RA
 			}
 
 			foreach (var t in TileSprites[currentTemplate])
-				yield return new Renderable(t.Value, Traits.Util.CenterOfCell(t.Key).ToFloat2(), terrainPalette, Game.CellSize * t.Key.Y);
+				yield return new SpriteRenderable(t.Value, Traits.Util.CenterOfCell(t.Key).ToFloat2(), terrainPalette, Game.CellSize * t.Key.Y);
 		}
 
 		void KillUnitsOnBridge()

OpenRA.Mods.RA/Cloak.cs

@@ -66,9 +66,9 @@ namespace OpenRA.Mods.RA
 			if (!canCloak) Uncloak();
 		}
 
-		static readonly Renderable[] Nothing = { };
+		static readonly IRenderable[] Nothing = { };
 
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			if (remainingTime > 0)
 				return r;

OpenRA.Mods.RA/Effects/Bullet.cs

@@ -151,7 +151,7 @@ namespace OpenRA.Mods.RA.Effects
 
 		const float height = .1f;
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (anim != null)
 			{
@@ -166,14 +166,14 @@ namespace OpenRA.Mods.RA.Effects
 					if (Info.High || Info.Angle > 0)
 					{
 						if (Info.Shadow)
-							yield return new Renderable(anim.Image, pos, wr.Palette("shadow"), (int)pos.Y);
+							yield return new SpriteRenderable(anim.Image, pos, wr.Palette("shadow"), (int)pos.Y);
 
 						var highPos = pos - new float2(0, GetAltitude());
 
-						yield return new Renderable(anim.Image, highPos, wr.Palette("effect"), (int)pos.Y);
+						yield return new SpriteRenderable(anim.Image, highPos, wr.Palette("effect"), (int)pos.Y);
 					}
 					else
-						yield return new Renderable(anim.Image, pos,
+						yield return new SpriteRenderable(anim.Image, pos,
 							wr.Palette(Args.weapon.Underwater ? "shadow" : "effect"), (int)pos.Y);
 				}
 			}

OpenRA.Mods.RA/Effects/CashTick.cs

@@ -49,7 +49,7 @@ namespace OpenRA.Mods.RA.Effects
 			pos -= new PVecInt(0, velocity);
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			font.DrawTextWithContrast(s, Game.viewport.Zoom*(pos.ToFloat2() - Game.viewport.Location) - offset, color, Color.Black,1);
 			yield break;

OpenRA.Mods.RA/Effects/Corpse.cs

@@ -31,9 +31,9 @@ namespace OpenRA.Mods.RA.Effects
 
 		public void Tick(World world) { anim.Tick(); }
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(anim.Image, pos, wr.Palette(paletteName), (int)pos.Y);
+			yield return new SpriteRenderable(anim.Image, pos, wr.Palette(paletteName), (int)pos.Y);
 		}
 	}
 }

OpenRA.Mods.RA/Effects/CrateEffect.cs

@@ -39,10 +39,10 @@ namespace OpenRA.Mods.RA.Effects
 			anim.Tick();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (a.IsInWorld)
-				yield return new Renderable(anim.Image,
+				yield return new SpriteRenderable(anim.Image,
 					a.CenterLocation.ToFloat2() + offset,
 				    wr.Palette("effect"), (int)a.CenterLocation.Y);
 		}

OpenRA.Mods.RA/Effects/Explosion.cs

@@ -32,10 +32,10 @@ namespace OpenRA.Mods.RA.Effects
 
 		public void Tick( World world ) { anim.Tick(); }
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			var p = pos.ToInt2() - new int2(0, altitude);
-			yield return new Renderable(anim.Image, p, wr.Palette("effect"), p.Y);
+			yield return new SpriteRenderable(anim.Image, p, wr.Palette("effect"), p.Y);
 		}
 
 		public Player Owner { get { return null; } }

OpenRA.Mods.RA/Effects/GpsDot.cs

@@ -77,14 +77,14 @@ namespace OpenRA.Mods.RA.Effects
 			show = hasGps && hasDot && !dotHidden;
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!show || self.Destroyed)
 				yield break;
 
 			var p = self.CenterLocation;
 			var palette = wr.Palette(info.IndicatorPalettePrefix+self.Owner.InternalName);
-			yield return new Renderable(anim.Image, p.ToFloat2(), palette, p.Y)
+			yield return new SpriteRenderable(anim.Image, p.ToFloat2(), palette, p.Y)
 				.WithScale(1.5f);
 		}
 	}

OpenRA.Mods.RA/Effects/GpsSatellite.cs

@@ -36,9 +36,9 @@ namespace OpenRA.Mods.RA.Effects
 				world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(anim.Image, offset, wr.Palette("effect"), (int)offset.Y);
+			yield return new SpriteRenderable(anim.Image, offset, wr.Palette("effect"), (int)offset.Y);
 		}
 	}
 }

OpenRA.Mods.RA/Effects/GravityBomb.cs

@@ -51,10 +51,10 @@ namespace OpenRA.Mods.RA.Effects
 			anim.Tick();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			var pos = Args.dest.ToInt2() - new int2(0, altitude) - .5f * anim.Image.size;
-			yield return new Renderable(anim.Image, pos, wr.Palette("effect"), Args.dest.Y);
+			yield return new SpriteRenderable(anim.Image, pos, wr.Palette("effect"), Args.dest.Y);
 		}
 	}
 }

OpenRA.Mods.RA/Effects/InvulnEffect.cs

@@ -32,7 +32,7 @@ namespace OpenRA.Mods.RA.Effects
 				world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (a.Destroyed) // Tick will clean up
 				yield break;

OpenRA.Mods.RA/Effects/LaserZap.cs

@@ -76,11 +76,11 @@ namespace OpenRA.Mods.RA.Effects
 					world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (explosion != null)
-				yield return new Renderable(explosion.Image, args.dest.ToFloat2(),
+				yield return new SpriteRenderable(explosion.Image, args.dest.ToFloat2(),
-				                            wr.Palette("effect"), (int)args.dest.Y);
+				                                  wr.Palette("effect"), (int)args.dest.Y);
 
 			if (ticks >= info.BeamDuration)
 				yield break;

OpenRA.Mods.RA/Effects/Missile.cs

@@ -174,11 +174,11 @@ namespace OpenRA.Mods.RA.Effects
 				Combat.DoImpacts(Args);
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!Args.firedBy.World.FogObscures(PxPosition.ToCPos()))
-				yield return new Renderable(anim.Image, PxPosition.ToFloat2() - new float2(0, Altitude),
+				yield return new SpriteRenderable(anim.Image, PxPosition.ToFloat2() - new float2(0, Altitude),
-					wr.Palette(Args.weapon.Underwater ? "shadow" : "effect"), PxPosition.Y);
+				                                  wr.Palette(Args.weapon.Underwater ? "shadow" : "effect"), PxPosition.Y);
 
 			if (Trail != null)
 				Trail.Render(wr, Args.firedBy);

OpenRA.Mods.RA/Effects/NukeLaunch.cs

@@ -77,9 +77,9 @@ namespace OpenRA.Mods.RA.Effects
 				a.Trait.Enable();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(anim.Image, pos.ToFloat2() - new float2(0, altitude),
+			yield return new SpriteRenderable(anim.Image, pos.ToFloat2() - new float2(0, altitude),
 				wr.Palette("effect"), (int)pos.Y);
 		}
 	}

OpenRA.Mods.RA/Effects/Parachute.cs

@@ -61,7 +61,7 @@ namespace OpenRA.Mods.RA.Effects
 			}
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			var rc = cargo.Render(wr);
 
@@ -76,7 +76,7 @@ namespace OpenRA.Mods.RA.Effects
 				yield return c.WithPos(pos);
 			}
 
-			yield return new Renderable(paraAnim.Image, pos + parachuteOffset, 1, rc.First().Palette, 1f);
+			yield return new SpriteRenderable(paraAnim.Image, pos + parachuteOffset, 1, rc.First().Palette, 1f);
 		}
 	}
 }

OpenRA.Mods.RA/Effects/PowerdownIndicator.cs

@@ -34,10 +34,10 @@ namespace OpenRA.Mods.RA.Effects
 			anim.Tick();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!a.Destroyed && a.Owner.IsAlliedWith(a.World.RenderPlayer))
-				yield return new Renderable(anim.Image,	a.CenterLocation.ToFloat2(),
+				yield return new SpriteRenderable(anim.Image, a.CenterLocation.ToFloat2(),
 					wr.Palette("chrome"), (int)a.CenterLocation.Y);
 		}
 	}

OpenRA.Mods.RA/Effects/RallyPoint.cs

@@ -48,7 +48,7 @@ namespace OpenRA.Mods.RA.Effects
 				world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (building.IsInWorld && building.Owner == building.World.LocalPlayer
 				&& building.World.Selection.Actors.Contains(building))
@@ -56,11 +56,11 @@ namespace OpenRA.Mods.RA.Effects
 				var pos = Traits.Util.CenterOfCell(rp.rallyPoint);
 				var palette = wr.Palette(palettePrefix+building.Owner.InternalName);
 
-				yield return new Renderable(circles.Image,
+				yield return new SpriteRenderable(circles.Image,
 					pos.ToFloat2() - .5f * circles.Image.size,
 					palette, (int)pos.Y);
 
-				yield return new Renderable(flag.Image,
+				yield return new SpriteRenderable(flag.Image,
 					pos.ToFloat2() + new float2(-1,-17),
 					palette, (int)pos.Y);
 			}

OpenRA.Mods.RA/Effects/RepairIndicator.cs

@@ -42,11 +42,11 @@ namespace OpenRA.Mods.RA.Effects
 			anim.Tick();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!building.Destroyed)
 			{
-				yield return new Renderable(anim.Image,
+				yield return new SpriteRenderable(anim.Image,
 					building.CenterLocation.ToFloat2(),
 					wr.Palette(palettePrefix+player.InternalName), (int)building.CenterLocation.Y);
 			}

OpenRA.Mods.RA/Effects/SatelliteLaunch.cs

@@ -40,9 +40,9 @@ namespace OpenRA.Mods.RA.Effects
 			}
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(doors.Image, pos, wr.Palette("effect"), (int)doorOffset.Y);
+			yield return new SpriteRenderable(doors.Image, pos, wr.Palette("effect"), (int)doorOffset.Y);
 		}
 	}
 }

OpenRA.Mods.RA/Effects/Smoke.cs

@@ -33,9 +33,9 @@ namespace OpenRA.Mods.RA.Effects
 			anim.Tick();
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
-			yield return new Renderable(anim.Image, pos.ToFloat2(),
+			yield return new SpriteRenderable(anim.Image, pos.ToFloat2(),
 				wr.Palette("effect"), (int)pos.Y);
 		}
 	}

OpenRA.Mods.RA/Effects/TeslaZap.cs

@@ -30,7 +30,7 @@ namespace OpenRA.Mods.RA.Effects
 	{
 		readonly ProjectileArgs Args;
 		readonly TeslaZapInfo Info;
-		IEnumerable<Renderable> renderables;
+		IEnumerable<IRenderable> renderables;
 		int timeUntilRemove = 2; // # of frames
 		bool doneDamage = false;
 		bool initialized = false;
@@ -41,7 +41,7 @@ namespace OpenRA.Mods.RA.Effects
 			Info = info;
 		}
 
-		public IEnumerable<Renderable> GenerateRenderables(WorldRenderer wr)
+		public IEnumerable<IRenderable> GenerateRenderables(WorldRenderer wr)
 		{
 			var bright = SequenceProvider.GetSequence(Info.Image, "bright");
 			var dim = SequenceProvider.GetSequence(Info.Image, "dim");
@@ -72,7 +72,7 @@ namespace OpenRA.Mods.RA.Effects
 			}
 		}
 
-		public IEnumerable<Renderable> Render(WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!initialized)
 			{
@@ -83,13 +83,13 @@ namespace OpenRA.Mods.RA.Effects
 			return renderables;
 		}
 
-		static IEnumerable<Renderable> DrawZapWandering(WorldRenderer wr, PPos from, PPos to, Sequence s)
+		static IEnumerable<IRenderable> DrawZapWandering(WorldRenderer wr, PPos from, PPos to, Sequence s)
 		{
 			var z = float2.Zero;	/* hack */
 			var dist = to - from;
 			var norm = (1f / dist.Length) * new float2(-dist.Y, dist.X);
 
-			var renderables = new List<Renderable>();
+			var renderables = new List<IRenderable>();
 			if (Game.CosmeticRandom.Next(2) != 0)
 			{
 				var p1 = from.ToFloat2() + (1 / 3f) * dist.ToFloat2() + Game.CosmeticRandom.Gauss1D(1) * .2f * dist.Length * norm;
@@ -110,12 +110,12 @@ namespace OpenRA.Mods.RA.Effects
 			return renderables;
 		}
 
-		static IEnumerable<Renderable> DrawZap(WorldRenderer wr, float2 from, float2 to, Sequence s, out float2 p)
+		static IEnumerable<IRenderable> DrawZap(WorldRenderer wr, float2 from, float2 to, Sequence s, out float2 p)
 		{
 			var dist = to - from;
 			var q = new float2(-dist.Y, dist.X);
 			var c = -float2.Dot(from, q);
-			var rs = new List<Renderable>();
+			var rs = new List<IRenderable>();
 			var z = from;
 
 			while ((to - z).X > 5 || (to - z).X < -5 || (to - z).Y > 5 || (to - z).Y < -5)
@@ -123,7 +123,7 @@ namespace OpenRA.Mods.RA.Effects
 				var step = steps.Where(t => (to - (z + new float2(t[0],t[1]))).LengthSquared < (to - z).LengthSquared )
 					.OrderBy(t => Math.Abs(float2.Dot(z + new float2(t[0], t[1]), q) + c)).First();
 
-				rs.Add(new Renderable(s.GetSprite(step[4]), z + new float2(step[2], step[3]),
+				rs.Add(new SpriteRenderable(s.GetSprite(step[4]), z + new float2(step[2], step[3]),
 					wr.Palette("effect"), (int)from.Y));
 				z += new float2(step[0], step[1]);
 				if( rs.Count >= 1000 )

OpenRA.Mods.RA/GainsExperience.cs

@@ -98,7 +98,7 @@ namespace OpenRA.Mods.RA
 			return Level > 0 ? Info.SpeedModifier[Level - 1] : 1m;
 		}
 
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			// TODO: Make this consistent with everything else that adds animations to RenderSimple.
 			if (self.Owner.IsAlliedWith(self.World.RenderPlayer) && Level > 0)
@@ -107,7 +107,7 @@ namespace OpenRA.Mods.RA
 				return r;
 		}
 
-		IEnumerable<Renderable> InnerModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		IEnumerable<IRenderable> InnerModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			foreach (var rs in r)
 				yield return rs;
@@ -119,7 +119,7 @@ namespace OpenRA.Mods.RA
 
 			var bounds = self.Bounds.Value;
 			var pos = new float2(bounds.Right, bounds.Bottom - 2);
-			yield return new Renderable(RankAnim.Image, pos, wr.Palette("effect"), self.CenterLocation.Y);
+			yield return new SpriteRenderable(RankAnim.Image, pos, wr.Palette("effect"), self.CenterLocation.Y);
 		}
 	}
 

OpenRA.Mods.RA/Modifiers/FrozenUnderFog.cs

@@ -24,8 +24,8 @@ namespace OpenRA.Mods.RA
 			return byPlayer == null || Shroud.GetVisOrigins(self).Any(o => byPlayer.Shroud.IsVisible(o));
 		}
 
-		Renderable[] cache = { };
+		IRenderable[] cache = { };
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			if (IsVisible(self, self.World.RenderPlayer))
 				cache = r.ToArray();

OpenRA.Mods.RA/Modifiers/HiddenUnderFog.cs

@@ -24,8 +24,8 @@ namespace OpenRA.Mods.RA
 			return byPlayer == null || Shroud.GetVisOrigins(self).Any(o => byPlayer.Shroud.IsVisible(o));
 		}
 
-		static Renderable[] Nothing = { };
+		static IRenderable[] Nothing = { };
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			return IsVisible(self, self.World.RenderPlayer) ? r : Nothing;
 		}

OpenRA.Mods.RA/Orders/PlaceBuildingOrderGenerator.cs

@@ -22,7 +22,7 @@ namespace OpenRA.Mods.RA.Orders
 		readonly Actor Producer;
 		readonly string Building;
 		readonly BuildingInfo BuildingInfo;
-		IEnumerable<Renderable> preview;
+		IEnumerable<IRenderable> preview;
 		Sprite buildOk, buildBlocked;
 		bool initialized = false;
 

OpenRA.Mods.RA/Render/RenderBuilding.cs

@@ -28,7 +28,7 @@ namespace OpenRA.Mods.RA.Render
 		public readonly WVec Origin = WVec.Zero;
 		public override object Create(ActorInitializer init) { return new RenderBuilding(init, this);}
 
-		public override IEnumerable<Renderable> RenderPreview(ActorInfo building, PaletteReference pr)
+		public override IEnumerable<IRenderable> RenderPreview(ActorInfo building, PaletteReference pr)
 		{
 			return base.RenderPreview(building, pr).Select(a => a.WithPos(a.Pos + Origin));
 		}
@@ -65,7 +65,7 @@ namespace OpenRA.Mods.RA.Render
 				self.QueueActivity(new CallFunc(() => Complete(self)));
 		}
 
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			var disabled = self.IsDisabled();
 			foreach (var a in r)

OpenRA.Mods.RA/Render/RenderBuildingWarFactory.cs

@@ -20,12 +20,12 @@ namespace OpenRA.Mods.RA.Render
 		public override object Create(ActorInitializer init) { return new RenderBuildingWarFactory( init, this ); }
 
 		/* get around unverifiability */
-		IEnumerable<Renderable> BaseBuildingPreview(ActorInfo building, PaletteReference pr)
+		IEnumerable<IRenderable> BaseBuildingPreview(ActorInfo building, PaletteReference pr)
 		{
 			return base.RenderPreview(building, pr);
 		}
 
-		public override IEnumerable<Renderable> RenderPreview(ActorInfo building, PaletteReference pr)
+		public override IEnumerable<IRenderable> RenderPreview(ActorInfo building, PaletteReference pr)
 		{
 			var p = BaseBuildingPreview(building, pr);
 			foreach (var r in p)
@@ -33,7 +33,7 @@ namespace OpenRA.Mods.RA.Render
 
 			var anim = new Animation(RenderSimple.GetImage(building), () => 0);
 			anim.PlayRepeating("idle-top");
-			yield return new Renderable(anim.Image, WPos.Zero + Origin, 0, pr, 1f);
+			yield return new SpriteRenderable(anim.Image, WPos.Zero + Origin, 0, pr, 1f);
 		}
 	}
 

OpenRA.Mods.RA/Render/RenderEditorOnly.cs

@@ -23,7 +23,7 @@ namespace OpenRA.Mods.RA.Render
 	{
 		public RenderEditorOnly(Actor self) : base(self, () => 0) { }
 
-		static readonly Renderable[] Nothing = { };
+		static readonly IRenderable[] Nothing = { };
-		public override IEnumerable<Renderable> Render(Actor self, WorldRenderer wr) { return Nothing; }
+		public override IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr) { return Nothing; }
 	}
 }

OpenRA.Mods.RA/Render/WithMuzzleFlash.cs

@@ -59,7 +59,7 @@ namespace OpenRA.Mods.RA.Render
 				mf.Animation.PlayThen("muzzle", () => isShowing = false);
 		}
 
-		public IEnumerable<Renderable> Render(Actor self, WorldRenderer wr)
+		public IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr)
 		{
 			foreach (var a in muzzleFlashes.Values)
 				if (a.DisableFunc == null || !a.DisableFunc())

OpenRA.Mods.RA/Render/WithShadow.cs

@@ -22,7 +22,7 @@ namespace OpenRA.Mods.RA.Render
 
 	class WithShadow : IRenderModifier
 	{
-		public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
+		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{
 			var move = self.Trait<IMove>();