Introduce IRenderable.IsDecoration and AsDecoration.

These are used to filter *Renderables that shouldn't
be copied for things like highlight or shadow.

OpenRA.Game/Graphics/Animation.cs

@@ -17,6 +17,7 @@ namespace OpenRA.Graphics
 	{
 		string name;
 		public Sequence CurrentSequence { get; private set; }
+		public bool IsDecoration = false;
 		int frame = 0;
 		bool backwards = false;
 		bool tickAlways;
@@ -43,10 +44,10 @@ namespace OpenRA.Graphics
 			if (CurrentSequence.ShadowStart >= 0)
 			{
 				var shadow = CurrentSequence.GetShadow(CurrentFrame, facingFunc());
-				yield return new SpriteRenderable(shadow, pos, offset, CurrentSequence.ShadowZOffset + zOffset, palette, scale);
+				yield return new SpriteRenderable(shadow, pos, offset, CurrentSequence.ShadowZOffset + zOffset, palette, scale, true);
 			}
 
-			yield return new SpriteRenderable(Image, pos, offset, CurrentSequence.ZOffset + zOffset, palette, scale);
+			yield return new SpriteRenderable(Image, pos, offset, CurrentSequence.ZOffset + zOffset, palette, scale, IsDecoration);
 		}
 
 		public IEnumerable<IRenderable> Render(WPos pos, PaletteReference palette)

OpenRA.Game/Graphics/BeamRenderable.cs

@@ -34,11 +34,13 @@ namespace OpenRA.Graphics
 		public float Scale { get { return 1f; } }
 		public PaletteReference Palette { get { return null; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return true; } }
 
 		public IRenderable WithScale(float newScale) { return new BeamRenderable(pos, zOffset, length, width, color); }
 		public IRenderable WithPalette(PaletteReference newPalette) { return new BeamRenderable(pos, zOffset, length, width, color); }
 		public IRenderable WithZOffset(int newOffset) { return new BeamRenderable(pos, zOffset, length, width, color); }
 		public IRenderable OffsetBy(WVec vec) { return new BeamRenderable(pos + vec, zOffset, length, width, color); }
+		public IRenderable AsDecoration() { return this; }
 
 		public void BeforeRender(WorldRenderer wr) {}
 		public void Render(WorldRenderer wr)

OpenRA.Game/Graphics/ContrailRenderable.cs

@@ -46,11 +46,13 @@ namespace OpenRA.Graphics
 		public float Scale { get { return 1f; } }
 		public PaletteReference Palette { get { return null; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return true; } }
 
 		public IRenderable WithScale(float newScale) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
 		public IRenderable WithPalette(PaletteReference newPalette) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
 		public IRenderable WithZOffset(int newOffset) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, newOffset); }
 		public IRenderable OffsetBy(WVec vec) { return new ContrailRenderable(world, trail.Select(pos => pos + vec).ToArray(), next, length, skip, color, zOffset); }
+		public IRenderable AsDecoration() { return this; }
 
 		public void BeforeRender(WorldRenderer wr) {}
 		public void Render(WorldRenderer wr)

OpenRA.Game/Graphics/Renderable.cs

@@ -36,11 +36,14 @@ namespace OpenRA.Graphics
 		float Scale { get; }
 		PaletteReference Palette { get; }
 		int ZOffset { get; }
+		bool IsDecoration { get; }
 
 		IRenderable WithScale(float newScale);
 		IRenderable WithPalette(PaletteReference newPalette);
 		IRenderable WithZOffset(int newOffset);
 		IRenderable OffsetBy(WVec offset);
+		IRenderable AsDecoration();
+
 		void BeforeRender(WorldRenderer wr);
 		void Render(WorldRenderer wr);
 		void RenderDebugGeometry(WorldRenderer wr);
@@ -56,8 +59,9 @@ namespace OpenRA.Graphics
 		readonly int zOffset;
 		readonly PaletteReference palette;
 		readonly float scale;
+		readonly bool isDecoration;
 
-		public SpriteRenderable(Sprite sprite, WPos pos, WVec offset, int zOffset, PaletteReference palette, float scale)
+		public SpriteRenderable(Sprite sprite, WPos pos, WVec offset, int zOffset, PaletteReference palette, float scale, bool isDecoration)
 		{
 			this.sprite = sprite;
 			this.pos = pos;
@@ -65,25 +69,21 @@ namespace OpenRA.Graphics
 			this.zOffset = zOffset;
 			this.palette = palette;
 			this.scale = scale;
+			this.isDecoration = isDecoration;
 		}
 
-		public SpriteRenderable(Sprite sprite, WPos pos, int zOffset, PaletteReference palette, float scale)
-			: this(sprite, pos, WVec.Zero, zOffset, palette, scale) { }
-
-		// 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 WPos Pos { get { return pos + offset; } }
 		public WVec Offset { get { return offset; } }
 		public float Scale { get { return scale; } }
 		public PaletteReference Palette { get { return palette; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return isDecoration; } }
 
-		public IRenderable WithScale(float newScale) { return new SpriteRenderable(sprite, pos, offset, zOffset, palette, newScale); }
+		public IRenderable WithScale(float newScale) { return new SpriteRenderable(sprite, pos, offset, zOffset, palette, newScale, isDecoration); }
-		public IRenderable WithPalette(PaletteReference newPalette) { return new SpriteRenderable(sprite, pos, offset, zOffset, newPalette, scale); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new SpriteRenderable(sprite, pos, offset, zOffset, newPalette, scale, isDecoration); }
-		public IRenderable WithZOffset(int newOffset) { return new SpriteRenderable(sprite, pos, offset, newOffset, palette, scale); }
+		public IRenderable WithZOffset(int newOffset) { return new SpriteRenderable(sprite, pos, offset, newOffset, palette, scale, isDecoration); }
-		public IRenderable OffsetBy(WVec vec) { return new SpriteRenderable(sprite, pos + vec, offset, zOffset, palette, scale); }
+		public IRenderable OffsetBy(WVec vec) { return new SpriteRenderable(sprite, pos + vec, offset, zOffset, palette, scale, isDecoration); }
+		public IRenderable AsDecoration() { return new SpriteRenderable(sprite, pos, offset, zOffset, palette, scale, true); }
 
 		float2 ScreenPosition(WorldRenderer wr)
 		{

OpenRA.Game/Graphics/TextRenderable.cs

@@ -35,11 +35,13 @@ namespace OpenRA.Graphics
 		public float Scale { get { return 1f; } }
 		public PaletteReference Palette { get { return null; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return true; } }
 
 		public IRenderable WithScale(float newScale) { return new TextRenderable(font, pos, zOffset, color, text); }
 		public IRenderable WithPalette(PaletteReference newPalette) { return new TextRenderable(font, pos, zOffset, color, text); }
 		public IRenderable WithZOffset(int newOffset) { return new TextRenderable(font, pos, zOffset, color, text); }
 		public IRenderable OffsetBy(WVec vec) { return new TextRenderable(font, pos + vec, zOffset, color, text); }
+		public IRenderable AsDecoration() { return this; }
 
 		public void BeforeRender(WorldRenderer wr) {}
 		public void Render(WorldRenderer wr)

OpenRA.Game/Graphics/VoxelRenderable.cs

@@ -54,6 +54,7 @@ namespace OpenRA.Graphics
 		public float Scale { get { return scale; } }
 		public PaletteReference Palette { get { return palette; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return false; } }
 
 		public IRenderable WithScale(float newScale)
 		{
@@ -83,6 +84,8 @@ namespace OpenRA.Graphics
 			                           palette, normalsPalette, shadowPalette);
 		}
 
+		public IRenderable AsDecoration() { return this; }
+
 		// This will need generalizing once we support TS/RA2 terrain
 		static readonly float[] groundNormal = new float[] {0,0,1,1};
 		public void BeforeRender(WorldRenderer wr)

OpenRA.Mods.RA/Bridge.cs

@@ -151,7 +151,7 @@ namespace OpenRA.Mods.RA
 			}
 
 			foreach (var t in TileSprites[currentTemplate])
-				yield return new SpriteRenderable(t.Value, t.Key.CenterPosition, 0, terrainPalette, 1f);
+				yield return new SpriteRenderable(t.Value, t.Key.CenterPosition, WVec.Zero, 0, terrainPalette, 1f, true);
 		}
 
 		void KillUnitsOnBridge()

OpenRA.Mods.RA/Effects/InvulnEffect.cs

@@ -38,6 +38,7 @@ namespace OpenRA.Mods.RA.Effects
 				yield break;
 
 			foreach (var r in a.Render(wr))
+				if (!r.IsDecoration)
 				yield return r.WithPalette(wr.Palette("invuln"));
 		}
 	}

OpenRA.Mods.RA/Effects/Parachute.cs

@@ -72,7 +72,9 @@ namespace OpenRA.Mods.RA.Effects
 			var shadow = wr.Palette("shadow");
 			foreach (var c in rc)
 			{
-				yield return c.WithPalette(shadow).WithZOffset(-1);
+				if (!c.IsDecoration)
+					yield return c.WithPalette(shadow).WithZOffset(c.ZOffset - 1).AsDecoration();
+
 				yield return c.OffsetBy(pos - c.Pos);
 			}
 

OpenRA.Mods.RA/GainsExperience.cs

@@ -118,8 +118,8 @@ namespace OpenRA.Mods.RA
 				yield break;
 
 			var bounds = self.Bounds.Value;
-			var pos = new float2(bounds.Right, bounds.Bottom - 2);
+			var pos = new PPos(bounds.Right, bounds.Bottom - 2).ToWPos(0);
-			yield return new SpriteRenderable(RankAnim.Image, pos, wr.Palette("effect"), self.CenterLocation.Y);
+			yield return new SpriteRenderable(RankAnim.Image, pos, WVec.Zero, 0, wr.Palette("effect"), 1f, true);
 		}
 	}
 

OpenRA.Mods.RA/Render/RenderBuilding.cs

@@ -63,8 +63,10 @@ namespace OpenRA.Mods.RA.Render
 			foreach (var a in r)
 			{
 				yield return a;
-				if (disabled)
+				if (disabled && !a.IsDecoration)
-					yield return a.WithPalette(wr.Palette("disabled")).WithZOffset(1);
+					yield return a.WithPalette(wr.Palette("disabled"))
+						.WithZOffset(a.ZOffset + 1)
+						.AsDecoration();
 			}
 		}
 

OpenRA.Mods.RA/Render/WithShadow.cs

@@ -31,9 +31,11 @@ namespace OpenRA.Mods.RA.Render
 				? (int)Math.Abs((self.ActorID + Game.LocalTick) / 5 % 4 - 1) - 1 : 0;
 
 			// Contrails shouldn't cast shadows
-			var shadowSprites = r.Where(s => !(s is ContrailRenderable))
+			var shadowSprites = r.Where(s => !s.IsDecoration)
 				.Select(a => a.WithPalette(wr.Palette("shadow"))
-				.OffsetBy(new WVec(0, 0, -a.Pos.Z)).WithZOffset(a.ZOffset + a.Pos.Z));
+				.OffsetBy(new WVec(0, 0, -a.Pos.Z))
+				.WithZOffset(a.ZOffset + a.Pos.Z)
+				.AsDecoration());
 
 			var worldVisualOffset = new WVec(0,0,-43*visualOffset);
 			var flyingSprites = !flying ? r :

OpenRA.Mods.RA/TeslaZapRenderable.cs

@@ -60,11 +60,13 @@ namespace OpenRA.Mods.RA
 		public float Scale { get { return 1f; } }
 		public PaletteReference Palette { get { return null; } }
 		public int ZOffset { get { return zOffset; } }
+		public bool IsDecoration { get { return true; } }
 		
 		public IRenderable WithScale(float newScale) { return new TeslaZapRenderable(pos, zOffset, length, image, brightZaps, dimZaps); }
 		public IRenderable WithPalette(PaletteReference newPalette) { return new TeslaZapRenderable(pos, zOffset, length, image, brightZaps, dimZaps); }
 		public IRenderable WithZOffset(int newOffset) { return new TeslaZapRenderable(pos, zOffset, length, image, brightZaps, dimZaps); }
 		public IRenderable OffsetBy(WVec vec) { return new TeslaZapRenderable(pos + vec, zOffset, length, image, brightZaps, dimZaps); }
+		public IRenderable AsDecoration() { return this; }
 
 		public void BeforeRender(WorldRenderer wr) { }
 		public void RenderDebugGeometry(WorldRenderer wr) { }
@@ -132,8 +134,8 @@ namespace OpenRA.Mods.RA
 				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 SpriteRenderable(s.GetSprite(step[4]), z + new float2(step[2], step[3]),
+				var pos = new PPos((int)(z.X + step[2]), (int)(z.Y + step[3])).ToWPos(0);
-					wr.Palette("effect"), (int)from.Y));
+				rs.Add(new SpriteRenderable(s.GetSprite(step[4]), pos, WVec.Zero, 0, wr.Palette("effect"), 1f, true));
 
 				z += new float2(step[0], step[1]);
 				if (rs.Count >= 1000)