public void Initialize(AutoArray <GameLine> lines)
{
Clear();
ResourceSync initsync = new ResourceSync();
GenericVertex[] vertices = new GenericVertex[lines.Count * wellsize];
System.Threading.Tasks.Parallel.For(0, lines.Count, (idx) =>
{
var line = (StandardLine)lines[idx];
var well = GetWell(line);
for (int i = 0; i < wellsize; i++)
{
vertices[idx * wellsize + i] = well[i];
}
try
{
initsync.UnsafeEnterWrite();
_lines.Add(line.ID, idx * wellsize);
}
finally
{
initsync.UnsafeExitWrite();
}
});
_vertexcounter = vertices.Length;
_vbo.Bind();
EnsureVBOSize(vertices.Length, false);
_vbo.SetData(vertices, 0, 0, vertices.Length);
_vbo.Unbind();
}
public Dictionary <int, int> AddLines(AutoArray <GameLine> lines, LineVertex[] vertices)
{
Dictionary <int, int> ret = new Dictionary <int, int>(lines.Count);
int startidx = _indices.Count;
int startvert = _vertexcount;
_indices.EnsureCapacity(vertices.Length);
for (int ix = 0; ix < lines.Count; ix++)
{
var baseoffset = (ix * linesize);
for (int i = 0; i < linesize; i++)
{
_indices.Add(startvert + baseoffset + i);
}
ret.Add(lines[ix].ID, startidx + baseoffset);
}
_vbo.Bind();
EnsureVBOSize(_vertexcount + vertices.Length);
_vbo.SetData(vertices, 0, _vertexcount, vertices.Length);
_vbo.Unbind();
_vertexcount += vertices.Length;
_ibo.Bind();
EnsureIBOSize(_indices.Count + vertices.Length);
_ibo.SetData(_indices.unsafe_array, startidx, startidx, vertices.Length);
_ibo.Unbind();
return(ret);
}
public void Initialize(AutoArray <GameLine> lines)
{
var red = new List <RedLine>(lines.Count / 4);
foreach (var line in lines.unsafe_array)
{
if (line.Type == LineType.Red)
{
red.Add((RedLine)line);
}
}
_linecolorrenderer.Initialize(lines);
_lineaccelrenderer.Initialize(red);
_wellrenderer.Initialize(lines);
}
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();
}
public void Initialize(List <GameLine> lines)
{
Clear();
LineVertex[] vertices = new LineVertex[lines.Count * linesize];
var redverts = new AutoArray <GenericVertex>((lines.Count / 2) * 3);
System.Threading.Tasks.Parallel.For(0, lines.Count, (idx) =>
{
var line = (StandardLine)lines[idx];
var lineverts = CreateDecorationLine(line, line.Color);
for (int i = 0; i < lineverts.Length; i++)
{
vertices[idx * 6 + i] = lineverts[i];
}
});
var dict = _linebuffer.AddLines(lines, vertices);
_lines = dict;
}
/// <summary>
/// Clears the renderer and initializes it with new lines.
/// </summary>
public void InitializeTrack(Track track)
{
AutoArray <GameLine> scenery = new AutoArray <GameLine>(track.SceneryLines);
scenery.UnsafeSetCount(track.SceneryLines);
AutoArray <GameLine> phys = new AutoArray <GameLine>(track.BlueLines);
AutoArray <GameLine> accel = new AutoArray <GameLine>(track.RedLines);
var sorted = track.GetSortedLines();
using (_sync.AcquireWrite())
{
_lineactions.Clear();
_physvbo.Clear();
_sceneryvbo.Clear();
_accelvbo.Clear();
_bluedecorator.Clear();
_acceldecorator.Clear();
_physlines.Clear();
_scenerylines.Clear();
_accellines.Clear();
RequiresUpdate = true;
int scenerycount = 0;
for (int i = 0; i < sorted.Length; i++)
{
var line = sorted[i];
switch (line.Type)
{
case LineType.Scenery:
scenery.unsafe_array[scenery.Count - (1 + scenerycount++)] = line;
break;
case LineType.Blue:
phys.Add(line);
break;
case LineType.Red:
accel.Add(line);
break;
}
}
Debug.Assert(scenerycount == scenery.Count,
"Predicted scenery count was not accurate");
if (scenery.Count != 0)
{
LineVertex[] sceneryverts = new LineVertex[scenery.Count * linesize];
System.Threading.Tasks.Parallel.For(0, scenery.Count, (index) =>
{
int counter = 0;
var verts = (GenerateLine(scenery[index], false));
foreach (var vert in verts)
{
sceneryverts[index * linesize + counter++] = vert;
}
});
_scenerylines = _sceneryvbo.AddLines(
scenery,
sceneryverts);
}
if (phys.Count != 0)
{
LineVertex[] physverts = new LineVertex[phys.Count * linesize];
System.Threading.Tasks.Parallel.For(0, phys.Count, (index) =>
{
int counter = 0;
var verts = (GenerateLine(phys[index], false));
foreach (var vert in verts)
{
physverts[index * linesize + counter++] = vert;
}
});
_physlines = _physvbo.AddLines(
phys,
physverts);
_bluedecorator.Initialize(phys);
}
if (accel.Count != 0)
{
LineVertex[] accelverts = new LineVertex[accel.Count * linesize];
System.Threading.Tasks.Parallel.For(0, accel.Count, (index) =>
{
int counter = 0;
var verts = (GenerateLine(accel[index], false));
foreach (var vert in verts)
{
accelverts[index * linesize + counter++] = vert;
}
});
_accellines = _accelvbo.AddLines(
accel,
accelverts);
_acceldecorator.Initialize(accel);
}
RequiresUpdate = true;
}
}
