Merge pull request #10203 from pchote/widelines2

Rewrite line renderer: Part 2 (remove LineRenderer plus other cleanups)

OpenRA.Game/Graphics/LineRenderer.cs

@@ -1,155 +0,0 @@
-#region Copyright & License Information
-/*
- * Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
- * This file is part of OpenRA, which is free software. It is made
- * available to you under the terms of the GNU General Public License
- * as published by the Free Software Foundation. For more information,
- * see COPYING.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-
-namespace OpenRA.Graphics
-{
-	public class LineRenderer : Renderer.IBatchRenderer
-	{
-		static readonly float2 Offset = new float2(0.5f, 0.5f);
-
-		readonly Renderer renderer;
-		readonly IShader shader;
-		readonly Action renderAction;
-
-		readonly Vertex[] vertices;
-		int nv = 0;
-
-		float lineWidth = 1f;
-
-		public LineRenderer(Renderer renderer, IShader shader)
-		{
-			this.renderer = renderer;
-			this.shader = shader;
-			vertices = new Vertex[renderer.TempBufferSize];
-			renderAction = () =>
-			{
-				renderer.SetLineWidth(LineWidth);
-				renderer.DrawBatch(vertices, nv, PrimitiveType.LineList);
-			};
-		}
-
-		public float LineWidth
-		{
-			get
-			{
-				return lineWidth;
-			}
-
-			set
-			{
-				if (LineWidth != value)
-					Flush();
-
-				lineWidth = value;
-			}
-		}
-
-		public void Flush()
-		{
-			if (nv > 0)
-			{
-				renderer.Device.SetBlendMode(BlendMode.Alpha);
-				shader.Render(renderAction);
-				renderer.Device.SetBlendMode(BlendMode.None);
-
-				nv = 0;
-			}
-		}
-
-		public void DrawRect(float2 tl, float2 br, Color c)
-		{
-			var tr = new float2(br.X, tl.Y);
-			var bl = new float2(tl.X, br.Y);
-			DrawLine(tl, tr, c);
-			DrawLine(tl, bl, c);
-			DrawLine(tr, br, c);
-			DrawLine(bl, br, c);
-		}
-
-		public void DrawLine(float2 start, float2 end, Color color)
-		{
-			renderer.CurrentBatchRenderer = this;
-
-			if (nv + 2 > renderer.TempBufferSize)
-				Flush();
-
-			color = Util.PremultiplyAlpha(color);
-			var r = color.R / 255.0f;
-			var g = color.G / 255.0f;
-			var b = color.B / 255.0f;
-			var a = color.A / 255.0f;
-			vertices[nv++] = new Vertex(start + Offset, r, g, b, a);
-			vertices[nv++] = new Vertex(end + Offset, r, g, b, a);
-		}
-
-		public void DrawLine(float2 start, float2 end, Color startColor, Color endColor)
-		{
-			renderer.CurrentBatchRenderer = this;
-
-			if (nv + 2 > renderer.TempBufferSize)
-				Flush();
-
-			startColor = Util.PremultiplyAlpha(startColor);
-			var r = startColor.R / 255.0f;
-			var g = startColor.G / 255.0f;
-			var b = startColor.B / 255.0f;
-			var a = startColor.A / 255.0f;
-			vertices[nv++] = new Vertex(start + Offset, r, g, b, a);
-
-			endColor = Util.PremultiplyAlpha(endColor);
-			r = endColor.R / 255.0f;
-			g = endColor.G / 255.0f;
-			b = endColor.B / 255.0f;
-			a = endColor.A / 255.0f;
-			vertices[nv++] = new Vertex(end + Offset, r, g, b, a);
-		}
-
-		public void DrawLineStrip(IEnumerable<float2> points, Color color)
-		{
-			renderer.CurrentBatchRenderer = this;
-
-			color = Util.PremultiplyAlpha(color);
-			var r = color.R / 255.0f;
-			var g = color.G / 255.0f;
-			var b = color.B / 255.0f;
-			var a = color.A / 255.0f;
-
-			var first = true;
-			var prev = new Vertex();
-			foreach (var point in points)
-			{
-				if (first)
-				{
-					first = false;
-					prev = new Vertex(point + Offset, r, g, b, a);
-					continue;
-				}
-
-				if (nv + 2 > renderer.TempBufferSize)
-					Flush();
-
-				vertices[nv++] = prev;
-				prev = new Vertex(point + Offset, r, g, b, a);
-				vertices[nv++] = prev;
-			}
-		}
-
-		public void SetViewportParams(Size screen, float zoom, int2 scroll)
-		{
-			shader.SetVec("Scroll", scroll.X, scroll.Y);
-			shader.SetVec("r1", zoom * 2f / screen.Width, -zoom * 2f / screen.Height);
-			shader.SetVec("r2", -1, 1);
-		}
-	}
-}

OpenRA.Game/Graphics/RgbaColorRenderer.cs

@@ -45,6 +45,34 @@ namespace OpenRA.Graphics
 			}
 		}
 
+		public void DrawLine(float2 start, float2 end, float width, Color startColor, Color endColor)
+		{
+			renderer.CurrentBatchRenderer = this;
+
+			if (nv + 4 > renderer.TempBufferSize)
+				Flush();
+
+			var delta = (end - start) / (end - start).Length;
+			var corner = width / 2 * new float2(-delta.Y, delta.X);
+
+			startColor = Util.PremultiplyAlpha(startColor);
+			var sr = startColor.R / 255.0f;
+			var sg = startColor.G / 255.0f;
+			var sb = startColor.B / 255.0f;
+			var sa = startColor.A / 255.0f;
+
+			endColor = Util.PremultiplyAlpha(endColor);
+			var er = endColor.R / 255.0f;
+			var eg = endColor.G / 255.0f;
+			var eb = endColor.B / 255.0f;
+			var ea = endColor.A / 255.0f;
+
+			vertices[nv++] = new Vertex(start - corner + Offset, sr, sg, sb, sa);
+			vertices[nv++] = new Vertex(start + corner + Offset, sr, sg, sb, sa);
+			vertices[nv++] = new Vertex(end + corner + Offset, er, eg, eb, ea);
+			vertices[nv++] = new Vertex(end - corner + Offset, er, eg, eb, ea);
+		}
+
 		public void DrawLine(float2 start, float2 end, float width, Color color)
 		{
 			renderer.CurrentBatchRenderer = this;
@@ -67,23 +95,120 @@ namespace OpenRA.Graphics
 			vertices[nv++] = new Vertex(end - corner + Offset, r, g, b, a);
 		}
 
-		public void FillRect(float2 tl, float2 br, Color color)
+		/// <summary>
+		/// Calculate the intersection of two lines.
+		/// Will behave badly if the lines are parallel
+		/// </summary>
+		float2 IntersectionOf(float2 a, float2 da, float2 b, float2 db)
 		{
+			var crossA = a.X * (a.Y + da.Y) - a.Y * (a.X + da.X);
+			var crossB = b.X * (b.Y + db.Y) - b.Y * (b.X + db.X);
+			var x = da.X * crossB - db.X * crossA;
+			var y = da.Y * crossB - db.Y * crossA;
+			var d = da.X * db.Y - da.Y * db.X;
+			return new float2(x, y) / d;
+		}
+
+		void DrawConnectedLine(float2[] points, float width, Color color, bool closed)
+		{
+			// Not a line
+			if (points.Length < 2)
+				return;
+
+			// Single segment
+			if (points.Length == 2)
+			{
+				DrawLine(points[0], points[1], width, color);
+				return;
+			}
+
 			renderer.CurrentBatchRenderer = this;
-
-			if (nv + 4 > renderer.TempBufferSize)
-				Flush();
-
 			color = Util.PremultiplyAlpha(color);
 			var r = color.R / 255.0f;
 			var g = color.G / 255.0f;
 			var b = color.B / 255.0f;
 			var a = color.A / 255.0f;
 
-			vertices[nv++] = new Vertex(new float2(tl.X, tl.Y) + Offset, r, g, b, a);
+			var start = points[0];
-			vertices[nv++] = new Vertex(new float2(br.X, tl.Y) + Offset, r, g, b, a);
+			var end = points[1];
-			vertices[nv++] = new Vertex(new float2(br.X, br.Y) + Offset, r, g, b, a);
+			var dir = (end - start) / (end - start).Length;
-			vertices[nv++] = new Vertex(new float2(tl.X, br.Y) + Offset, r, g, b, a);
+			var corner = width / 2 * new float2(-dir.Y, dir.X);
+
+			// Corners for start of line segment
+			var ca = start - corner;
+			var cb = start + corner;
+
+			// Segment is part of closed loop
+			if (closed)
+			{
+				var prev = points[points.Length - 1];
+				var prevDir = (start - prev) / (start - prev).Length;
+				var prevCorner = width / 2 * new float2(-prevDir.Y, prevDir.X);
+				ca = IntersectionOf(start - prevCorner, prevDir, start - corner, dir);
+				cb = IntersectionOf(start + prevCorner, prevDir, start + corner, dir);
+			}
+
+			var limit = closed ? points.Length : points.Length - 1;
+			for (var i = 0; i < limit; i++)
+			{
+				var next = points[(i + 2) % points.Length];
+				var nextDir = (next - end) / (next - end).Length;
+				var nextCorner = width / 2 * new float2(-nextDir.Y, nextDir.X);
+
+				// Vertices for the corners joining start-end to end-next
+				var cc = closed || i < limit ? IntersectionOf(end + corner, dir, end + nextCorner, nextDir) : end + corner;
+				var cd = closed || i < limit ? IntersectionOf(end - corner, dir, end - nextCorner, nextDir) : end - corner;
+
+				// Fill segment
+				if (nv + 4 > renderer.TempBufferSize)
+					Flush();
+
+				vertices[nv++] = new Vertex(ca + Offset, r, g, b, a);
+				vertices[nv++] = new Vertex(cb + Offset, r, g, b, a);
+				vertices[nv++] = new Vertex(cc + Offset, r, g, b, a);
+				vertices[nv++] = new Vertex(cd + Offset, r, g, b, a);
+
+				// Advance line segment
+				end = next;
+				dir = nextDir;
+				corner = nextCorner;
+
+				ca = cd;
+				cb = cc;
+			}
+		}
+
+		public void DrawLine(float2[] points, float width, Color color, bool connectSegments = false)
+		{
+			if (!connectSegments)
+			{
+				if (points.Length < 2)
+					return;
+
+				for (var i = 1; i < points.Length; i++)
+					DrawLine(points[i - 1], points[i], width, color);
+			}
+			else
+				DrawConnectedLine(points, width, color, false);
+		}
+
+		public void DrawPolygon(float2[] vertices, float width, Color color)
+		{
+			DrawConnectedLine(vertices, width, color, true);
+		}
+
+		public void DrawRect(float2 tl, float2 br, float width, Color color)
+		{
+			var tr = new float2(br.X, tl.Y);
+			var bl = new float2(tl.X, br.Y);
+			DrawPolygon(new[] { tl, tr, br, bl }, width, color);
+		}
+
+		public void FillRect(float2 tl, float2 br, Color color)
+		{
+			var tr = new float2(br.X, tl.Y);
+			var bl = new float2(tl.X, br.Y);
+			FillRect(tl, tr, br, bl, color);
 		}
 
 		public void FillRect(float2 a, float2 b, float2 c, float2 d, Color color)

OpenRA.Game/Graphics/SelectionBarsRenderable.cs

@@ -64,23 +64,24 @@ namespace OpenRA.Graphics
 
 		void DrawSelectionBar(WorldRenderer wr, float2 start, float2 end, float value, Color barColor)
 		{
+			var iz = 1 / wr.Viewport.Zoom;
 			var c = Color.FromArgb(128, 30, 30, 30);
 			var c2 = Color.FromArgb(128, 10, 10, 10);
-			var p = new float2(0, -4 / wr.Viewport.Zoom);
+			var p = new float2(0, -4 * iz);
-			var q = new float2(0, -3 / wr.Viewport.Zoom);
+			var q = new float2(0, -3 * iz);
-			var r = new float2(0, -2 / wr.Viewport.Zoom);
+			var r = new float2(0, -2 * iz);
 
 			var barColor2 = Color.FromArgb(255, barColor.R / 2, barColor.G / 2, barColor.B / 2);
 
 			var z = float2.Lerp(start, end, value);
-			var wlr = Game.Renderer.WorldLineRenderer;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
-			wlr.DrawLine(start + p, end + p, c);
+			wcr.DrawLine(start + p, end + p, iz, c);
-			wlr.DrawLine(start + q, end + q, c2);
+			wcr.DrawLine(start + q, end + q, iz, c2);
-			wlr.DrawLine(start + r, end + r, c);
+			wcr.DrawLine(start + r, end + r, iz, c);
 
-			wlr.DrawLine(start + p, z + p, barColor2);
+			wcr.DrawLine(start + p, z + p, iz, barColor2);
-			wlr.DrawLine(start + q, z + q, barColor);
+			wcr.DrawLine(start + q, z + q, iz, barColor);
-			wlr.DrawLine(start + r, z + r, barColor2);
+			wcr.DrawLine(start + r, z + r, iz, barColor2);
 		}
 
 		Color GetHealthColor(IHealth health)
@@ -120,9 +121,10 @@ namespace OpenRA.Graphics
 
 			var c = Color.FromArgb(128, 30, 30, 30);
 			var c2 = Color.FromArgb(128, 10, 10, 10);
-			var p = new float2(0, -4 / wr.Viewport.Zoom);
+			var iz = 1 / wr.Viewport.Zoom;
-			var q = new float2(0, -3 / wr.Viewport.Zoom);
+			var p = new float2(0, -4 * iz);
-			var r = new float2(0, -2 / wr.Viewport.Zoom);
+			var q = new float2(0, -3 * iz);
+			var r = new float2(0, -2 * iz);
 
 			var healthColor = GetHealthColor(health);
 			var healthColor2 = Color.FromArgb(
@@ -133,14 +135,14 @@ namespace OpenRA.Graphics
 
 			var z = float2.Lerp(start, end, (float)health.HP / health.MaxHP);
 
-			var wlr = Game.Renderer.WorldLineRenderer;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
-			wlr.DrawLine(start + p, end + p, c);
+			wcr.DrawLine(start + p, end + p, iz, c);
-			wlr.DrawLine(start + q, end + q, c2);
+			wcr.DrawLine(start + q, end + q, iz, c2);
-			wlr.DrawLine(start + r, end + r, c);
+			wcr.DrawLine(start + r, end + r, iz, c);
 
-			wlr.DrawLine(start + p, z + p, healthColor2);
+			wcr.DrawLine(start + p, z + p, iz, healthColor2);
-			wlr.DrawLine(start + q, z + q, healthColor);
+			wcr.DrawLine(start + q, z + q, iz, healthColor);
-			wlr.DrawLine(start + r, z + r, healthColor2);
+			wcr.DrawLine(start + r, z + r, iz, healthColor2);
 
 			if (health.DisplayHP != health.HP)
 			{
@@ -152,9 +154,9 @@ namespace OpenRA.Graphics
 					deltaColor.B / 2);
 				var zz = float2.Lerp(start, end, (float)health.DisplayHP / health.MaxHP);
 
-				wlr.DrawLine(z + p, zz + p, deltaColor2);
+				wcr.DrawLine(z + p, zz + p, iz, deltaColor2);
-				wlr.DrawLine(z + q, zz + q, deltaColor);
+				wcr.DrawLine(z + q, zz + q, iz, deltaColor);
-				wlr.DrawLine(z + r, zz + r, deltaColor2);
+				wcr.DrawLine(z + r, zz + r, iz, deltaColor2);
 			}
 		}
 

OpenRA.Game/Graphics/SpriteRenderable.cs

@@ -62,7 +62,7 @@ namespace OpenRA.Graphics
 		public void RenderDebugGeometry(WorldRenderer wr)
 		{
 			var offset = ScreenPosition(wr) + sprite.Offset;
-			Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + sprite.Size, Color.Red);
+			Game.Renderer.WorldRgbaColorRenderer.DrawRect(offset, offset + sprite.Size, 1 / wr.Viewport.Zoom, Color.Red);
 		}
 
 		public Rectangle ScreenBounds(WorldRenderer wr)

OpenRA.Game/Graphics/TargetLineRenderable.cs

@@ -43,16 +43,26 @@ namespace OpenRA.Graphics
 			if (!waypoints.Any())
 				return;
 
+			var iz = 1 / wr.Viewport.Zoom;
 			var first = wr.ScreenPxPosition(waypoints.First());
 			var a = first;
 			foreach (var b in waypoints.Skip(1).Select(pos => wr.ScreenPxPosition(pos)))
 			{
-				Game.Renderer.WorldLineRenderer.DrawLine(a, b, color);
+				Game.Renderer.WorldRgbaColorRenderer.DrawLine(a, b, iz, color);
-				wr.DrawTargetMarker(color, b);
+				DrawTargetMarker(wr, color, b);
 				a = b;
 			}
 
-			wr.DrawTargetMarker(color, first);
+			DrawTargetMarker(wr, color, first);
+		}
+
+		public static void DrawTargetMarker(WorldRenderer wr, Color color, float2 location)
+		{
+			var iz = 1 / wr.Viewport.Zoom;
+			var offset = new float2(iz, iz);
+			var tl = location - offset;
+			var br = location + offset;
+			Game.Renderer.WorldRgbaColorRenderer.FillRect(tl, br, color);
 		}
 
 		public void RenderDebugGeometry(WorldRenderer wr) { }

OpenRA.Game/Graphics/UISpriteRenderable.cs

@@ -53,7 +53,7 @@ namespace OpenRA.Graphics
 		public void RenderDebugGeometry(WorldRenderer wr)
 		{
 			var offset = screenPos + sprite.Offset;
-			Game.Renderer.LineRenderer.DrawRect(offset, offset + sprite.Size, Color.Red);
+			Game.Renderer.RgbaColorRenderer.DrawRect(offset, offset + sprite.Size, 1, Color.Red);
 		}
 
 		public Rectangle ScreenBounds(WorldRenderer wr)

OpenRA.Game/Graphics/WorldRenderer.cs

@@ -204,26 +204,6 @@ namespace OpenRA.Graphics
 			Game.Renderer.Flush();
 		}
 
-		public void DrawRollover(Actor unit)
-		{
-			if (unit.Info.HasTraitInfo<SelectableInfo>())
-				new SelectionBarsRenderable(unit, true, true).Render(this);
-		}
-
-		public void DrawTargetMarker(Color c, float2 location)
-		{
-			var tl = new float2(-1 / Viewport.Zoom, -1 / Viewport.Zoom);
-			var br = new float2(1 / Viewport.Zoom, 1 / Viewport.Zoom);
-			var bl = new float2(tl.X, br.Y);
-			var tr = new float2(br.X, tl.Y);
-
-			var wlr = Game.Renderer.WorldLineRenderer;
-			wlr.DrawLine(location + tl, location + tr, c);
-			wlr.DrawLine(location + tr, location + br, c);
-			wlr.DrawLine(location + br, location + bl, c);
-			wlr.DrawLine(location + bl, location + tl, c);
-		}
-
 		public void RefreshPalette()
 		{
 			palette.ApplyModifiers(World.WorldActor.TraitsImplementing<IPaletteModifier>());

OpenRA.Game/OpenRA.Game.csproj

@@ -119,7 +119,6 @@
     <Compile Include="Graphics\CursorProvider.cs" />
     <Compile Include="Graphics\CursorSequence.cs" />
     <Compile Include="Graphics\HardwarePalette.cs" />
-    <Compile Include="Graphics\LineRenderer.cs" />
     <Compile Include="Graphics\MappedImage.cs" />
     <Compile Include="Graphics\Minimap.cs" />
     <Compile Include="Graphics\SequenceProvider.cs" />

OpenRA.Game/Renderer.cs

@@ -22,10 +22,8 @@ namespace OpenRA
 	{
 		public SpriteRenderer WorldSpriteRenderer { get; private set; }
 		public SpriteRenderer WorldRgbaSpriteRenderer { get; private set; }
-		public LineRenderer WorldLineRenderer { get; private set; }
 		public RgbaColorRenderer WorldRgbaColorRenderer { get; private set; }
 		public VoxelRenderer WorldVoxelRenderer { get; private set; }
-		public LineRenderer LineRenderer { get; private set; }
 		public RgbaColorRenderer RgbaColorRenderer { get; private set; }
 		public SpriteRenderer RgbaSpriteRenderer { get; private set; }
 		public SpriteRenderer SpriteRenderer { get; private set; }
@@ -63,10 +61,8 @@ namespace OpenRA
 
 			WorldSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("shp"));
 			WorldRgbaSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("rgba"));
-			WorldLineRenderer = new LineRenderer(this, Device.CreateShader("color"));
 			WorldRgbaColorRenderer = new RgbaColorRenderer(this, Device.CreateShader("color"));
 			WorldVoxelRenderer = new VoxelRenderer(this, Device.CreateShader("vxl"));
-			LineRenderer = new LineRenderer(this, Device.CreateShader("color"));
 			RgbaColorRenderer = new RgbaColorRenderer(this, Device.CreateShader("color"));
 			RgbaSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("rgba"));
 			SpriteRenderer = new SpriteRenderer(this, Device.CreateShader("shp"));
@@ -120,7 +116,6 @@ namespace OpenRA
 				lastResolution = Resolution;
 				RgbaSpriteRenderer.SetViewportParams(Resolution, 1f, int2.Zero);
 				SpriteRenderer.SetViewportParams(Resolution, 1f, int2.Zero);
-				LineRenderer.SetViewportParams(Resolution, 1f, int2.Zero);
 				RgbaColorRenderer.SetViewportParams(Resolution, 1f, int2.Zero);
 			}
 
@@ -132,7 +127,6 @@ namespace OpenRA
 				WorldRgbaSpriteRenderer.SetViewportParams(Resolution, zoom, scroll);
 				WorldSpriteRenderer.SetViewportParams(Resolution, zoom, scroll);
 				WorldVoxelRenderer.SetViewportParams(Resolution, zoom, scroll);
-				WorldLineRenderer.SetViewportParams(Resolution, zoom, scroll);
 				WorldRgbaColorRenderer.SetViewportParams(Resolution, zoom, scroll);
 			}
 		}

OpenRA.Game/Widgets/WorldInteractionControllerWidget.cs

@@ -33,22 +33,30 @@ namespace OpenRA.Widgets
 			this.worldRenderer = worldRenderer;
 		}
 
+		void DrawRollover(Actor unit)
+		{
+			// TODO: Integrate this with SelectionDecorations to unhardcode the *Renderable
+			if (unit.Info.HasTraitInfo<SelectableInfo>())
+				new SelectionBarsRenderable(unit, true, true).Render(worldRenderer);
+		}
+
 		public override void Draw()
 		{
 			if (!IsDragging)
 			{
 				// Render actors under the mouse pointer
 				foreach (var u in SelectActorsInBoxWithDeadzone(World, lastMousePosition, lastMousePosition))
-					worldRenderer.DrawRollover(u);
+					DrawRollover(u);
 
 				return;
 			}
 
 			// Render actors in the dragbox
 			var selbox = SelectionBox;
-			Game.Renderer.WorldLineRenderer.DrawRect(selbox.Value.First.ToFloat2(), selbox.Value.Second.ToFloat2(), Color.White);
+			Game.Renderer.WorldRgbaColorRenderer.DrawRect(selbox.Value.First, selbox.Value.Second,
+				1 / worldRenderer.Viewport.Zoom, Color.White);
 			foreach (var u in SelectActorsInBoxWithDeadzone(World, selbox.Value.First, selbox.Value.Second))
-				worldRenderer.DrawRollover(u);
+				DrawRollover(u);
 		}
 
 		public override bool HandleMouseInput(MouseInput mi)

OpenRA.Mods.Common/Effects/Bullet.cs

@@ -66,6 +66,7 @@ namespace OpenRA.Mods.Common.Effects
 		public readonly Color ContrailColor = Color.White;
 		public readonly bool ContrailUsePlayerColor = false;
 		public readonly int ContrailDelay = 1;
+		public readonly WDist ContrailWidth = new WDist(64);
 
 		public IEffect Create(ProjectileArgs args) { return new Bullet(this, args); }
 	}
@@ -127,7 +128,7 @@ namespace OpenRA.Mods.Common.Effects
 			if (info.ContrailLength > 0)
 			{
 				var color = info.ContrailUsePlayerColor ? ContrailRenderable.ChooseColor(args.SourceActor) : info.ContrailColor;
-				contrail = new ContrailRenderable(world, color, info.ContrailLength, info.ContrailDelay, 0);
+				contrail = new ContrailRenderable(world, color, info.ContrailWidth, info.ContrailLength, info.ContrailDelay, 0);
 			}
 
 			trailPalette = info.TrailPalette;

OpenRA.Mods.Common/Effects/Contrail.cs

@@ -23,9 +23,12 @@ namespace OpenRA.Mods.Common.Effects
 		[Desc("Position relative to body")]
 		public readonly WVec Offset = WVec.Zero;
 
-		[Desc("Measured in pixels.")]
+		[Desc("Length of the trail (in ticks).")]
 		public readonly int TrailLength = 25;
 
+		[Desc("Width of the trail.")]
+		public readonly WDist TrailWidth = new WDist(64);
+
 		[Desc("RGB color of the contrail.")]
 		public readonly Color Color = Color.White;
 
@@ -48,7 +51,7 @@ namespace OpenRA.Mods.Common.Effects
 			this.info = info;
 
 			var color = info.UsePlayerColor ? ContrailRenderable.ChooseColor(self) : info.Color;
-			trail = new ContrailRenderable(self.World, color, info.TrailLength, 0, 0);
+			trail = new ContrailRenderable(self.World, color, info.TrailWidth, info.TrailLength, 0, 0);
 
 			body = self.Trait<BodyOrientation>();
 		}

OpenRA.Mods.Common/Effects/Missile.cs

@@ -105,6 +105,8 @@ namespace OpenRA.Mods.Common.Effects
 
 		public readonly int ContrailLength = 0;
 
+		public readonly WDist ContrailWidth = new WDist(64);
+
 		public readonly Color ContrailColor = Color.White;
 
 		public readonly bool ContrailUsePlayerColor = false;
@@ -209,7 +211,7 @@ namespace OpenRA.Mods.Common.Effects
 			if (info.ContrailLength > 0)
 			{
 				var color = info.ContrailUsePlayerColor ? ContrailRenderable.ChooseColor(args.SourceActor) : info.ContrailColor;
-				contrail = new ContrailRenderable(world, color, info.ContrailLength, info.ContrailDelay, 0);
+				contrail = new ContrailRenderable(world, color, info.ContrailWidth, info.ContrailLength, info.ContrailDelay, 0);
 			}
 
 			trailPalette = info.TrailPalette;

OpenRA.Mods.Common/Graphics/ContrailRenderable.cs

@@ -24,17 +24,19 @@ namespace OpenRA.Mods.Common.Graphics
 
 		// Store trail positions in a circular buffer
 		readonly WPos[] trail;
+		readonly WDist width;
 		int next;
 		int length;
 		int skip;
 
-		public ContrailRenderable(World world, Color color, int length, int skip, int zOffset)
+		public ContrailRenderable(World world, Color color, WDist width, int length, int skip, int zOffset)
-			: this(world, new WPos[length], 0, 0, skip, color, zOffset) { }
+			: this(world, new WPos[length], width, 0, 0, skip, color, zOffset) { }
 
-		ContrailRenderable(World world, WPos[] trail, int next, int length, int skip, Color color, int zOffset)
+		ContrailRenderable(World world, WPos[] trail, WDist width, int next, int length, int skip, Color color, int zOffset)
 		{
 			this.world = world;
 			this.trail = trail;
+			this.width = width;
 			this.next = next;
 			this.length = length;
 			this.skip = skip;
@@ -47,9 +49,9 @@ namespace OpenRA.Mods.Common.Graphics
 		public int ZOffset { get { return zOffset; } }
 		public bool IsDecoration { get { return true; } }
 
-		public IRenderable WithPalette(PaletteReference newPalette) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new ContrailRenderable(world, (WPos[])trail.Clone(), width, next, length, skip, color, zOffset); }
-		public IRenderable WithZOffset(int newOffset) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, newOffset); }
+		public IRenderable WithZOffset(int newOffset) { return new ContrailRenderable(world, (WPos[])trail.Clone(), width, 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 OffsetBy(WVec vec) { return new ContrailRenderable(world, trail.Select(pos => pos + vec).ToArray(), width, next, length, skip, color, zOffset); }
 		public IRenderable AsDecoration() { return this; }
 
 		public IFinalizedRenderable PrepareRender(WorldRenderer wr) { return this; }
@@ -59,9 +61,8 @@ namespace OpenRA.Mods.Common.Graphics
 			if (length - skip < 4)
 				return;
 
-			var wlr = Game.Renderer.WorldLineRenderer;
+			var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0];
-			var oldWidth = wlr.LineWidth;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
-			wlr.LineWidth = wr.Viewport.Zoom;
 
 			// Start of the first line segment is the tail of the list - don't smooth it.
 			var curPos = trail[Index(next - skip - 1)];
@@ -73,13 +74,11 @@ namespace OpenRA.Mods.Common.Graphics
 				var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent);
 
 				if (!world.FogObscures(curPos) && !world.FogObscures(nextPos))
-					wlr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), curColor, nextColor);
+					wcr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), screenWidth, curColor, nextColor);
 
 				curPos = nextPos;
 				curColor = nextColor;
 			}
-
-			wlr.LineWidth = oldWidth;
 		}
 
 		public void RenderDebugGeometry(WorldRenderer wr) { }

OpenRA.Mods.Common/Graphics/SelectionBoxRenderable.cs

@@ -17,18 +17,16 @@ namespace OpenRA.Mods.Common.Graphics
 	public struct SelectionBoxRenderable : IRenderable, IFinalizedRenderable
 	{
 		readonly WPos pos;
-		readonly float scale;
 		readonly Rectangle visualBounds;
 		readonly Color color;
 
 		public SelectionBoxRenderable(Actor actor, Color color)
-			: this(actor.CenterPosition, actor.VisualBounds, 1f, color) { }
+			: this(actor.CenterPosition, actor.VisualBounds, color) { }
 
-		public SelectionBoxRenderable(WPos pos, Rectangle visualBounds, float scale, Color color)
+		public SelectionBoxRenderable(WPos pos, Rectangle visualBounds, Color color)
 		{
 			this.pos = pos;
 			this.visualBounds = visualBounds;
-			this.scale = scale;
 			this.color = color;
 		}
 
@@ -40,30 +38,26 @@ namespace OpenRA.Mods.Common.Graphics
 
 		public IRenderable WithPalette(PaletteReference newPalette) { return this; }
 		public IRenderable WithZOffset(int newOffset) { return this; }
-		public IRenderable OffsetBy(WVec vec) { return new SelectionBoxRenderable(pos + vec, visualBounds, scale, color); }
+		public IRenderable OffsetBy(WVec vec) { return new SelectionBoxRenderable(pos + vec, visualBounds, color); }
 		public IRenderable AsDecoration() { return this; }
 
 		public IFinalizedRenderable PrepareRender(WorldRenderer wr) { return this; }
 		public void Render(WorldRenderer wr)
 		{
+			var iz = 1 / wr.Viewport.Zoom;
 			var screenPos = wr.ScreenPxPosition(pos);
-			var tl = screenPos + scale * new float2(visualBounds.Left, visualBounds.Top);
+			var tl = screenPos + new float2(visualBounds.Left, visualBounds.Top);
-			var br = screenPos + scale * new float2(visualBounds.Right, visualBounds.Bottom);
+			var br = screenPos + new float2(visualBounds.Right, visualBounds.Bottom);
 			var tr = new float2(br.X, tl.Y);
 			var bl = new float2(tl.X, br.Y);
-			var u = new float2(4f / wr.Viewport.Zoom, 0);
+			var u = new float2(4 * iz, 0);
-			var v = new float2(0, 4f / wr.Viewport.Zoom);
+			var v = new float2(0, 4 * iz);
 
-			var wlr = Game.Renderer.WorldLineRenderer;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
-			wlr.DrawLine(tl + u, tl, color);
+			wcr.DrawLine(new[] { tl + u, tl, tl + v }, iz, color, true);
-			wlr.DrawLine(tl, tl + v, color);
+			wcr.DrawLine(new[] { tr - u, tr, tr + v }, iz, color, true);
-			wlr.DrawLine(tr, tr - u, color);
+			wcr.DrawLine(new[] { br - u, br, br - v }, iz, color, true);
-			wlr.DrawLine(tr, tr + v, color);
+			wcr.DrawLine(new[] { bl + u, bl, bl - v }, iz, color, true);
-
-			wlr.DrawLine(bl, bl + u, color);
-			wlr.DrawLine(bl, bl - v, color);
-			wlr.DrawLine(br, br - u, color);
-			wlr.DrawLine(br, br - v, color);
 		}
 
 		public void RenderDebugGeometry(WorldRenderer wr) { }

OpenRA.Mods.Common/Graphics/TextRenderable.cs

@@ -53,7 +53,7 @@ namespace OpenRA.Mods.Common.Graphics
 		{
 			var size = font.Measure(text).ToFloat2();
 			var offset = wr.ScreenPxPosition(pos) - 0.5f * size;
-			Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + size, Color.Red);
+			Game.Renderer.WorldRgbaColorRenderer.DrawRect(offset, offset + size, 1 / wr.Viewport.Zoom, Color.Red);
 		}
 
 		public Rectangle ScreenBounds(WorldRenderer wr) { return Rectangle.Empty; }

OpenRA.Mods.Common/Graphics/VoxelRenderable.cs

@@ -105,9 +105,7 @@ namespace OpenRA.Mods.Common.Graphics
 			public void Render(WorldRenderer wr)
 			{
 				var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length);
-
 				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / 1024f;
-
 				var pxOrigin = wr.ScreenPosition(voxel.pos);
 				var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1));
 
@@ -122,21 +120,27 @@ namespace OpenRA.Mods.Common.Graphics
 
 			public void RenderDebugGeometry(WorldRenderer wr)
 			{
+				var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length);
+				var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / 1024f;
 				var pxOrigin = wr.ScreenPosition(voxel.pos);
-				var groundZ = 0.5f * (pxOrigin.Y - wr.ScreenZPosition(voxel.pos, 0));
 				var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1));
+				var iz = 1 / wr.Viewport.Zoom;
 
 				// Draw sprite rect
 				var offset = pxOrigin + renderProxy.Sprite.Offset - 0.5f * renderProxy.Sprite.Size;
-				Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + renderProxy.Sprite.Size, Color.Red);
+				Game.Renderer.WorldRgbaColorRenderer.DrawRect(offset, offset + renderProxy.Sprite.Size, iz, Color.Red);
 
 				// Draw transformed shadow sprite rect
 				var c = Color.Purple;
 				var psb = renderProxy.ProjectedShadowBounds;
-				Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[1], shadowOrigin + psb[3], c);
+
-				Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[3], shadowOrigin + psb[0], c);
+				Game.Renderer.WorldRgbaColorRenderer.DrawPolygon(new[]
-				Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[0], shadowOrigin + psb[2], c);
+				{
-				Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[2], shadowOrigin + psb[1], c);
+					shadowOrigin + psb[1],
+					shadowOrigin + psb[3],
+					shadowOrigin + psb[0],
+					shadowOrigin + psb[2]
+				}, iz, c);
 
 				// Draw voxel bounding box
 				var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
@@ -153,15 +157,16 @@ namespace OpenRA.Mods.Common.Graphics
 					wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz);
 					var pxPos = pxOrigin + new float2(sx, sy);
 					var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform);
-					DrawBoundsBox(pxPos, screenTransform, bounds, Color.Yellow);
+					DrawBoundsBox(pxPos, screenTransform, bounds, iz, Color.Yellow);
 				}
 			}
 
 			static readonly uint[] CornerXIndex = new uint[] { 0, 0, 0, 0, 3, 3, 3, 3 };
 			static readonly uint[] CornerYIndex = new uint[] { 1, 1, 4, 4, 1, 1, 4, 4 };
 			static readonly uint[] CornerZIndex = new uint[] { 2, 5, 2, 5, 2, 5, 2, 5 };
-			static void DrawBoundsBox(float2 pxPos, float[] transform, float[] bounds, Color c)
+			static void DrawBoundsBox(float2 pxPos, float[] transform, float[] bounds, float width, Color c)
 			{
+				var wcr = Game.Renderer.WorldRgbaColorRenderer;
 				var corners = new float2[8];
 				for (var i = 0; i < 8; i++)
 				{
@@ -170,20 +175,17 @@ namespace OpenRA.Mods.Common.Graphics
 					corners[i] = pxPos + new float2(screen[0], screen[1]);
 				}
 
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[0], corners[1], c);
+				// Front face
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[1], corners[3], c);
+				wcr.DrawPolygon(new[] { corners[0], corners[1], corners[3], corners[2] }, width, c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[3], corners[2], c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[2], corners[0], c);
 
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[4], corners[5], c);
+				// Back face
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[5], corners[7], c);
+				wcr.DrawPolygon(new[] { corners[4], corners[5], corners[7], corners[6] }, width, c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[7], corners[6], c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[6], corners[4], c);
 
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[0], corners[4], c);
+				// Horizontal edges
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[1], corners[5], c);
+				wcr.DrawLine(corners[0], corners[4], width, c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[2], corners[6], c);
+				wcr.DrawLine(corners[1], corners[5], width, c);
-				Game.Renderer.WorldLineRenderer.DrawLine(corners[3], corners[7], c);
+				wcr.DrawLine(corners[2], corners[6], width, c);
+				wcr.DrawLine(corners[3], corners[7], width, c);
 			}
 
 			public Rectangle ScreenBounds(WorldRenderer wr)

OpenRA.Mods.Common/Traits/CombatDebugOverlay.cs

@@ -52,7 +52,8 @@ namespace OpenRA.Mods.Common.Traits
 				RangeCircleRenderable.DrawRangeCircle(wr, self.CenterPosition, healthInfo.Radius,
 					1, Color.Red, 0, Color.Red);
 
-			var wlr = Game.Renderer.WorldLineRenderer;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
+			var iz = 1 / wr.Viewport.Zoom;
 
 			if (blockInfo != null)
 			{
@@ -60,9 +61,9 @@ namespace OpenRA.Mods.Common.Traits
 				var height = new WVec(0, 0, blockInfo.Height.Length);
 				var ha = wr.ScreenPosition(self.CenterPosition);
 				var hb = wr.ScreenPosition(self.CenterPosition + height);
-				wlr.DrawLine(ha, hb, hc);
+				wcr.DrawLine(ha, hb, iz, hc);
-				wr.DrawTargetMarker(hc, ha);
+				TargetLineRenderable.DrawTargetMarker(wr, hc, ha);
-				wr.DrawTargetMarker(hc, hb);
+				TargetLineRenderable.DrawTargetMarker(wr, hc, hb);
 			}
 
 			// No armaments to draw
@@ -85,8 +86,8 @@ namespace OpenRA.Mods.Common.Traits
 					var o = wr.ScreenPosition(pos);
 					var a = wr.ScreenPosition(pos + da * 224 / da.Length);
 					var b = wr.ScreenPosition(pos + db * 224 / db.Length);
-					wlr.DrawLine(o, a, c);
+					wcr.DrawLine(o, a, iz, c);
-					wlr.DrawLine(o, b, c);
+					wcr.DrawLine(o, b, iz, c);
 				}
 
 				return;
@@ -101,8 +102,8 @@ namespace OpenRA.Mods.Common.Traits
 
 					var sm = wr.ScreenPosition(muzzle);
 					var sd = wr.ScreenPosition(muzzle + dirOffset);
-					wlr.DrawLine(sm, sd, c);
+					wcr.DrawLine(sm, sd, iz, c);
-					wr.DrawTargetMarker(c, sm);
+					TargetLineRenderable.DrawTargetMarker(wr, c, sm);
 				}
 			}
 		}

OpenRA.Mods.Common/Traits/World/TerrainGeometryOverlay.cs

@@ -53,7 +53,7 @@ namespace OpenRA.Mods.Common.Traits
 
 			var map = wr.World.Map;
 			var tileSet = wr.World.TileSet;
-			var lr = Game.Renderer.WorldLineRenderer;
+			var wcr = Game.Renderer.WorldRgbaColorRenderer;
 			var colors = wr.World.TileSet.HeightDebugColors;
 			var mouseCell = wr.Viewport.ViewToWorld(Viewport.LastMousePos).ToMPos(wr.World.Map);
 
@@ -71,22 +71,18 @@ namespace OpenRA.Mods.Common.Traits
 				var color = corners.Select(c => colors[height + c.Z / 512]).ToArray();
 				var pos = map.CenterOfCell(uv.ToCPos(map));
 				var screen = corners.Select(c => wr.ScreenPxPosition(pos + c).ToFloat2()).ToArray();
+				var width = (uv == mouseCell ? 3 : 1) / wr.Viewport.Zoom;
 
-				if (uv == mouseCell)
+				// Colors change between points, so render separately
-					lr.LineWidth = 3;
-
 				for (var i = 0; i < 4; i++)
 				{
 					var j = (i + 1) % 4;
-					lr.DrawLine(screen[i], screen[j], color[i], color[j]);
+					wcr.DrawLine(screen[i], screen[j], width, color[i], color[j]);
 				}
-
-				lr.LineWidth = 1;
 			}
 
 			// Projected cell coordinates for the current cell
 			var projectedCorners = map.CellCorners[0];
-			lr.LineWidth = 3;
 			foreach (var puv in map.ProjectedCellsCovering(mouseCell))
 			{
 				var pos = map.CenterOfCell(((MPos)puv).ToCPos(map));
@@ -94,11 +90,9 @@ namespace OpenRA.Mods.Common.Traits
 				for (var i = 0; i < 4; i++)
 				{
 					var j = (i + 1) % 4;
-					lr.DrawLine(screen[i], screen[j], Color.Navy);
+					wcr.DrawLine(screen[i], screen[j], 3 / wr.Viewport.Zoom, Color.Navy);
 				}
 			}
-
-			lr.LineWidth = 1;
 		}
 	}
 }

OpenRA.Mods.Common/Traits/World/WeatherOverlay.cs

@@ -38,7 +38,7 @@ namespace OpenRA.Mods.Common.Traits
 		[Desc("Particles are drawn in squares when enabled, otherwise with lines.")]
 		public readonly bool UseSquares = true;
 
-		[Desc("Works only with squares enabled. Size min. and max. value in pixels.")]
+		[Desc("Size / width of the particle in px.")]
 		public readonly int[] ParticleSize = { 1, 3 };
 
 		[Desc("Scatters falling direction on the x-axis. Scatter min. and max. value in px/tick.")]
@@ -294,7 +294,7 @@ namespace OpenRA.Mods.Common.Traits
 				else
 				{
 					var tempPosTail = new float2(topLeft.X + item.PosX - currentWindXOffset, item.PosY - (item.Gravity * 2 / 3) + topLeft.Y);
-					Game.Renderer.WorldLineRenderer.DrawLine(tempPos, tempPosTail, item.Color, item.TailColor);
+					Game.Renderer.WorldRgbaColorRenderer.DrawLine(tempPos, tempPosTail, item.Size, item.TailColor);
 				}
 			}
 		}

OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs

@@ -2694,6 +2694,14 @@ namespace OpenRA.Mods.Common.UtilityCommands
 					}
 				}
 
+				// Added width support for line particles
+				if (engineVersion < 20151220 && node.Key == "WeatherOverlay")
+				{
+					var useSquares = node.Value.Nodes.FirstOrDefault(n => n.Key == "UseSquares");
+					if (useSquares != null && !FieldLoader.GetValue<bool>("UseSquares", useSquares.Value.Value))
+						node.Value.Nodes.Add(new MiniYamlNode("ParticleSize", "1, 1"));
+				}
+
 				UpgradeActorRules(engineVersion, ref node.Value.Nodes, node, depth + 1);
 			}
 		}

OpenRA.Mods.Common/Widgets/LineGraphWidget.cs

@@ -87,6 +87,7 @@ namespace OpenRA.Mods.Common.Widgets
 				|| GetAxisFont == null || GetAxisFont() == null)
 				return;
 
+			var cr = Game.Renderer.RgbaColorRenderer;
 			var rect = RenderBounds;
 			var origin = new float2(rect.Left, rect.Bottom);
 
@@ -120,13 +121,13 @@ namespace OpenRA.Mods.Common.Widgets
 					points = points.Reverse().Take(xAxisSize).Reverse();
 					var lastX = 0;
 					var lastPoint = 0f;
-					Game.Renderer.LineRenderer.DrawLineStrip(
+					cr.DrawLine(
 						points.Select((point, x) =>
 						{
 							lastX = x;
 							lastPoint = point;
 							return origin + new float2(x * xStep, -point * scale);
-						}), color);
+						}).ToArray(), 1, color);
 
 					if (lastPoint != 0f)
 						tiny.DrawText(GetValueFormat().F(lastPoint), origin + new float2(lastX * xStep, -lastPoint * scale - 2), color);
@@ -139,7 +140,7 @@ namespace OpenRA.Mods.Common.Widgets
 			// TODO: make this stuff not draw outside of the RenderBounds
 			for (int n = pointStart, x = 0; n <= pointEnd; n++, x += xStep)
 			{
-				Game.Renderer.LineRenderer.DrawLine(origin + new float2(x, 0), origin + new float2(x, -5), Color.White);
+				cr.DrawLine(origin + new float2(x, 0), origin + new float2(x, -5), 1, Color.White);
 				tiny.DrawText(GetXAxisValueFormat().F(n), origin + new float2(x, 2), Color.White);
 			}
 
@@ -148,16 +149,16 @@ namespace OpenRA.Mods.Common.Widgets
 			for (var y = GetDisplayFirstYAxisValue() ? 0 : yStep; y <= height; y += yStep)
 			{
 				var yValue = y / scale;
-				Game.Renderer.LineRenderer.DrawLine(origin + new float2(width - 5, -y), origin + new float2(width, -y), Color.White);
+				cr.DrawLine(origin + new float2(width - 5, -y), origin + new float2(width, -y), 1, Color.White);
 				tiny.DrawText(GetYAxisValueFormat().F(yValue), origin + new float2(width + 2, -y), Color.White);
 			}
 
 			bold.DrawText(GetYAxisLabel(), origin + new float2(width + 40, -(height / 2)), Color.White);
 
-			Game.Renderer.LineRenderer.DrawLine(origin, origin + new float2(width, 0), Color.White);
+			cr.DrawLine(origin, origin + new float2(width, 0), 1, Color.White);
-			Game.Renderer.LineRenderer.DrawLine(origin, origin + new float2(0, -height), Color.White);
+			cr.DrawLine(origin, origin + new float2(0, -height), 1, Color.White);
-			Game.Renderer.LineRenderer.DrawLine(origin + new float2(width, 0), origin + new float2(width, -height), Color.White);
+			cr.DrawLine(origin + new float2(width, 0), origin + new float2(width, -height), 1, Color.White);
-			Game.Renderer.LineRenderer.DrawLine(origin + new float2(0, -height), origin + new float2(width, -height), Color.White);
+			cr.DrawLine(origin + new float2(0, -height), origin + new float2(width, -height), 1, Color.White);
 		}
 
 		public override Widget Clone()

OpenRA.Mods.Common/Widgets/PerfGraphWidget.cs

@@ -19,30 +19,37 @@ namespace OpenRA.Mods.Common.Widgets
 	{
 		public override void Draw()
 		{
+			var cr = Game.Renderer.RgbaColorRenderer;
 			var rect = RenderBounds;
 			var origin = new float2(rect.Right, rect.Bottom);
 			var basis = new float2(-rect.Width / 100, -rect.Height / 100);
 
-			Game.Renderer.LineRenderer.DrawLine(origin, origin + new float2(100, 0) * basis, Color.White);
+			cr.DrawLine(new[]
-			Game.Renderer.LineRenderer.DrawLine(origin + new float2(100, 0) * basis, origin + new float2(100, 100) * basis, Color.White);
+			{
+				new float2(rect.Left, rect.Top),
+				new float2(rect.Left, rect.Bottom),
+				new float2(rect.Right, rect.Bottom)
+			}, 1, Color.White);
+
+			cr.DrawLine(origin + new float2(100, 0) * basis, origin + new float2(100, 100) * basis, 1, Color.White);
 
 			var k = 0;
 			foreach (var item in PerfHistory.Items.Values)
 			{
-				Game.Renderer.LineRenderer.DrawLineStrip(
+				cr.DrawLine(item.Samples()
-					item.Samples().Select((sample, i) => origin + new float2(i, (float)sample) * basis), item.C);
+					.Select((sample, i) => origin + new float2(i, (float)sample) * basis).ToArray(),
+					1, item.C);
 
 				var u = new float2(rect.Left, rect.Top);
 
-				Game.Renderer.LineRenderer.DrawLine(
+				cr.DrawLine(
 					u + new float2(10, 10 * k + 5),
 					u + new float2(12, 10 * k + 5),
-					item.C);
+					1, item.C);
-
+				cr.DrawLine(
-				Game.Renderer.LineRenderer.DrawLine(
 					u + new float2(10, 10 * k + 4),
 					u + new float2(12, 10 * k + 4),
-					item.C);
+					1, item.C);
 
 				++k;
 			}

OpenRA.Mods.Common/Widgets/RadarWidget.cs

@@ -307,7 +307,7 @@ namespace OpenRA.Mods.Common.Widgets
 
 				Game.Renderer.EnableScissor(mapRect);
 				DrawRadarPings();
-				Game.Renderer.LineRenderer.DrawRect(tl, br, Color.White);
+				Game.Renderer.RgbaColorRenderer.DrawRect(tl, br, 1, Color.White);
 				Game.Renderer.DisableScissor();
 			}
 		}
@@ -317,22 +317,15 @@ namespace OpenRA.Mods.Common.Widgets
 			if (radarPings == null)
 				return;
 
-			var lr = Game.Renderer.LineRenderer;
+			var cr = Game.Renderer.RgbaColorRenderer;
-			var oldWidth = lr.LineWidth;
-			lr.LineWidth = 2;
 
 			foreach (var radarPing in radarPings.Pings.Where(e => e.IsVisible()))
 			{
 				var c = radarPing.Color;
 				var pingCell = world.Map.CellContaining(radarPing.Position);
 				var points = radarPing.Points(CellToMinimapPixel(pingCell)).ToArray();
-
+				Game.Renderer.RgbaColorRenderer.DrawPolygon(points, 2, c);
-				lr.DrawLine(points[0], points[1], c);
-				lr.DrawLine(points[1], points[2], c);
-				lr.DrawLine(points[2], points[0], c);
 			}
-
-			lr.LineWidth = oldWidth;
 		}
 
 		public override void Tick()

OpenRA.Mods.Common/Widgets/ResourceBarWidget.cs

@@ -92,7 +92,7 @@ namespace OpenRA.Mods.Common.Widgets
 							top.Y -= 1;
 						}
 
-						Game.Renderer.LineRenderer.DrawLine(bottom, top, color);
+						Game.Renderer.RgbaColorRenderer.DrawLine(bottom, top, 1, color);
 					}
 				}
 				else
@@ -124,7 +124,7 @@ namespace OpenRA.Mods.Common.Widgets
 							right.X -= 1;
 						}
 
-						Game.Renderer.LineRenderer.DrawLine(left, right, color);
+						Game.Renderer.RgbaColorRenderer.DrawLine(left, right, 1, color);
 					}
 				}
 				else

mods/cnc/maps/gdi06/map.yaml

@@ -1055,7 +1055,6 @@ Rules:
 			WindTick: 150, 550
 			InstantWindChanges: false
 			UseSquares: false
-			ParticleSize: 0, 0
 			ScatterDirection: 0, 0
 			Gravity: 8.00, 12.00
 			SwingOffset: 0, 0
@@ -1063,6 +1062,7 @@ Rules:
 			SwingAmplitude: 0, 0
 			ParticleColors: 304074, 28386C, 202C60, 182C54
 			LineTailAlphaValue: 150
+			ParticleSize: 1, 1
 		GlobalLightingPaletteEffect:
 			Red: 0.75
 			Green: 0.85

mods/ra/maps/fort-lonestar/map.yaml

@@ -508,7 +508,6 @@ Rules:
 			WindTick: 150, 550
 			InstantWindChanges: false
 			UseSquares: false
-			ParticleSize: 0, 0
 			ScatterDirection: 0, 0
 			Gravity: 8.00, 12.00
 			SwingOffset: 0, 0
@@ -516,6 +515,7 @@ Rules:
 			SwingAmplitude: 0, 0
 			ParticleColors: 304074, 28386C, 202C60, 182C54
 			LineTailAlphaValue: 150
+			ParticleSize: 1, 1
 		GlobalLightingPaletteEffect:
 			Red: 0.75
 			Green: 0.85