public void Render(IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
var str = $"3-D View";
var size = im.CalcTextSize(FontType.Normal, str);
im.AddText(new Vector2(2, 2), Color.White, FontType.Normal, str);
im.AddRectFilled(Vector2.Zero, size + new Vector2(4, 4), Color.FromArgb(128, Color.Pink));
}
public void TestInitialize()
{
_mockRenderContext = new Mock <IRenderContext>(MockBehavior.Strict);
_mockFactory = new Mock <IFactory>(MockBehavior.Strict);
_mockVertexBuffer = new Mock <IVertexBuffer>(MockBehavior.Strict);
_mockIndexBuffer = new Mock <IIndexBuffer>(MockBehavior.Strict);
_mockVertexArray = new Mock <IVertexArray>(MockBehavior.Strict);
_mockShader = new Mock <IShader>(MockBehavior.Strict);
_target = new Renderer2D(_mockRenderContext.Object, _mockFactory.Object);
}
public void Render(IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
if (CursorVisible)
{
return;
}
if (Viewport.Viewport != viewport)
{
return;
}
var x = viewport.Width / 2;
var y = viewport.Height / 2;
const int size = 3;
im.AddRectFilled(new Vector2(x - 1, y - size - 1), new Vector2(x + 2, y + size + 2), Color.Black);
im.AddRectFilled(new Vector2(x - size - 1, y - 1), new Vector2(x + size + 2, y + 2), Color.Black);
im.AddLine(new Vector2(x, y - size), new Vector2(x, y + size + 1), Color.White, 1, false);
im.AddLine(new Vector2(x - size, y), new Vector2(x + size + 1, y), Color.White, 1, false);
}
protected override void Render(MapDocument document, IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
base.Render(document, viewport, camera, worldMin, worldMax, im);
if (_state != ClipState.None && _clipPlanePoint1 != null && _clipPlanePoint2 != null && _clipPlanePoint3 != null)
{
var p1 = _clipPlanePoint1.Value;
var p2 = _clipPlanePoint2.Value;
var p3 = _clipPlanePoint3.Value;
var points = new[] { p1, p2, p3 };
foreach (var p in points)
{
const int size = 4;
var spos = camera.WorldToScreen(p);
im.AddRectOutlineOpaque(new Vector2(spos.X - size, spos.Y - size), new Vector2(spos.X + size, spos.Y + size), Color.Black, Color.White);
}
}
}
protected override void Render(MapDocument document, IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
if (!document.Selection.IsEmpty)
{
switch (_mouseMovePoint == null ? CircleType.None : _mouseDown)
{
case CircleType.None:
RenderCircleTypeNone(camera, im);
break;
case CircleType.Outer:
case CircleType.X:
case CircleType.Y:
case CircleType.Z:
RenderAxisRotating(viewport, camera, im);
break;
}
}
base.Render(document, viewport, camera, im);
}
public void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var str = $"";
switch (camera.ViewType)
{
case OrthographicCamera.OrthographicType.Front:
str = $"2-D Side";
break;
case OrthographicCamera.OrthographicType.Side:
str = $"Gameplay View (Front)";
break;
case OrthographicCamera.OrthographicType.Top:
str = $"2-D Top";
break;
}
var size = im.CalcTextSize(FontType.Normal, str);
im.AddText(new Vector2(2, 2), Color.White, FontType.Normal, str);
im.AddRectFilled(Vector2.Zero, size + new Vector2(4, 4), Color.FromArgb(128, Color.Pink));
}
public void Render(IViewport viewport, ICollection <IMapObject> objects, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (camera.Zoom < 0.5f)
{
return;
}
foreach (var ed in objects.OfType <Entity>().Where(x => x.EntityData != null).Where(x => !x.Data.OfType <IObjectVisibility>().Any(v => v.IsHidden)))
{
var ang = ed.EntityData.GetVector3("angles");
if (!ang.HasValue)
{
continue;
}
var c = ed.Color?.Color ?? Color.White;
var angRad = ang.Value * (float)Math.PI / 180f;
var min = Math.Min(ed.BoundingBox.Width, Math.Min(ed.BoundingBox.Height, ed.BoundingBox.Length));
var tform = Matrix4x4.CreateFromYawPitchRoll(angRad.X, angRad.Z, angRad.Y);
var origin = ed.BoundingBox.Center;
var start = camera.WorldToScreen(origin).ToVector2();
var end = camera.WorldToScreen(origin + Vector3.Transform(Vector3.UnitX, tform) * 0.4f * min).ToVector2();
im.AddLine(start, end, c, 2);
}
}
protected virtual void DrawBoxText(IViewport viewport, OrthographicCamera camera, I2DRenderer im, Vector3 start, Vector3 end)
{
// Don't draw the text at all if the rectangle is entirely outside the viewport
if (start.X > camera.Width || end.X < 0)
{
return;
}
if (start.Y < 0 || end.Y > camera.Height)
{
return;
}
// Find the width and height for the given projection
var st = camera.Flatten(State.Start);
var en = camera.Flatten(State.End);
var widthText = (Math.Abs(Math.Round(en.X - st.X, 1))).ToString("0.##");
var heightText = (Math.Abs(Math.Round(en.Y - st.Y, 1))).ToString("0.##");
// Determine the size of the value strings
var mWidth = im.CalcTextSize(FontType.Large, widthText);
var mHeight = im.CalcTextSize(FontType.Large, heightText);
const int padding = 6;
// Ensure the text is clamped inside the viewport
var vWidth = new Vector3((end.X + start.X - mWidth.X) / 2, end.Y - mWidth.Y - padding, 0);
vWidth = Vector3.Clamp(vWidth, Vector3.Zero, new Vector3(camera.Width - mWidth.X - padding, camera.Height - mHeight.Y - padding, 0));
var vHeight = new Vector3(end.X + padding, (end.Y + start.Y - mHeight.Y) / 2, 0);
vHeight = Vector3.Clamp(vHeight, new Vector3(0, mWidth.Y + padding, 0), new Vector3(camera.Width - mWidth.X - padding, camera.Height - mHeight.Y - padding, 0));
// Draw the strings
im.AddText(vWidth.ToVector2(), GetRenderBoxColour(), FontType.Large, widthText);
im.AddText(vHeight.ToVector2(), GetRenderBoxColour(), FontType.Large, heightText);
}
public void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (!_overlays.Any())
{
return;
}
if (!_document.TryGetTarget(out var doc))
{
return;
}
// Determine which objects are visible
var padding = Vector3.One * 100;
var box = new Box(worldMin - padding, worldMax + padding);
var objects = doc.Map.Root.Find(x => x.BoundingBox.IntersectsWith(box)).ToList();
// Render the overlay for each object
foreach (var overlay in _overlays)
{
overlay.Value.Render(viewport, objects, camera, worldMin, worldMax, im);
}
}
public abstract void Render(IViewport viewport, PerspectiveCamera camera, I2DRenderer im);
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (ShouldDrawBox())
{
var start = camera.WorldToScreen(Vector3.Min(State.Start, State.End));
var end = camera.WorldToScreen(Vector3.Max(State.Start, State.End));
DrawBox(viewport, camera, im, start, end);
}
if (ShouldDrawBoxText())
{
var start = camera.WorldToScreen(Vector3.Min(State.Start, State.End));
var end = camera.WorldToScreen(Vector3.Max(State.Start, State.End));
DrawBoxText(viewport, camera, im, start, end);
}
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var(wpos, soff) = GetWorldPositionAndScreenOffset(camera);
var spos = camera.WorldToScreen(wpos) + soff;
const float radius = 4;
im.AddCircleFilled(spos.ToVector2(), radius, Color.White);
im.AddCircle(spos.ToVector2(), radius, Color.Black);
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (HighlightedViewport != viewport)
{
return;
}
var b = GetRectangle(camera);
var start = camera.WorldToScreen(camera.Expand(b.Start));
var end = camera.WorldToScreen(camera.Expand(b.End));
im.AddRectFilled(start.ToVector2(), end.ToVector2(), State.FillColour);
if (Handle == ResizeHandle.Center && SnappedMoveOrigin != null)
{
const int size = 4;
var orig = camera.WorldToScreen(camera.Expand(SnappedMoveOrigin.Value));
im.AddLine(new Vector2(orig.X - size, orig.Y - size), new Vector2(orig.X + size, orig.Y + size), Color.Yellow, 1, false);
im.AddLine(new Vector2(orig.X + size, orig.Y - size), new Vector2(orig.X - size, orig.Y + size), Color.Yellow, 1, false);
}
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var spos = camera.WorldToScreen(Position);
const int size = 4;
var col = Highlighted ? Color.Red : Color.Green;
im.AddRectOutlineOpaque(spos.ToVector2() - new Vector2(size, size), spos.ToVector2() + new Vector2(size, size), Color.Black, col);
}
protected override void Render(MapDocument document, IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
foreach (var obj in CollectObjects(x => new[] { x }).OrderByDescending(x => (x.Origin - camera.Position).LengthSquared()))
{
obj.Render(viewport, camera, im);
}
base.Render(document, viewport, camera, im);
}
protected override void Render(MapDocument document, IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
foreach (var obj in CollectObjects(x => new[] { x }).OrderBy(x => camera.GetUnusedValue(x.ZIndex)))
{
obj.Render(viewport, camera, worldMin, worldMax, im);
}
base.Render(document, viewport, camera, worldMin, worldMax, im);
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var spos = camera.WorldToScreen(Position);
const float inner = 4;
const float outer = 8;
var col = Highlighted ? Color.Red : Color.White;
im.AddCircle(spos.ToVector2(), inner, Color.Cyan);
im.AddCircle(spos.ToVector2(), outer, col);
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (State.State.Action != BoxAction.Drawn)
{
return;
}
var(wpos, soff) = GetWorldPositionAndScreenOffset(camera);
var spos = camera.WorldToScreen(wpos) + soff;
const int size = 4;
im.AddRectOutlineOpaque(new Vector2(spos.X - size, spos.Y - size), new Vector2(spos.X + size, spos.Y + size), Color.Black, Color.White);
}
public abstract void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im);
private void RenderAxisRotating(IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
if (ActiveViewport.Viewport != viewport || !_mouseDownPoint.HasValue || !_mouseMovePoint.HasValue)
{
return;
}
var st = camera.WorldToScreen(_pivotPoint);
var en = _mouseDownPoint.Value;
im.AddLine(st.ToVector2(), en.ToVector2(), Color.Gray);
en = _mouseMovePoint.Value;
im.AddLine(st.ToVector2(), en.ToVector2(), Color.LightGray);
}
public void Render(IViewport viewport, ICollection <IMapObject> objects, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
if (camera.Zoom < 1)
{
return;
}
// Escape hatch in case there's too many entities on screen
var ents = objects.OfType <Entity>().Where(x => x.EntityData != null).Where(x => !x.Data.OfType <IObjectVisibility>().Any(v => v.IsHidden)).ToList();
if (ents.Count <= 0 || ents.Count > 1000)
{
return;
}
var renderNames = camera.Zoom > 2 && ents.Count < 50;
foreach (var ed in ents)
{
var c = ed.Color?.Color ?? Color.White;
var loc = camera.WorldToScreen(ed.BoundingBox.Center);
var box = ed.BoundingBox;
var dim = camera.Flatten(box.Dimensions / 2);
loc.Y -= camera.UnitsToPixels(dim.Y);
var str = ed.EntityData.Name;
var targetname = ed.EntityData.Get <string>("targetname")?.Trim() ?? "";
var size = im.CalcTextSize(FontType.Normal, str);
var pos = new Vector2(loc.X - size.X / 2, loc.Y - size.Y - 2);
im.AddText(pos, c, FontType.Normal, str);
if (renderNames && targetname.Length > 0)
{
var nmms = im.CalcTextSize(FontType.Bold, targetname);
im.AddText(new Vector2(loc.X - nmms.X / 2, loc.Y + 2), c, FontType.Bold, targetname);
}
}
}
private void RenderCircleTypeNone(PerspectiveCamera camera, I2DRenderer im)
{
var center = _pivotPoint;
var origin = new Vector3(center.X, center.Y, center.Z);
var distance = (camera.EyeLocation - origin).Length();
if (distance <= 1)
{
return;
}
// Ensure points that can't be projected properly don't get rendered
var screenOrigin = camera.WorldToScreen(origin);
var sop = new PointF(screenOrigin.X, screenOrigin.Y);
var rec = new RectangleF(-200, -200, camera.Width + 400, camera.Height + 400);
if (!rec.Contains(sop))
{
return;
}
var radius = 0.15f * distance;
var normal = Vector3.Normalize(Vector3.Subtract(camera.EyeLocation, origin));
var right = Vector3.Normalize(Vector3.Cross(normal, Vector3.UnitZ));
var up = Vector3.Normalize(Vector3.Cross(normal, right));
const int sides = 32;
const float diff = (float)(2 * Math.PI) / sides;
for (var i = 0; i < sides; i++)
{
var cos1 = (float)Math.Cos(diff * i);
var sin1 = (float)Math.Sin(diff * i);
var cos2 = (float)Math.Cos(diff * (i + 1));
var sin2 = (float)Math.Sin(diff * (i + 1));
var line = new Line(
origin + right * cos1 * radius + up * sin1 * radius,
origin + right * cos2 * radius + up * sin2 * radius
);
var st = camera.WorldToScreen(line.Start);
var en = camera.WorldToScreen(line.End);
im.AddLine(st.ToVector2(), en.ToVector2(), Color.DarkGray);
line = new Line(
origin + right * cos1 * radius * 1.2f + up * sin1 * radius * 1.2f,
origin + right * cos2 * radius * 1.2f + up * sin2 * radius * 1.2f
);
st = camera.WorldToScreen(line.Start);
en = camera.WorldToScreen(line.End);
var c = _mouseOver == CircleType.Outer ? Color.White : Color.LightGray;
im.AddLine(st.ToVector2(), en.ToVector2(), c);
}
var plane = new Plane(normal, Vector3.Dot(origin, normal));
for (var i = 0; i < sides; i++)
{
var cos1 = (float)Math.Cos(diff * i) * radius;
var sin1 = (float)Math.Sin(diff * i) * radius;
var cos2 = (float)Math.Cos(diff * (i + 1)) * radius;
var sin2 = (float)Math.Sin(diff * (i + 1)) * radius;
RenderLine(
(origin + Vector3.UnitX * cos1 + Vector3.UnitY * sin1),
(origin + Vector3.UnitX * cos2 + Vector3.UnitY * sin2),
plane,
_mouseOver == CircleType.Z ? Color.Blue : Color.DarkBlue,
camera, im);
RenderLine(
(origin + Vector3.UnitY * cos1 + Vector3.UnitZ * sin1),
(origin + Vector3.UnitY * cos2 + Vector3.UnitZ * sin2),
plane,
_mouseOver == CircleType.X ? Color.Red : Color.DarkRed,
camera, im);
RenderLine(
(origin + Vector3.UnitZ * cos1 + Vector3.UnitX * sin1),
(origin + Vector3.UnitZ * cos2 + Vector3.UnitX * sin2),
plane,
_mouseOver == CircleType.Y ? Color.Lime : Color.LimeGreen,
camera, im);
}
}
protected virtual void DrawBox(IViewport viewport, OrthographicCamera camera, I2DRenderer im, Vector3 start, Vector3 end)
{
start = Vector3.Max(start, new Vector3(-100, -100, -100));
end = Vector3.Min(end, new Vector3(viewport.Width + 100, viewport.Height + 100, 100));
im.AddRectFilled(start.ToVector2(), end.ToVector2(), GetRenderFillColour());
im.AddRect(start.ToVector2(), end.ToVector2(), GetRenderBoxColour());
}
private void RenderLine(Vector3 start, Vector3 end, Plane plane, Color color, ICamera camera, I2DRenderer im)
{
var line = new Line(start, end);
var cls = line.ClassifyAgainstPlane(plane);
if (cls == PlaneClassification.Back)
{
return;
}
if (cls == PlaneClassification.Spanning)
{
var isect = plane.GetIntersectionPoint(line, true);
var first = plane.OnPlane(line.Start) > 0 ? line.Start : line.End;
if (!isect.HasValue)
{
return;
}
line = new Line(first, isect.Value);
}
var st = camera.WorldToScreen(line.Start);
var en = camera.WorldToScreen(line.End);
im.AddLine(st.ToVector2(), en.ToVector2(), color, 2);
}
public override void Render(IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
//
}
public void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var str = $"2D {camera.ViewType}";
var size = im.CalcTextSize(FontType.Normal, str);
im.AddText(new Vector2(2, 2), Color.White, FontType.Normal, str);
im.AddRectFilled(Vector2.Zero, size + new Vector2(4, 4), Color.FromArgb(128, Color.Pink));
}
public void Render(IViewport viewport, PerspectiveCamera camera, I2DRenderer im)
{
// 2D only
}
public Scene(I2DRenderer renderer, ITextRenderer textRenderer, IEntityContainer entityContainer)
{
_renderer = renderer;
_textRenderer = textRenderer;
EntityContainer = entityContainer;
}
protected override void Render(MapDocument document, IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
base.Render(document, viewport, camera, worldMin, worldMax, im);
foreach (var cam in GetCameraList(document))
{
var p1 = camera.WorldToScreen(cam.EyePosition);
var p2 = camera.WorldToScreen(cam.LookPosition);
var lineColor = cam.IsActive ? Color.Red : Color.Cyan;
var handleColor = cam.IsActive ? Color.DarkOrange : Color.LawnGreen;
im.AddLine(p1.ToVector2(), p2.ToVector2(), lineColor);
im.AddCircleFilled(p1.ToVector2(), 4, handleColor);
im.AddCircle(p1.ToVector2(), 4, Color.Black);
// todo post-beta: triangle arrow for cameras in 2D?
}
}
public override void Render(IViewport viewport, OrthographicCamera camera, Vector3 worldMin, Vector3 worldMax, I2DRenderer im)
{
var spos = camera.WorldToScreen(Position);
const int inner = 4;
const int outer = 8;
var col = Highlighted ? Color.DarkOrange : Color.LightBlue;
im.AddCircle(spos.ToVector2(), inner, Color.AliceBlue);
im.AddCircle(spos.ToVector2(), outer, col);
}
