epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #11864 from pchote/line-depth

Browse Source 
Fix line rendering with depth buffer enabled.
This commit is contained in:
Oliver Brakmann
2016-08-27 17:57:30 +02:00
committed by GitHub
parent 7739e7c0e0 735a031d6e
commit 7fbe282167
24 changed files with 178 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
OpenRA.Game/Graphics/RgbaColorRenderer.cs
View File

@@ -47,15 +47,15 @@ namespace OpenRA.Graphics
}
}
public void DrawLine(float2 start, float2 end, float width, Color startColor, Color endColor)
public void DrawLine(float3 start, float3 end, float width, Color startColor, Color endColor)
{
renderer.CurrentBatchRenderer = this;
if (nv + 6 > renderer.TempBufferSize)
Flush();
var delta = (end - start) / (end - start).Length;
var corner = width / 2 * new float2(-delta.Y, delta.X);
var delta = (end - start) / (end - start).XY.Length;
var corner = width / 2 * new float3(-delta.Y, delta.X, delta.Z);
startColor = Util.PremultiplyAlpha(startColor);
var sr = startColor.R / 255.0f;
@@ -77,14 +77,14 @@ namespace OpenRA.Graphics
vertices[nv++] = new Vertex(start - corner + Offset, sr, sg, sb, sa, 0, 0);
}
public void DrawLine(float2 start, float2 end, float width, Color color)
public void DrawLine(float3 start, float3 end, float width, Color color)
{
renderer.CurrentBatchRenderer = this;
if (nv + 6 > renderer.TempBufferSize)
Flush();
var delta = (end - start) / (end - start).Length;
var delta = (end - start) / (end - start).XY.Length;
var corner = width / 2 * new float2(-delta.Y, delta.X);
color = Util.PremultiplyAlpha(color);
@@ -102,20 +102,21 @@ namespace OpenRA.Graphics
}
/// <summary>
/// Calculate the intersection of two lines.
/// Will behave badly if the lines are parallel
/// Calculate the 2D intersection of two lines.
/// Will behave badly if the lines are parallel.
/// Z position is the average of a and b (ignores actual intersection point if it exists)
/// </summary>
float2 IntersectionOf(float2 a, float2 da, float2 b, float2 db)
float3 IntersectionOf(float3 a, float3 da, float3 b, float3 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;
return new float3(x / d, y / d, 0.5f * (a.Z + b.Z));
}
void DrawDisconnectedLine(IEnumerable<float2> points, float width, Color color)
void DrawDisconnectedLine(IEnumerable<float3> points, float width, Color color)
{
using (var e = points.GetEnumerator())
{
@@ -132,7 +133,7 @@ namespace OpenRA.Graphics
}
}
void DrawConnectedLine(float2[] points, float width, Color color, bool closed)
void DrawConnectedLine(float3[] points, float width, Color color, bool closed)
{
// Not a line
if (points.Length < 2)
@@ -154,8 +155,8 @@ namespace OpenRA.Graphics
var start = points[0];
var end = points[1];
var dir = (end - start) / (end - start).Length;
var corner = width / 2 * new float2(-dir.Y, dir.X);
var dir = (end - start) / (end - start).XY.Length;
var corner = width / 2 * new float3(-dir.Y, dir.X, dir.Z);
// Corners for start of line segment
var ca = start - corner;
@@ -165,8 +166,8 @@ namespace OpenRA.Graphics
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);
var prevDir = (start - prev) / (start - prev).XY.Length;
var prevCorner = width / 2 * new float3(-prevDir.Y, prevDir.X, prevDir.Z);
ca = IntersectionOf(start - prevCorner, prevDir, start - corner, dir);
cb = IntersectionOf(start + prevCorner, prevDir, start + corner, dir);
}
@@ -175,8 +176,8 @@ namespace OpenRA.Graphics
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);
var nextDir = (next - end) / (next - end).XY.Length;
var nextCorner = width / 2 * new float3(-nextDir.Y, nextDir.X, nextDir.Z);
// Vertices for the corners joining start-end to end-next
var cc = closed || i < limit ? IntersectionOf(end + corner, dir, end + nextCorner, nextDir) : end + corner;
@@ -204,33 +205,43 @@ namespace OpenRA.Graphics
}
public void DrawLine(IEnumerable<float2> points, float width, Color color, bool connectSegments = false)
{
DrawLine(points.Select(p => new float3(p, 0)), width, color, connectSegments);
}
public void DrawLine(IEnumerable<float3> points, float width, Color color, bool connectSegments = false)
{
if (!connectSegments)
DrawDisconnectedLine(points, width, color);
else
DrawConnectedLine(points as float2[] ?? points.ToArray(), width, color, false);
DrawConnectedLine(points as float3[] ?? points.ToArray(), width, color, false);
}
public void DrawPolygon(float2[] vertices, float width, Color color)
public void DrawPolygon(float3[] vertices, float width, Color color)
{
DrawConnectedLine(vertices, width, color, true);
}
public void DrawRect(float2 tl, float2 br, float width, Color color)
public void DrawPolygon(float2[] vertices, float width, Color color)
{
var tr = new float2(br.X, tl.Y);
var bl = new float2(tl.X, br.Y);
DrawConnectedLine(vertices.Select(v => new float3(v, 0)).ToArray(), width, color, true);
}
public void DrawRect(float3 tl, float3 br, float width, Color color)
{
var tr = new float3(br.X, tl.Y, tl.Z);
var bl = new float3(tl.X, br.Y, br.Z);
DrawPolygon(new[] { tl, tr, br, bl }, width, color);
}
public void FillRect(float2 tl, float2 br, Color color)
public void FillRect(float3 tl, float3 br, Color color)
{
var tr = new float2(br.X, tl.Y);
var bl = new float2(tl.X, br.Y);
var tr = new float3(br.X, tl.Y, tl.Z);
var bl = new float3(tl.X, br.Y, br.Z);
FillRect(tl, tr, br, bl, color);
}
public void FillRect(float2 a, float2 b, float2 c, float2 d, Color color)
public void FillRect(float3 a, float3 b, float3 c, float3 d, Color color)
{
renderer.CurrentBatchRenderer = this;
@@ -251,25 +262,34 @@ namespace OpenRA.Graphics
vertices[nv++] = new Vertex(a + Offset, cr, cg, cb, ca, 0, 0);
}
public void FillEllipse(RectangleF r, Color color, int vertices = 32)
public void FillEllipse(float3 tl, float3 br, Color color, int vertices = 32)
{
// TODO: Create an ellipse polygon instead
var a = (r.Right - r.Left) / 2;
var b = (r.Bottom - r.Top) / 2;
var xc = (r.Right + r.Left) / 2;
var yc = (r.Bottom + r.Top) / 2;
for (var y = r.Top; y <= r.Bottom; y++)
var a = (br.X - tl.X) / 2;
var b = (br.Y - tl.Y) / 2;
var xc = (br.X + tl.X) / 2;
var yc = (br.Y + tl.Y) / 2;
for (var y = tl.Y; y <= br.Y; y++)
{
var z = float2.Lerp(tl.Z, br.Z, (y - tl.Y) / (br.Y - tl.Y));
var dx = a * (float)Math.Sqrt(1 - (y - yc) * (y - yc) / b / b);
DrawLine(new float2(xc - dx, y), new float2(xc + dx, y), 1, color);
DrawLine(new float3(xc - dx, y, z), new float3(xc + dx, y, z), 1, color);
}
}
public void SetViewportParams(Size screen, float zoom, int2 scroll)
public void SetViewportParams(Size screen, float depthScale, float depthOffset, 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);
shader.SetVec("Scroll", scroll.X, scroll.Y, scroll.Y);
shader.SetVec("r1",
zoom * 2f / screen.Width,
-zoom * 2f / screen.Height,
-depthScale * zoom / screen.Height);
shader.SetVec("r2", -1, 1, 1 - depthOffset);
}
public void SetDepthPreviewEnabled(bool enabled)
{
shader.SetBool("EnableDepthPreview", enabled);
}
}
}

25
OpenRA.Game/Graphics/SelectionBarsRenderable.cs
View File

@@ -48,21 +48,22 @@ namespace OpenRA.Graphics
public IRenderable OffsetBy(WVec vec) { return new SelectionBarsRenderable(pos + vec, actor); }
public IRenderable AsDecoration() { return this; }
void DrawExtraBars(WorldRenderer wr, float2 start, float2 end)
void DrawExtraBars(WorldRenderer wr, float3 start, float3 end)
{
foreach (var extraBar in actor.TraitsImplementing<ISelectionBar>())
{
var value = extraBar.GetValue();
if (value != 0 || extraBar.DisplayWhenEmpty)
{
start.Y += (int)(4 / wr.Viewport.Zoom);
end.Y += (int)(4 / wr.Viewport.Zoom);
var offset = new float3(0, (int)(4 / wr.Viewport.Zoom), 0);
start += offset;
end += offset;
DrawSelectionBar(wr, start, end, extraBar.GetValue(), extraBar.GetColor());
}
}
}
void DrawSelectionBar(WorldRenderer wr, float2 start, float2 end, float value, Color barColor)
void DrawSelectionBar(WorldRenderer wr, float3 start, float3 end, float value, Color barColor)
{
var iz = 1 / wr.Viewport.Zoom;
var c = Color.FromArgb(128, 30, 30, 30);
@@ -73,7 +74,7 @@ namespace OpenRA.Graphics
var barColor2 = Color.FromArgb(255, barColor.R / 2, barColor.G / 2, barColor.B / 2);
var z = float2.Lerp(start, end, value);
var z = float3.Lerp(start, end, value);
var wcr = Game.Renderer.WorldRgbaColorRenderer;
wcr.DrawLine(start + p, end + p, iz, c);
wcr.DrawLine(start + q, end + q, iz, c2);
@@ -93,7 +94,7 @@ namespace OpenRA.Graphics
health.DamageState == DamageState.Heavy ? Color.Yellow : Color.LimeGreen;
}
void DrawHealthBar(WorldRenderer wr, IHealth health, float2 start, float2 end)
void DrawHealthBar(WorldRenderer wr, IHealth health, float3 start, float3 end)
{
if (health == null || health.IsDead)
return;
@@ -112,7 +113,7 @@ namespace OpenRA.Graphics
healthColor.G / 2,
healthColor.B / 2);
var z = float2.Lerp(start, end, (float)health.HP / health.MaxHP);
var z = float3.Lerp(start, end, (float)health.HP / health.MaxHP);
var wcr = Game.Renderer.WorldRgbaColorRenderer;
wcr.DrawLine(start + p, end + p, iz, c);
@@ -131,7 +132,7 @@ namespace OpenRA.Graphics
deltaColor.R / 2,
deltaColor.G / 2,
deltaColor.B / 2);
var zz = float2.Lerp(start, end, (float)health.DisplayHP / health.MaxHP);
var zz = float3.Lerp(start, end, (float)health.DisplayHP / health.MaxHP);
wcr.DrawLine(z + p, zz + p, iz, deltaColor2);
wcr.DrawLine(z + q, zz + q, iz, deltaColor);
@@ -147,12 +148,12 @@ namespace OpenRA.Graphics
var health = actor.TraitOrDefault<IHealth>();
var screenPos = wr.ScreenPxPosition(pos);
var screenPos = wr.Screen3DPxPosition(pos);
var bounds = actor.VisualBounds;
bounds.Offset(screenPos.X, screenPos.Y);
bounds.Offset((int)screenPos.X, (int)screenPos.Y);
var start = new float2(bounds.Left + 1, bounds.Top);
var end = new float2(bounds.Right - 1, bounds.Top);
var start = new float3(bounds.Left + 1, bounds.Top, screenPos.Z);
var end = new float3(bounds.Right - 1, bounds.Top, screenPos.Z);
if (DisplayHealth)
DrawHealthBar(wr, health, start, end);

8
OpenRA.Game/Graphics/SpriteRenderable.cs
View File

@@ -65,14 +65,14 @@ namespace OpenRA.Graphics
public void RenderDebugGeometry(WorldRenderer wr)
{
var offset = ScreenPosition(wr) + sprite.Offset.XY;
Game.Renderer.WorldRgbaColorRenderer.DrawRect(offset.XY, (offset + sprite.Size).XY, 1 / wr.Viewport.Zoom, Color.Red);
var screenOffset = ScreenPosition(wr) + sprite.Offset;
Game.Renderer.WorldRgbaColorRenderer.DrawRect(screenOffset, screenOffset + sprite.Size, 1 / wr.Viewport.Zoom, Color.Red);
}
public Rectangle ScreenBounds(WorldRenderer wr)
{
var offset = ScreenPosition(wr) + sprite.Offset;
return new Rectangle((int)offset.X, (int)offset.Y, (int)sprite.Size.X, (int)sprite.Size.Y);
var screenOffset = ScreenPosition(wr) + sprite.Offset;
return new Rectangle((int)screenOffset.X, (int)screenOffset.Y, (int)sprite.Size.X, (int)sprite.Size.Y);
}
}
}

6
OpenRA.Game/Graphics/TargetLineRenderable.cs
View File

@@ -43,9 +43,9 @@ namespace OpenRA.Graphics
return;
var iz = 1 / wr.Viewport.Zoom;
var first = wr.ScreenPxPosition(waypoints.First());
var first = wr.Screen3DPosition(waypoints.First());
var a = first;
foreach (var b in waypoints.Skip(1).Select(pos => wr.ScreenPxPosition(pos)))
foreach (var b in waypoints.Skip(1).Select(pos => wr.Screen3DPosition(pos)))
{
Game.Renderer.WorldRgbaColorRenderer.DrawLine(a, b, iz, color);
DrawTargetMarker(wr, color, b);
@@ -55,7 +55,7 @@ namespace OpenRA.Graphics
DrawTargetMarker(wr, color, first);
}
public static void DrawTargetMarker(WorldRenderer wr, Color color, float2 location)
public static void DrawTargetMarker(WorldRenderer wr, Color color, float3 location)
{
var iz = 1 / wr.Viewport.Zoom;
var offset = new float2(iz, iz);

38
OpenRA.Game/Graphics/WorldRenderer.cs
View File

@@ -127,6 +127,7 @@ namespace OpenRA.Graphics
{
Game.Renderer.WorldSpriteRenderer.SetDepthPreviewEnabled(devTrait.Value.ShowDepthPreview);
Game.Renderer.WorldRgbaSpriteRenderer.SetDepthPreviewEnabled(devTrait.Value.ShowDepthPreview);
Game.Renderer.WorldRgbaColorRenderer.SetDepthPreviewEnabled(devTrait.Value.ShowDepthPreview);
}
RefreshPalette();
@@ -162,10 +163,6 @@ namespace OpenRA.Graphics
foreach (var a in World.ActorsWithTrait<IRenderShroud>())
a.Trait.RenderShroud(renderShroud, this);
if (devTrait.Value != null && devTrait.Value.ShowDebugGeometry)
for (var i = 0; i < renderables.Count; i++)
renderables[i].RenderDebugGeometry(this);
if (enableDepthBuffer)
Game.Renderer.Device.DisableDepthBuffer();
@@ -200,9 +197,14 @@ namespace OpenRA.Graphics
r.Render(this);
if (devTrait.Value != null && devTrait.Value.ShowDebugGeometry)
{
for (var i = 0; i < renderables.Count; i++)
renderables[i].RenderDebugGeometry(this);
foreach (var g in finalOverlayRenderables.GroupBy(prs => prs.GetType()))
foreach (var r in g)
r.RenderDebugGeometry(this);
}
Game.Renderer.Flush();
}
@@ -232,28 +234,34 @@ namespace OpenRA.Graphics
return new int2((int)Math.Round(px.X), (int)Math.Round(px.Y));
}
// For scaling vectors to pixel sizes in the voxel renderer
public void ScreenVectorComponents(WVec vec, out float x, out float y, out float z)
public float3 Screen3DPxPosition(WPos pos)
{
x = TileSize.Width * vec.X / 1024f;
y = TileSize.Height * (vec.Y - vec.Z) / 1024f;
z = TileSize.Height * vec.Z / 1024f;
// Round to nearest pixel
var px = Screen3DPosition(pos);
return new float3((float)Math.Round(px.X), (float)Math.Round(px.Y), px.Z);
}
// For scaling vectors to pixel sizes in the voxel renderer
public float3 ScreenVectorComponents(WVec vec)
{
return new float3(
TileSize.Width * vec.X / 1024f,
TileSize.Height * (vec.Y - vec.Z) / 1024f,
TileSize.Height * vec.Z / 1024f);
}
// For scaling vectors to pixel sizes in the voxel renderer
public float[] ScreenVector(WVec vec)
{
float x, y, z;
ScreenVectorComponents(vec, out x, out y, out z);
return new[] { x, y, z, 1f };
var xyz = ScreenVectorComponents(vec);
return new[] { xyz.X, xyz.Y, xyz.Z, 1f };
}
public int2 ScreenPxOffset(WVec vec)
{
// Round to nearest pixel
float x, y, z;
ScreenVectorComponents(vec, out x, out y, out z);
return new int2((int)Math.Round(x), (int)Math.Round(y));
var xyz = ScreenVectorComponents(vec);
return new int2((int)Math.Round(xyz.X), (int)Math.Round(xyz.Y));
}
public float ScreenZPosition(WPos pos, int offset)

8
OpenRA.Game/Primitives/float3.cs
View File

@@ -37,6 +37,14 @@ namespace OpenRA
public static float3 operator /(float3 a, float3 b) { return new float3(a.X / b.X, a.Y / b.Y, a.Z / b.Z); }
public static float3 operator /(float3 a, float b) { return new float3(a.X / b, a.Y / b, a.Z / b); }
public static float3 Lerp(float3 a, float3 b, float t)
{
return new float3(
float2.Lerp(a.X, b.X, t),
float2.Lerp(a.Y, b.Y, t),
float2.Lerp(a.Z, b.Z, t));
}
public static bool operator ==(float3 me, float3 other) { return me.X == other.X && me.Y == other.Y && me.Z == other.Z; }
public static bool operator !=(float3 me, float3 other) { return !(me == other); }
public override int GetHashCode() { return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode(); }

4
OpenRA.Game/Renderer.cs
View File

@@ -119,7 +119,7 @@ namespace OpenRA
lastResolution = Resolution;
RgbaSpriteRenderer.SetViewportParams(Resolution, 0f, 0f, 1f, int2.Zero);
SpriteRenderer.SetViewportParams(Resolution, 0f, 0f, 1f, int2.Zero);
RgbaColorRenderer.SetViewportParams(Resolution, 1f, int2.Zero);
RgbaColorRenderer.SetViewportParams(Resolution, 0f, 0f, 1f, int2.Zero);
}
// If zoom evaluates as different due to floating point weirdness that's OK, setting the parameters again is harmless.
@@ -130,7 +130,7 @@ namespace OpenRA
WorldRgbaSpriteRenderer.SetViewportParams(Resolution, depthScale, depthOffset, zoom, scroll);
WorldSpriteRenderer.SetViewportParams(Resolution, depthScale, depthOffset, zoom, scroll);
WorldVoxelRenderer.SetViewportParams(Resolution, zoom, scroll);
WorldRgbaColorRenderer.SetViewportParams(Resolution, zoom, scroll);
WorldRgbaColorRenderer.SetViewportParams(Resolution, depthScale, depthOffset, zoom, scroll);
}
}

4
OpenRA.Game/Widgets/WidgetUtils.cs
View File

@@ -70,7 +70,9 @@ namespace OpenRA.Widgets
public static void FillEllipseWithColor(Rectangle r, Color c)
{
Game.Renderer.RgbaColorRenderer.FillEllipse(new RectangleF(r.X, r.Y, r.Width, r.Height), c);
var tl = new float2(r.Left, r.Top);
var br = new float2(r.Right, r.Bottom);
Game.Renderer.RgbaColorRenderer.FillEllipse(tl, br, c);
}
public static int[] GetBorderSizes(string collection)

12
OpenRA.Mods.Common/Graphics/BeamRenderable.cs
View File

@@ -55,16 +55,16 @@ namespace OpenRA.Mods.Common.Graphics
{
var delta = length * width.Length / (2 * vecLength);
var corner = new WVec(-delta.Y, delta.X, delta.Z);
var a = wr.ScreenPosition(pos - corner);
var b = wr.ScreenPosition(pos + corner);
var c = wr.ScreenPosition(pos + corner + length);
var d = wr.ScreenPosition(pos - corner + length);
var a = wr.Screen3DPosition(pos - corner);
var b = wr.Screen3DPosition(pos + corner);
var c = wr.Screen3DPosition(pos + corner + length);
var d = wr.Screen3DPosition(pos - corner + length);
Game.Renderer.WorldRgbaColorRenderer.FillRect(a, b, c, d, color);
}
else
{
var start = wr.ScreenPosition(pos);
var end = wr.ScreenPosition(pos + length);
var start = wr.Screen3DPosition(pos);
var end = wr.Screen3DPosition(pos + length);
var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0];
Game.Renderer.WorldRgbaColorRenderer.DrawLine(start, end, screenWidth, color);
}

2
OpenRA.Mods.Common/Graphics/ContrailRenderable.cs
View File

@@ -75,7 +75,7 @@ namespace OpenRA.Mods.Common.Graphics
var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent);
if (!world.FogObscures(curPos) && !world.FogObscures(nextPos))
wcr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), screenWidth, curColor, nextColor);
wcr.DrawLine(wr.Screen3DPosition(curPos), wr.Screen3DPosition(nextPos), screenWidth, curColor, nextColor);
curPos = nextPos;
curColor = nextColor;

4
OpenRA.Mods.Common/Graphics/DetectionCircleRenderable.cs
View File

@@ -67,13 +67,13 @@ namespace OpenRA.Mods.Common.Graphics
public void Render(WorldRenderer wr)
{
var wcr = Game.Renderer.WorldRgbaColorRenderer;
var center = wr.ScreenPosition(centerPosition);
var center = wr.Screen3DPosition(centerPosition);
for (var i = 0; i < trailCount; i++)
{
var angle = trailAngle - new WAngle(i * (trailSeparation.Angle <= 512 ? 1 : -1));
var length = radius.Length * new WVec(angle.Cos(), angle.Sin(), 0) / 1024;
var end = wr.ScreenPosition(centerPosition + length);
var end = wr.Screen3DPosition(centerPosition + length);
var alpha = color.A - i * color.A / trailCount;
wcr.DrawLine(center, end, 3, Color.FromArgb(alpha, contrastColor));

4
OpenRA.Mods.Common/Graphics/RangeCircleRenderable.cs
View File

@@ -58,8 +58,8 @@ namespace OpenRA.Mods.Common.Graphics
var offset = new WVec(radius.Length, 0, 0);
for (var i = 0; i < RangeCircleSegments; i++)
{
var a = wr.ScreenPosition(centerPosition + offset.Rotate(RangeCircleStartRotations[i]));
var b = wr.ScreenPosition(centerPosition + offset.Rotate(RangeCircleEndRotations[i]));
var a = wr.Screen3DPosition(centerPosition + offset.Rotate(RangeCircleStartRotations[i]));
var b = wr.Screen3DPosition(centerPosition + offset.Rotate(RangeCircleEndRotations[i]));
if (contrastWidth > 0)
wcr.DrawLine(a, b, contrastWidth / wr.Viewport.Zoom, contrastColor);

6
OpenRA.Mods.Common/Graphics/SelectionBoxRenderable.cs
View File

@@ -45,11 +45,11 @@ namespace OpenRA.Mods.Common.Graphics
public void Render(WorldRenderer wr)
{
var iz = 1 / wr.Viewport.Zoom;
var screenPos = wr.ScreenPxPosition(pos);
var screenPos = wr.Screen3DPxPosition(pos);
var tl = screenPos + new float2(visualBounds.Left, visualBounds.Top);
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 tr = new float3(br.X, tl.Y, screenPos.Z);
var bl = new float3(tl.X, br.Y, screenPos.Z);
var u = new float2(4 * iz, 0);
var v = new float2(0, 4 * iz);

2
OpenRA.Mods.Common/Graphics/TextRenderable.cs
View File

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

25
OpenRA.Mods.Common/Graphics/VoxelRenderable.cs
View File

@@ -129,7 +129,7 @@ namespace OpenRA.Mods.Common.Graphics
{
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 pxOrigin = wr.Screen3DPosition(voxel.pos);
var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1));
var iz = 1 / wr.Viewport.Zoom;
@@ -141,13 +141,12 @@ namespace OpenRA.Mods.Common.Graphics
var c = Color.Purple;
var psb = renderProxy.ProjectedShadowBounds;
// TODO: add float3 support to WorldRgbaColorRenderer
Game.Renderer.WorldRgbaColorRenderer.DrawPolygon(new[]
{
shadowOrigin + psb[1].XY,
shadowOrigin + psb[3].XY,
shadowOrigin + psb[0].XY,
shadowOrigin + psb[2].XY
shadowOrigin + psb[1],
shadowOrigin + psb[3],
shadowOrigin + psb[0],
shadowOrigin + psb[2]
}, iz, c);
// Draw voxel bounding box
@@ -161,9 +160,7 @@ namespace OpenRA.Mods.Common.Graphics
var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform,
(x, y) => OpenRA.Graphics.Util.MatrixMultiply(x, OpenRA.Graphics.Util.MakeFloatMatrix(y.AsMatrix())));
float sx, sy, sz;
wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz);
var pxPos = pxOrigin + new float2(sx, sy);
var pxPos = pxOrigin + wr.ScreenVectorComponents(v.OffsetFunc());
var screenTransform = OpenRA.Graphics.Util.MatrixMultiply(cameraTransform, worldTransform);
DrawBoundsBox(pxPos, screenTransform, bounds, iz, Color.Yellow);
}
@@ -172,15 +169,15 @@ namespace OpenRA.Mods.Common.Graphics
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, float width, Color c)
static void DrawBoundsBox(float3 pxPos, float[] transform, float[] bounds, float width, Color c)
{
var wcr = Game.Renderer.WorldRgbaColorRenderer;
var corners = new float2[8];
var corners = new float3[8];
for (var i = 0; i < 8; i++)
{
var vec = new float[] { bounds[CornerXIndex[i]], bounds[CornerYIndex[i]], bounds[CornerZIndex[i]], 1 };
var screen = OpenRA.Graphics.Util.MatrixVectorMultiply(transform, vec);
corners[i] = pxPos + new float2(screen[0], screen[1]);
corners[i] = pxPos + new float3(screen[0], screen[1], screen[2]);
}
// Front face
@@ -221,9 +218,7 @@ namespace OpenRA.Mods.Common.Graphics
var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform,
(x, y) => OpenRA.Graphics.Util.MatrixMultiply(x, OpenRA.Graphics.Util.MakeFloatMatrix(y.AsMatrix())));
float sx, sy, sz;
wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz);
var pxPos = pxOrigin + new float3(sx, sy, sz);
var pxPos = pxOrigin + wr.ScreenVectorComponents(v.OffsetFunc());
var screenTransform = OpenRA.Graphics.Util.MatrixMultiply(cameraTransform, worldTransform);
for (var i = 0; i < 8; i++)

8
OpenRA.Mods.Common/HitShapes/Capsule.cs
View File

@@ -112,13 +112,13 @@ namespace OpenRA.Mods.Common.HitShapes
var c = Color.Yellow;
RangeCircleRenderable.DrawRangeCircle(wr, a, Radius, 1, c, 0, c);
RangeCircleRenderable.DrawRangeCircle(wr, b, Radius, 1, c, 0, c);
wcr.DrawLine(new[] { wr.ScreenPosition(a - offset1), wr.ScreenPosition(b - offset1) }, 1, c);
wcr.DrawLine(new[] { wr.ScreenPosition(a + offset1), wr.ScreenPosition(b + offset1) }, 1, c);
wcr.DrawLine(new[] { wr.Screen3DPosition(a - offset1), wr.Screen3DPosition(b - offset1) }, 1, c);
wcr.DrawLine(new[] { wr.Screen3DPosition(a + offset1), wr.Screen3DPosition(b + offset1) }, 1, c);
RangeCircleRenderable.DrawRangeCircle(wr, aa, Radius, 1, c, 0, c);
RangeCircleRenderable.DrawRangeCircle(wr, bb, Radius, 1, c, 0, c);
wcr.DrawLine(new[] { wr.ScreenPosition(aa - offset2), wr.ScreenPosition(bb - offset2) }, 1, c);
wcr.DrawLine(new[] { wr.ScreenPosition(aa + offset2), wr.ScreenPosition(bb + offset2) }, 1, c);
wcr.DrawLine(new[] { wr.Screen3DPosition(aa - offset2), wr.Screen3DPosition(bb - offset2) }, 1, c);
wcr.DrawLine(new[] { wr.Screen3DPosition(aa + offset2), wr.Screen3DPosition(bb + offset2) }, 1, c);
}
}
}

8
OpenRA.Mods.Common/HitShapes/Rectangle.cs
View File

@@ -129,16 +129,16 @@ namespace OpenRA.Mods.Common.HitShapes
var positions = targetablePositions.SelectMany(tp => tp.TargetablePositions(actor));
foreach (var pos in positions)
{
var vertsTop = combatOverlayVertsTop.Select(v => wr.ScreenPosition(pos + v.Rotate(orientation)));
var vertsBottom = combatOverlayVertsBottom.Select(v => wr.ScreenPosition(pos + v.Rotate(orientation)));
var vertsTop = combatOverlayVertsTop.Select(v => wr.Screen3DPosition(pos + v.Rotate(orientation)));
var vertsBottom = combatOverlayVertsBottom.Select(v => wr.Screen3DPosition(pos + v.Rotate(orientation)));
wcr.DrawPolygon(vertsTop.ToArray(), 1, Color.Yellow);
wcr.DrawPolygon(vertsBottom.ToArray(), 1, Color.Yellow);
}
}
else
{
var vertsTop = combatOverlayVertsTop.Select(v => wr.ScreenPosition(actorPos + v.Rotate(orientation)));
var vertsBottom = combatOverlayVertsBottom.Select(v => wr.ScreenPosition(actorPos + v.Rotate(orientation)));
var vertsTop = combatOverlayVertsTop.Select(v => wr.Screen3DPosition(actorPos + v.Rotate(orientation)));
var vertsBottom = combatOverlayVertsBottom.Select(v => wr.Screen3DPosition(actorPos + v.Rotate(orientation)));
wcr.DrawPolygon(vertsTop.ToArray(), 1, Color.Yellow);
wcr.DrawPolygon(vertsBottom.ToArray(), 1, Color.Yellow);
}

14
OpenRA.Mods.Common/Traits/CombatDebugOverlay.cs
View File

@@ -63,8 +63,8 @@ namespace OpenRA.Mods.Common.Traits
{
var hc = Color.Orange;
var height = new WVec(0, 0, blockers.Max(b => b.BlockingHeight.Length));
var ha = wr.ScreenPosition(self.CenterPosition);
var hb = wr.ScreenPosition(self.CenterPosition + height);
var ha = wr.Screen3DPosition(self.CenterPosition);
var hb = wr.Screen3DPosition(self.CenterPosition + height);
wcr.DrawLine(ha, hb, iz, hc);
TargetLineRenderable.DrawTargetMarker(wr, hc, ha);
TargetLineRenderable.DrawTargetMarker(wr, hc, hb);
@@ -89,9 +89,9 @@ namespace OpenRA.Mods.Common.Traits
var da = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw + p.Cone)).Rotate(bodyOrientation));
var db = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw - p.Cone)).Rotate(bodyOrientation));
var o = wr.ScreenPosition(pos);
var a = wr.ScreenPosition(pos + da * 224 / da.Length);
var b = wr.ScreenPosition(pos + db * 224 / db.Length);
var o = wr.Screen3DPosition(pos);
var a = wr.Screen3DPosition(pos + da * 224 / da.Length);
var b = wr.Screen3DPosition(pos + db * 224 / db.Length);
wcr.DrawLine(o, a, iz, c);
wcr.DrawLine(o, b, iz, c);
}
@@ -106,8 +106,8 @@ namespace OpenRA.Mods.Common.Traits
var muzzle = self.CenterPosition + a.MuzzleOffset(self, b);
var dirOffset = new WVec(0, -224, 0).Rotate(a.MuzzleOrientation(self, b));
var sm = wr.ScreenPosition(muzzle);
var sd = wr.ScreenPosition(muzzle + dirOffset);
var sm = wr.Screen3DPosition(muzzle);
var sd = wr.Screen3DPosition(muzzle + dirOffset);
wcr.DrawLine(sm, sd, iz, c);
TargetLineRenderable.DrawTargetMarker(wr, c, sm);
}

2
OpenRA.Mods.Common/Traits/ExitsDebugOverlay.cs
View File

@@ -97,7 +97,7 @@ namespace OpenRA.Mods.Common.Traits
continue;
var exitCellCenter = self.World.Map.CenterOfCell(exitCells[i]);
rgbaRenderer.DrawLine(wr.ScreenPosition(spawnPos), wr.ScreenPosition(exitCellCenter), 1f, self.Owner.Color.RGB);
rgbaRenderer.DrawLine(wr.Screen3DPosition(spawnPos), wr.Screen3DPosition(exitCellCenter), 1f, self.Owner.Color.RGB);
}
}
}

4
OpenRA.Mods.Common/Traits/World/TerrainGeometryOverlay.cs
View File

@@ -69,7 +69,7 @@ namespace OpenRA.Mods.Common.Traits
var corners = map.Grid.CellCorners[ramp];
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 screen = corners.Select(c => wr.Screen3DPxPosition(pos + c)).ToArray();
var width = (uv == mouseCell ? 3 : 1) / wr.Viewport.Zoom;
// Colors change between points, so render separately
@@ -85,7 +85,7 @@ namespace OpenRA.Mods.Common.Traits
foreach (var puv in map.ProjectedCellsCovering(mouseCell))
{
var pos = map.CenterOfCell(((MPos)puv).ToCPos(map));
var screen = projectedCorners.Select(c => wr.ScreenPxPosition(pos + c - new WVec(0, 0, pos.Z)).ToFloat2()).ToArray();
var screen = projectedCorners.Select(c => wr.Screen3DPxPosition(pos + c - new WVec(0, 0, pos.Z))).ToArray();
for (var i = 0; i < 4; i++)
{
var j = (i + 1) % 4;

7
OpenRA.Mods.Common/Traits/World/WarheadDebugOverlay.cs
View File

@@ -73,11 +73,10 @@ namespace OpenRA.Mods.Common.Traits
foreach (var r in i.Range)
{
var tl = wr.ScreenPosition(i.CenterPosition - new WVec(r.Length, r.Length, 0));
var br = wr.ScreenPosition(i.CenterPosition + new WVec(r.Length, r.Length, 0));
var rect = RectangleF.FromLTRB(tl.X, tl.Y, br.X, br.Y);
var tl = wr.Screen3DPosition(i.CenterPosition - new WVec(r.Length, r.Length, 0));
var br = wr.Screen3DPosition(i.CenterPosition + new WVec(r.Length, r.Length, 0));
Game.Renderer.WorldRgbaColorRenderer.FillEllipse(rect, Color.FromArgb((int)alpha, i.Color));
Game.Renderer.WorldRgbaColorRenderer.FillEllipse(tl, br, Color.FromArgb((int)alpha, i.Color));
alpha -= rangeStep;
}

4
OpenRA.Mods.Common/Widgets/WorldInteractionControllerWidget.cs
View File

@@ -54,7 +54,9 @@ namespace OpenRA.Mods.Common.Widgets
if (IsValidDragbox)
{
// Render actors in the dragbox
Game.Renderer.WorldRgbaColorRenderer.DrawRect(dragStart, mousePos,
var a = new float3(dragStart.X, dragStart.Y, dragStart.Y);
var b = new float3(mousePos.X, mousePos.Y, mousePos.Y);
Game.Renderer.WorldRgbaColorRenderer.DrawRect(a, b,
1 / worldRenderer.Viewport.Zoom, Color.White);
foreach (var u in SelectActorsInBoxWithDeadzone(World, dragStart, mousePos))
DrawRollover(u);

14
glsl/color.frag
View File

@@ -1,6 +1,18 @@
varying vec4 vColor;
uniform bool EnableDepthPreview;
void main()
{
gl_FragColor = vColor;
float depth = gl_FragCoord.z;
// Convert to window coords
gl_FragDepth = 0.5 * depth + 0.5;
if (EnableDepthPreview)
{
// Front of the depth buffer is at 0, but we want to render it as bright
gl_FragColor = vec4(vec3(1.0 - gl_FragDepth), 1.0);
}
else
gl_FragColor = vColor;
}

7
glsl/color.vert
View File

@@ -1,5 +1,5 @@
uniform vec2 Scroll;
uniform vec2 r1, r2;
uniform vec3 Scroll;
uniform vec3 r1, r2;
attribute vec4 aVertexPosition;
attribute vec4 aVertexTexCoord;
@@ -7,7 +7,6 @@ varying vec4 vColor;
void main()
{
vec2 p = (aVertexPosition.xy - Scroll.xy)*r1 + r2;
gl_Position = vec4(p.x,p.y,0,1);
gl_Position = vec4((aVertexPosition.xyz - Scroll.xyz) * r1 + r2, 1);
vColor = aVertexTexCoord;
}