public static void RenderRoundedRectangle(DoubleRect rect, Color color, float thickness, bool gamecoords = true)
{
using (new GLEnableCap(EnableCap.Blend))
{
using (new GLEnableCap(EnableCap.Texture2D))
{
if (gamecoords)
{
GameDrawingMatrix.Enter();
}
var vao = GetLineVAO();
vao.Scale = GameDrawingMatrix.Scale;
var vec1 = rect.Vector;
var vec2 = vec1 + new Vector2d(rect.Width, 0);
var vec3 = vec1 + rect.Size;
var vec4 = vec1 + new Vector2d(0, rect.Height);
vao.AddLine(vec1, vec2, color, thickness);
vao.AddLine(vec2, vec3, color, thickness);
vao.AddLine(vec3, vec4, color, thickness);
vao.AddLine(vec4, vec1, color, thickness);
vao.knobstate = 0;
vao.Draw(PrimitiveType.Triangles);
if (gamecoords)
{
GameDrawingMatrix.Exit();
}
}
}
}
private void DrawTexture(
Tex tex,
DoubleRect rect,
FloatRect uv,
Vector2d origin,
Vector2d rotationAnchor,
float opacity,
bool pretty = false
)
{
var angle = Angle.FromLine(origin, rotationAnchor);
var t = Utility.RotateRect(rect, Vector2d.Zero, angle);
var transform = new Vector2d[] {
(t[0] + origin), // 0 tl
(t[1] + origin), // 1 tr
(t[2] + origin), // 2 br
(t[3] + origin), // 3 bl
};
var texrect = GameDrawingMatrix.ScreenCoords(transform);
var color = Color.FromArgb((int)(255f * opacity), Color.White);
Color[] colors = new Color[] { color, color, color, color };
if (pretty)
{
var random = new Random((Environment.TickCount / 100) % 255);
for (int i = 0; i < colors.Length; i++)
{
bool redness = random.Next() % 2 == 0;
bool blueness = random.Next() % 2 == 0;
var random1 = Math.Max(200, random.Next() % 255);
int red = Math.Min(255, redness ? (random1 * 2) : (random1 / 2));
int green = Math.Min(255, (blueness && redness) ? (random1) : (random1 / 2));
int blue = Math.Min(255, blueness ? (random1 * 2) : (random1 / 2));
colors[i] = Color.FromArgb((int)(255f * opacity), red, green, blue);
}
}
var u1 = uv.Left;
var v1 = uv.Top;
var u2 = uv.Right;
var v2 = uv.Bottom;
var verts = new RiderVertex[] {
new RiderVertex(texrect[0], new Vector2(uv.Left, uv.Top), tex, colors[0]),
new RiderVertex(texrect[1], new Vector2(uv.Right, uv.Top), tex, colors[1]),
new RiderVertex(texrect[2], new Vector2(uv.Right, uv.Bottom), tex, colors[2]),
new RiderVertex(texrect[3], new Vector2(uv.Left, uv.Bottom), tex, colors[3])
};
Array.Add(verts[0]);
Array.Add(verts[1]);
Array.Add(verts[2]);
Array.Add(verts[3]);
Array.Add(verts[2]);
Array.Add(verts[0]);
}
public void Render(DrawOptions options, bool recording = false)
{
using (new GLEnableCap(EnableCap.Texture2D))
{
UpdateBuffers();
GL.BlendFunc(
BlendingFactorSrc.SrcAlpha,
BlendingFactorDest.OneMinusSrcAlpha);
GameDrawingMatrix.Enter();
_physvbo.Scale = options.Zoom;
_physvbo.KnobState = options.KnobState;
_sceneryvbo.Scale = options.Zoom;
//green lines dont get lifelock
if (options.KnobState != KnobState.Hidden)
{
_sceneryvbo.KnobState = KnobState.Shown;
}
else
{
_sceneryvbo.KnobState = KnobState.Hidden;
}
if ((Settings.PreviewMode || recording) && !(recording && !Settings.Recording.EnableColorTriggers))
{
_sceneryvbo.OverrideColor = game.Track.Timeline.GetFrameLineColor(game.Track.Offset);
_physvbo.OverrideColor = game.Track.Timeline.GetFrameLineColor(game.Track.Offset);
}
else
{
_sceneryvbo.OverrideColor = (Settings.NightMode ? Constants.DefaultNightLineColor : Constants.DefaultLineColor);
_physvbo.OverrideColor = (Settings.NightMode ? Constants.DefaultNightLineColor : Constants.DefaultLineColor);
}
if (options.LineColors)
{
_sceneryvbo.OverrideColor = Constants.SceneryLineColor;
_sceneryvbo.OverridePriority = 1;
_physvbo.OverridePriority = 1;
}
else
{
_sceneryvbo.OverridePriority = 255;//force override
_physvbo.OverridePriority = 255;
}
_physvbo.Overlay = options.Overlay;
_sceneryvbo.Overlay = options.Overlay;
_sceneryvbo.Draw();
_decorator.DrawUnder(options);
_physvbo.Draw();
GameDrawingMatrix.Exit();
}
}
public void Render(DrawOptions options)
{
using (new GLEnableCap(EnableCap.Texture2D))
{
UpdateBuffers();
GL.BlendFunc(
BlendingFactorSrc.SrcAlpha,
BlendingFactorDest.OneMinusSrcAlpha);
GameDrawingMatrix.Enter();
_physvbo.Scale = options.Zoom;
_physvbo.KnobState = options.KnobState;
_sceneryvbo.Scale = options.Zoom;
//green lines dont get lifelock
if (options.KnobState != KnobState.Hidden)
{
_sceneryvbo.KnobState = KnobState.Shown;
}
else
{
_sceneryvbo.KnobState = KnobState.Hidden;
}
if (options.NightMode)
{
_sceneryvbo.OverrideColor = Constants.DefaultNightLineColor;
_physvbo.OverrideColor = Constants.DefaultNightLineColor;
}
else
{
_sceneryvbo.OverrideColor = Constants.DefaultLineColor;
_physvbo.OverrideColor = Constants.DefaultLineColor;
}
if (options.LineColors)
{
_sceneryvbo.OverrideColor = Constants.SceneryLineColor;
_sceneryvbo.OverridePriority = 1;
_physvbo.OverridePriority = 1;
}
else
{
_sceneryvbo.OverridePriority = 255;//force override
_physvbo.OverridePriority = 255;
}
_physvbo.Overlay = options.Overlay;
_sceneryvbo.Overlay = options.Overlay;
_sceneryvbo.Draw();
_decorator.DrawUnder(options);
_physvbo.Draw();
GameDrawingMatrix.Exit();
}
}
private static void RenderPointOutline(List <Vector2d> points, Color color)
{
GameDrawingMatrix.Enter();
GL.Begin(PrimitiveType.LineStrip);
for (int i = 0; i < points.Count; i++)
{
Color col = (i < 1 || i == points.Count - 1) ? color : Color.FromArgb(255, 200, 0);
GL.Color3(col);
GL.Vertex2(points[i]);
}
GL.End();
GameDrawingMatrix.Exit();
}
private static void DrawCircle(Vector2d point, float size, Color color)
{
GameDrawingMatrix.Enter();
var center = (Vector2)point;
var circ = StaticRenderer.GenerateCircle(center.X, center.Y, size, 360);
GL.Begin(PrimitiveType.LineStrip);
GL.Color3(color);
for (int i = 0; i < circ.Length; i++)
{
GL.Vertex2((Vector2)circ[i]);
}
GL.End();
GameDrawingMatrix.Exit();
}
public static void RenderRoundedLine(Vector2d position, Vector2d position2, Color color, float thickness, bool knobs = false, bool redknobs = false)
{
using (new GLEnableCap(EnableCap.Blend))
{
using (new GLEnableCap(EnableCap.Texture2D))
{
GameDrawingMatrix.Enter();
var vao = GetLineVAO();
vao.Scale = GameDrawingMatrix.Scale;
vao.AddLine(position, position2, color, thickness);
vao.knobstate = knobs ? (redknobs ? 2 : 1) : 0;
vao.Draw(PrimitiveType.Triangles);
GameDrawingMatrix.Exit();
}
}
}
public static void DrawBezierCurve(Vector2[] points, Color color, int resolution)
{
Vector2[] curvePoints = GenerateBezierCurve(points, resolution);
if (points.Length > 0)
{
GameDrawingMatrix.Enter();
GL.Begin(PrimitiveType.LineStrip);
GL.Color3(color);
for (int i = 0; i < curvePoints.Length; i++)
{
GL.Vertex2(curvePoints[i]);
}
GL.End();
GameDrawingMatrix.Exit();
}
}
public static void DrawTrackLine(StandardLine line, Color color, bool drawwell, bool drawcolor)
{
var lv = new AutoArray <LineVertex>(24);
var verts = new AutoArray <GenericVertex>(30);
if (drawcolor)
{
if (line is RedLine redline)
{
verts.AddRange(LineAccelRenderer.GetAccelDecor(redline));
}
lv.AddRange(LineColorRenderer.CreateDecorationLine(line, line.Color));
}
lv.AddRange(
LineRenderer.CreateTrackLine(
line.Start,
line.End,
line.Width * 2,
Utility.ColorToRGBA_LE(color)));
if (drawwell)
{
verts.AddRange(WellRenderer.GetWell(line));
}
var vao = GetLineVAO();
vao.Scale = Game.Track.Zoom;
foreach (var v in lv.unsafe_array)
{
vao.AddVertex(v);
}
GameDrawingMatrix.Enter();
using (new GLEnableCap(EnableCap.Blend))
{
if (verts.Count != 0)
{
GenericVAO gvao = new GenericVAO();
foreach (var v in verts.unsafe_array)
{
gvao.AddVertex(v);
}
gvao.Draw(PrimitiveType.Triangles);
}
vao.Draw(PrimitiveType.Triangles);
}
GameDrawingMatrix.Exit();
}
private Vector2[] DrawLine(Vector2d p1, Vector2d p2, int color, float size)
{
var calc = Utility.GetThickLine(p1, p2, Angle.FromLine(p1, p2), size);
var t = GameDrawingMatrix.ScreenCoords(calc);
var verts = new RiderVertex[] {
RiderVertex.NoTexture(t[0],color),
RiderVertex.NoTexture(t[1],color),
RiderVertex.NoTexture(t[2],color),
RiderVertex.NoTexture(t[3],color)
};
Array.Add(verts[0]);
Array.Add(verts[1]);
Array.Add(verts[2]);
Array.Add(verts[3]);
Array.Add(verts[2]);
Array.Add(verts[0]);
return t;
}
public void DrawMomentum(Rider rider, float opacity)
{
var color = Constants.MomentumVectorColor;
color = ChangeOpacity(color, opacity);
for (int i = 0; i < rider.Body.Length; i++)
{
var anchor = rider.Body[i];
var vec1 = anchor.Location;
var vec2 = vec1 + (anchor.Momentum);
var line = Line.FromAngle(
vec1,
Angle.FromVector(anchor.Momentum),
2);
_momentumvao.AddLine(
GameDrawingMatrix.ScreenCoordD(line.Position),
GameDrawingMatrix.ScreenCoordD(line.Position2),
color,
GameDrawingMatrix.Scale / 2.5f);
}
}
private static void renderPointTrace(List <Vector2d> points, BezierCurve curve, Color color)
{
double lineLength = 0;
List <double> lengthsPerPoint = new List <double> {
0
};
for (int i = 1; i < points.Count; i++)
{
lineLength += Distance(points[i - 1], points[i]);
lengthsPerPoint.Add(lineLength);
}
for (int i = 1; i < points.Count - 1; i++)
{
Vector2 curvePoint = curve.CalculatePoint((float)lengthsPerPoint[i] / (float)lineLength);
GameDrawingMatrix.Enter();
GL.Begin(PrimitiveType.LineStrip);
GL.Color3(color);
GL.Vertex2(points[i]);
GL.Vertex2(curvePoint);
GL.End();
GameDrawingMatrix.Exit();
}
}
public void DrawContacts(Rider rider, List <int> diagnosis, float opacity)
{
if (diagnosis == null)
{
diagnosis = new List <int>();
}
var bones = RiderConstants.Bones;
for (var i = 0; i < bones.Length; i++)
{
var constraintcolor = bones[i].OnlyRepel
? Constants.ConstraintRepelColor
: Constants.ConstraintColor;
constraintcolor = ChangeOpacity(constraintcolor, opacity);
if (bones[i].Breakable)
{
continue;
}
else if (bones[i].OnlyRepel)
{
_lines.AddLine(
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[i].joint1].Location),
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[i].joint2].Location),
constraintcolor,
GameDrawingMatrix.Scale / 4);
}
else if (i <= 3)
{
_lines.AddLine(
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[i].joint1].Location),
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[i].joint2].Location),
constraintcolor,
GameDrawingMatrix.Scale / 4);
}
}
if (!rider.Crashed && diagnosis.Count != 0)
{
Color firstbreakcolor = Constants.ConstraintFirstBreakColor;
Color breakcolor = Constants.ConstraintBreakColor;
breakcolor = ChangeOpacity(breakcolor, opacity / 2);
firstbreakcolor = ChangeOpacity(firstbreakcolor, opacity);
for (int i = 1; i < diagnosis.Count; i++)
{
var broken = diagnosis[i];
if (broken >= 0)
{
_lines.AddLine(
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[broken].joint1].Location),
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[broken].joint2].Location),
breakcolor,
GameDrawingMatrix.Scale / 4);
}
}
//the first break is most important so we give it a better color, assuming its not just a fakie death
if (diagnosis[0] > 0)
{
_lines.AddLine(
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[diagnosis[0]].joint1].Location),
GameDrawingMatrix.ScreenCoordD(rider.Body[bones[diagnosis[0]].joint2].Location),
firstbreakcolor,
GameDrawingMatrix.Scale / 4);
}
}
for (var i = 0; i < rider.Body.Length; i++)
{
Color c = Constants.ContactPointColor;
if (
((i == RiderConstants.SledTL || i == RiderConstants.SledBL) && diagnosis.Contains(-1)) ||
((i == RiderConstants.BodyButt || i == RiderConstants.BodyShoulder) && diagnosis.Contains(-2)))
{
c = Constants.ContactPointFakieColor;
}
c = ChangeOpacity(c, opacity);
_lines.AddLine(
GameDrawingMatrix.ScreenCoordD(rider.Body[i].Location),
GameDrawingMatrix.ScreenCoordD(rider.Body[i].Location),
c,
GameDrawingMatrix.Scale / 4);
}
}
