public ConsoleRenderProgram(RenderThread renderer) : base(renderer)
{
Renderer.AutoEnableCaps = AutoEnableCapabilitiesFlags.Blend;
Glyphs = new CircularBuffer <RenderGlyph[]>(ConsoleSize.Height);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
DefaultBackColor = Color.Black;
DefaultForeColor = Color.LightGray;
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
DefaultBackColor = Color.White;
DefaultForeColor = Color.DarkSlateGray;
}
else
{
DefaultBackColor = Color.Black;
DefaultForeColor = Color.LightGreen;
}
BackColor = DefaultBackColor;
ForeColor = DefaultForeColor;
}
public void Start()
{
if (Running)
{
return;
}
Running = true;
ConfigManager.LoadConfigAsync().ContinueWith((Task loadTask) =>
{
Logger.Log("Config loaded successfully");
ConfigManager.SaveConfigAsync().ContinueWith((Task saveTask) => {
Logger.Log("Config saved");
});
WallpaperRenderer.Initialize();
ThreadManager.Run(InputThread = new InputThread(UpdateInput));
ThreadManager.Run(BrowserThread = new BrowserThread(BrowserInit));
ThreadManager.Run(WallpaperThread = new RenderThread(RenderInit));
ThreadManager.Run(ControllerThread = new ControllerThread(ControllerInit));
});
while (Running)
{
System.Threading.Thread.Sleep(1);
}
;
}
protected override void Renderer_ProcessingRawInput(RenderThread sender, FrameStageControllerEventArgs args)
{
if (Renderer.TargetWindow.KeyboardState.IsKeyDown(Key.Escape))
{
args.AbortExecution = true;
return;
}
}
override public void StopRendering()
{
if (RenderThread != null)
{
CancelRender = true;
RenderThread.Join();
}
}
public void UnhookRenderer()
{
if (RenderThread == null)
{
return;
}
RenderThread.Terminate();
RenderThread = null;
}
protected override void Renderer_DrawPrepare(RenderThread sender, FrameStageControllerEventArgs args)
{
CheckGlErrors("pre-program");
sender.SelectShader(glyphShader);
CheckGlErrors("post-program");
sender.SelectShader(glyphShader);
sender.SetUniform("resolution", 0, 0, sender.InternalResolution.Width, sender.InternalResolution.Height);
sender.SetUniform("atlasSize", fontAtlas.AtlasTextureSize.Width, fontAtlas.AtlasTextureSize.Height);
Gl.Uniform1(Gl.GetUniformLocation(glyphShader.ProgramId, "atlasTexture"), 0);
CheckGlErrors("post-uniforms");
}
public void KillRenderThread()
{
try
{
Pause = true;
RenderThread.Abort();
}
catch (Exception) { }
finally
{
RenderThread = null;
}
}
protected override void Renderer_ContextCreated(RenderThread sender, ContextCreationEventArgs args)
{
Log.WriteLine("Render context created. Continuing initialization...");
Log.WriteLine("Running on OpenGL: %@", LogLevel.Message, Gl.GetString(StringName.Renderer) + Gl.GetString(StringName.Version));
Renderer.TargetWindow.KeyDown += TargetWindow_KeyDown;
Renderer.TargetWindow.KeyUp += TargetWindow_KeyUp;
CompileShaders();
LoadTextures();
Gl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
VAO = Gl.GenVertexArray();
Gl.BindVertexArray(VAO);
CheckGlErrors("pre-texture");
Gl.ActiveTexture(TextureUnit.Texture0);
Gl.BindTexture(TextureTarget.Texture2D, fontAtlasTexture);
CheckGlErrors("post-texture");
VBO = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, VBO);
EBO = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, EBO);
CheckGlErrors("pre_va_pointer");
Gl.VertexAttribPointer(0, 2, VertexAttribPointerType.Float, false, 12 * sizeof(float), 0 * sizeof(float));
CheckGlErrors("post-va-pointer-0-set");
Gl.EnableVertexAttribArray(0);
CheckGlErrors("post-va-pointer-0-enable");
Gl.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 12 * sizeof(float), 2 * sizeof(float));
Gl.EnableVertexAttribArray(1);
CheckGlErrors("post-va-pointer-1");
Gl.VertexAttribPointer(2, 4, VertexAttribPointerType.Float, false, 12 * sizeof(float), 4 * sizeof(float));
Gl.EnableVertexAttribArray(2);
CheckGlErrors("post-va-pointer-2");
Gl.VertexAttribPointer(3, 4, VertexAttribPointerType.Float, false, 12 * sizeof(float), 8 * sizeof(float));
Gl.EnableVertexAttribArray(3);
}
public static void Main(string[] args)
{
Console.WriteLine("Starting..");
StreamCommunicatorThread dataSource = new StreamCommunicatorThread(500000);
dataSource.Start();
DataAnalysisThread worker = new DataAnalysisThread(dataSource);
worker.Start();
RenderThread renderTool = new RenderThread(worker);
renderTool.Start();
}
public void Init(LaunchState state, InitialiseSettings settings)
{
LaunchState = state;
Settings = settings;
ActiveWorld = new World();
Settings.Context.MakeCurrent(null);
SystemManager.LoadSystems(new CoreSystemLoader());
EntityManager.RegisterSystem(Renderer);
SystemManager.InitialiseSystems(EntityManager, EventManager, ResourceManager, ActiveWorld);
UpdateThread.Start();
RenderThread.Start();
}
public void Shutdown()
{
if (!Powered)
{
return;
}
if (RenderThread != null)
{
RenderThread.Terminate();
}
GPU.Terminate();
CPU.Terminate();
Powered = false;
}
protected override void Renderer_Draw(RenderThread sender, FrameStageEventArgs args)
{
Log.WriteLine("Renderer_Draw(%@)", LogLevel.Message, args.CurrentTime.FrameIndex);
Gl.BindVertexArray(VAO);
CheckGlErrors("Renderer_Draw:BindVAO");
Gl.ClearColor(0.2f, 0.3f, 0.3f, 1.0f);
Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
CheckGlErrors("Renderer_Draw:Clear");
Gl.UseProgram(shader.ProgramId);
CheckGlErrors("Renderer_Draw:UseProgram");
Gl.DrawElements(PrimitiveType.Triangles, 6, DrawElementsType.UnsignedInt, 0);
CheckGlErrors("Renderer_Draw:DrawElements");
}
public static int Main(string[] args)
{
Log.Initialize(false);
Log.Console.Enabled = true;
Log.Console.MinimumLevel = LogLevel.Debug;
Log.WriteLine("Console3D Test App");
Log.WriteLine("Running on %@ %@ (%@)",
LogLevel.Message,
GetPlatformName(),
RuntimeInformation.ProcessArchitecture,
RuntimeInformation.OSDescription);
Log.WriteLine();
Log.WriteLine("Checking custom fonts...");
CheckRasterFonts();
Log.WriteLine("Starting Render Thread...");
RenderThread renderThread = new RenderThread(new Size(960, 480), new Size(960, 480));
renderThread.Asynchronous = false;
renderThread.WindowTitle = "Console3D - OpenGL";
renderThread.Initialize();
KeyConverter.Default = new KeyConverter("en-US");
KeyConverter.Default.IgnoreLoadErrors = false;
using (FileStream fs = new FileStream("./res/layout_en-US.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
KeyConverter.Default.LoadLayout(fs);
ConsoleRenderProgram program;
program = new ConsoleRenderProgram(renderThread);
program.FontName = "Unifont";
program.KeyDown += Program_KeyDown;
Log.WriteLine("Starting render thread in %@ mode...",
LogLevel.Message,
renderThread.Asynchronous ? "Asynchronous" : "Synchronous");
RzSwLogAdapter adapter = new RzSwLogAdapter(program);
Log.AttachOutput(adapter);
program.Run();
// Main thread is free
while (restartGraphicsProgram && !renderThread.Asynchronous)
{
restartGraphicsProgram = false;
program.Stop();
program.Run();
}
while (renderThread.Asynchronous && !Console.KeyAvailable && renderThread.IsRunning)
{
if (!renderThread.AutoEventPolling)
{
renderThread.ProcessEvents();
if (renderThread.TimeSinceLastFrame > 1000)
{
int amount = (int)(renderThread.TimeSinceLastFrame / 2000.0f);
if (amount >= 3)
{
Thread.Sleep(amount);
}
}
}
else
{
Thread.Sleep(1000);
}
}
program.Stop();
Log.WriteLine("Render thread has been stopped.");
Log.WriteLine("Shutting down Render thread...");
program.Dispose();
return(0);
}
protected override void Renderer_Draw(RenderThread sender, FrameStageEventArgs args)
{
// Do nothing
}
public NullRenderProgram(RenderThread renderer) : base(renderer)
{
Renderer.AutoClearFrames = true;
Renderer.AutoEnableCaps = AutoEnableCapabilitiesFlags.None;
}
private void Form1_Load(object sender, EventArgs e)
{
#region StartupWindow
StartupForm StartForm = new StartupForm(Environment.GetCommandLineArgs());
StartForm.ShowDialog();
if (StartupForm.ApplicationTerminated)
{
this.Close();
Application.Exit();
return;
}
#endregion
#region WindowSettings
this.Size = new Size(StartupForm.W, StartupForm.H);
int WindowWidth = StartupForm.W - ClientSize.Width;
int WindowHeight = StartupForm.H - ClientSize.Height;
this.Size = new Size(StartupForm.W + WindowWidth, StartupForm.H + WindowHeight);
this.SetStyle(ControlStyles.StandardDoubleClick, false);
FBCaching = StartupForm.NormalsInterpolated;
this.MouseWheel += Form1_MouseWheel;
#endregion
#region FullscreenSettings
if (StartupForm.FullscreenSelected)
{
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
this.WindowState = FormWindowState.Maximized;
StartupForm.W = this.Width;
StartupForm.H = this.Height;
}
#endregion
#region VertexBufferInitialization
STLImporter Importer = new STLImporter(StartupForm.FilePath);
float[] vertexpoints = new float[Importer.AllTriangles.Length * 3 * 3];
float[] normalBuffer = new float[Importer.AllTriangles.Length * 3];
for (int i = 0; i < Importer.AllTriangles.Length; i++)
{
vertexpoints[i * 9] = Importer.AllTriangles[i].vertex1.x;
vertexpoints[i * 9 + 1] = Importer.AllTriangles[i].vertex1.y;
vertexpoints[i * 9 + 2] = Importer.AllTriangles[i].vertex1.z;
vertexpoints[i * 9 + 3] = Importer.AllTriangles[i].vertex2.x;
vertexpoints[i * 9 + 4] = Importer.AllTriangles[i].vertex2.y;
vertexpoints[i * 9 + 5] = Importer.AllTriangles[i].vertex2.z;
vertexpoints[i * 9 + 6] = Importer.AllTriangles[i].vertex3.x;
vertexpoints[i * 9 + 7] = Importer.AllTriangles[i].vertex3.y;
vertexpoints[i * 9 + 8] = Importer.AllTriangles[i].vertex3.z;
normalBuffer[i * 3] = Importer.AllTriangles[i].normals.x;
normalBuffer[i * 3 + 1] = Importer.AllTriangles[i].normals.y;
normalBuffer[i * 3 + 2] = Importer.AllTriangles[i].normals.z;
}
#endregion
ModelCenter = CalculateCenterOfModel(ref vertexpoints, out DistanceCenter);
// vertexpoints = STLImporter.AverageUpFaceNormalsAndOutputVertexBuffer(Importer.AllTriangles, 45);
NormalBuffer = new GLBuffer(normalBuffer, 3, MemoryLocation.Heap);
VertexBuffer = new GLBuffer(vertexpoints, 3, MemoryLocation.Heap);
NormalBuffer = new GLBuffer(renderX.PrimitiveTypes.CubeNormals(), 3, MemoryLocation.Heap);
VertexBuffer = new GLBuffer(renderX.PrimitiveTypes.Cube(), 5, MemoryLocation.Heap);
//GL._DebugBlit
StandardShader = new Shader(null, BasicShader, GLRenderMode.TriangleFlat);
//StandardShader.SetOverrideAttributeCopy(true);
// Skybox = new GLCubemap("skybox_data");
DisplayTexture = new Shader(CubeShader, TextureShader, GLRenderMode.Triangle);
// DisplayTexture.SetOverrideAttributeCopy(false);
// DisplayTexture.SetOverrideAttributeCount(3);
// GL.BlitInto
texture2d = new GLTexture("container2.png", MemoryLocation.Heap, DuringLoad.Flip);
TEXTURE_ADDR = (int *)texture2d.GetAddress();
textureHeight = texture2d.Height;
textureWidthMinusOne = texture2d.Width - 1;
textureHeightMinusOne = texture2d.Height - 1;
#region MemoryAddresses
nbAddr = (float *)NormalBuffer.GetAddress();
vertexpoints = null;
#endregion
#region CubeObject
CubeVBO = new GLBuffer(renderX.PrimitiveTypes.Cube(), 5, MemoryLocation.Heap);
cubeShader = new Shader(CubeVS, CubeFS, GLRenderMode.TriangleFlat);
cubeShader.SetOverrideAttributeCount(0);
#endregion
#region 3D_Grid
float[] vpoints = new float[] {
0, 0, 0, 9, 0, 0,
0, 0, 1, 9, 0, 1,
0, 0, 2, 9, 0, 2,
0, 0, 3, 9, 0, 3,
0, 0, 4, 9, 0, 4,
0, 0, 5, 9, 0, 5,
0, 0, 6, 9, 0, 6,
0, 0, 7, 9, 0, 7,
0, 0, 8, 9, 0, 8,
0, 0, 9, 9, 0, 9,
0, 0, 0, 0, 0, 9,
1, 0, 0, 1, 0, 9,
2, 0, 0, 2, 0, 9,
3, 0, 0, 3, 0, 9,
4, 0, 0, 4, 0, 9,
5, 0, 0, 5, 0, 9,
6, 0, 0, 6, 0, 9,
7, 0, 0, 7, 0, 9,
8, 0, 0, 8, 0, 9,
9, 0, 0, 9, 0, 9
};
LineBuffer = new GLBuffer(vpoints, 3, MemoryLocation.Heap);
LineShader = new Shader(GridShaderVS, GridShaderFS, GLRenderMode.Line, GLExtraAttributeData.XYZ_CameraSpace);
#endregion
#region CameraIndicator
CameraIndicator = new Shader(CIVS, null, GLRenderMode.TriangleGouraud);
CameraIndicator.SetOverrideCameraTransform(true);
CameraIndicator.SetOverrideAttributeCopy(true);
//Inner Part
CICVertex = new GLBuffer(renderX.PrimitiveTypes.CMI(), 3, MemoryLocation.Heap);
CICNormals = new GLBuffer(renderX.PrimitiveTypes.CMINormals(), 3, MemoryLocation.Heap);
//Outer Part
CIPVertex = new GLBuffer(renderX.PrimitiveTypes.CMS(), 3, MemoryLocation.Heap);
CIPNormals = new GLBuffer(renderX.PrimitiveTypes.CMSNormals(), 3, MemoryLocation.Heap);
CIC_Normals = (float *)CICNormals.GetAddress();
CIP_Normals = (float *)CIPNormals.GetAddress();
#endregion
#region Post-Processing
SSRShader = new Shader(null, SSR_Fragment, GLRenderMode.Triangle, GLExtraAttributeData.XYZ_XY_Both);
SSRShaderPost = new Shader(SSR_Pass);
#endregion
#region MiniGLIndicator
MiniGL = new renderX(130, 128);
MiniGL.SetMatrixData(90, 10);
MiniGL.SelectShader(CameraIndicator);
MiniGL.SetFaceCulling(true, false);
MiniGL.InitializeClickBuffer();
MiniGL.SetClickBufferWrite(true);
#endregion
#region renderX_Initialization
GL = new renderX(StartupForm.W, StartupForm.H, this.Handle);
GL.SelectBuffer(VertexBuffer);
GL.SelectShader(StandardShader);
GL.SetMatrixData(90, 10);
#endregion
#region GLSettings
cachedBuffer = new GLCachedBuffer(GL);
GL.SetWireFrameOFFSET(-0.1f);
GL.SetFaceCulling(true, false);
#endregion
// GL.SetLinkedWireframe(true, 255, 255, 255);
// GL.SetViewportScaling(1920, 1080, InterpolationMethod.NearestNeighbour);
GL.SetDebugWireFrameColor(255, 255, 255);
// GL.SetLineAntiAliasing(true);
GL.SetLineAntiAliasing(true);
GL.SetLineThickness(1);
// GL.SetLineThickness(3);
// GL.SetWireFrameOFFSET(-5000f);
// GL.SetLineAntiAliasing(true);
// GL.SetLinkedWireframe(true, 0, 0, 255);
GL.InitializeVignetteBuffer(VignetteShader);
// cameraPosition = new Vector3(-1.16f, 18f, -33.5f);
// cameraRotation = new Vector3(0,0,90);
cameraPosition = new Vector3(0, 0, -50);
cameraRotation = new Vector3(0, 0, 0);
#region RenderThreadStart
RT = new RenderThread(144);
RT.RenderFrame += RT_RenderFrame;
RT.Start();
#endregion
}
public IndexedQuadShaderRenderProgram(RenderThread renderer) : base(renderer)
{
Renderer.AutoClearFrames = false;
Renderer.AutoEnableCaps = AutoEnableCapabilitiesFlags.None;
Renderer.WireframeMode = true;
}
protected override void Renderer_DrawEnd(RenderThread sender, FrameStageEventArgs args)
{
}
protected override void Renderer_Draw(RenderThread sender, FrameStageEventArgs args)
{
if (!sender.IsMainThread() && !sender.Asynchronous)
{
throw new InvalidOperationException("Draw operation initiated from secondary thread when supposed to run in Sync mode.");
}
float cellX = sender.InternalResolution.Width / (float)ConsoleSize.Width;
float cellY = sender.InternalResolution.Height / (float)ConsoleSize.Height;
List <float> vertices = new List <float>(4096);
List <uint> indices = new List <uint>(4096);
float[] db = ColorToFloatArray(DefaultBackColor);
float[] df = ColorToFloatArray(DefaultForeColor);
int vertexCount = 0;
for (int xi = 0; xi < ConsoleSize.Width; xi++)
{
float x = xi * cellX;
for (int yi = 0; yi < ConsoleSize.Height; yi++)
{
RenderGlyph glyphData = GetGlyph(xi, yi);
if (ShowCursor && xi == Cursor.X && yi == Cursor.Y && glyphData == null)
{
int val = (int)((args.CurrentTime.TotalRuntime / 1000.0f) / BlinkInterval);
if (val % 2 == 0 || BlinkInterval == 0)
{
glyphData = new RenderGlyph('_');
}
}
float y = yi * cellY;
Rectangle texRec = Rectangle.Empty;
int glyphId = (int)(glyphData?.Glyph ?? ' ');
if (fontAtlas.ContainsId(glyphId))
{
texRec = fontAtlas.GetPointerById(glyphId).Bounds;
}
else if (fontAtlas.ContainsId(0x558))
{
texRec = fontAtlas.GetPointerById(0x558).Bounds;
}
else
{
texRec = fontAtlas.GetPointerById((int)'?').Bounds;
}
float[] b = glyphData == null || !glyphData.Background.HasValue ? db : ColorToFloatArray(glyphData.Background.Value);
float[] f = glyphData == null || !glyphData.Foreground.HasValue ? df : ColorToFloatArray(glyphData.Foreground.Value);
int qi = vertexCount;
vertices.AddRange(new float[] { // Add vertices
x, y, // 0,0 (A)
texRec.X, texRec.Y, // Texture X,Y
b[0], b[1], b[2], b[3], // Back
f[0], f[1], f[2], f[3], // Fore
x + cellX, y, // 1,0 (B)
texRec.Right, texRec.Y, // Texture X,Y
b[0], b[1], b[2], b[3], // Back
f[0], f[1], f[2], f[3], // Fore
x + cellX, y + cellY, // 1,1 (C)
texRec.Right, texRec.Bottom, // Texture X,Y
b[0], b[1], b[2], b[3], // Back
f[0], f[1], f[2], f[3], // Fore
x, y + cellY, //0,1 (D)
texRec.X, texRec.Bottom, // Texture X,Y
b[0], b[1], b[2], b[3], // Back
f[0], f[1], f[2], f[3], // Fore
});
indices.AddRange(new uint[]
{
(uint)(qi + 1), // B
(uint)(qi + 3), // D
(uint)(qi), // A
(uint)(qi + 1), // B
(uint)(qi + 2), // C
(uint)(qi + 3), // D
});
vertexCount += 4;
}
}
Gl.BindVertexArray(VAO);
Gl.BindBuffer(BufferTarget.ArrayBuffer, VBO);
float[] fvertices = vertices.ToArray();
vertices.Clear();
uint[] iindices = indices.ToArray();
indices.Clear();
CheckGlErrors("pre-vab");
GCHandle buffAddress = GCHandle.Alloc(fvertices, GCHandleType.Pinned);
Gl.BufferData(BufferTarget.ArrayBuffer, fvertices.Length * sizeof(float), buffAddress.AddrOfPinnedObject(), BufferUsageHint.StreamDraw);
buffAddress.Free();
CheckGlErrors("pre-eab");
buffAddress = GCHandle.Alloc(iindices, GCHandleType.Pinned);
Gl.BufferData(BufferTarget.ElementArrayBuffer, iindices.Length * sizeof(float), buffAddress.AddrOfPinnedObject(), BufferUsageHint.StreamDraw);
buffAddress.Free();
CheckGlErrors("predraw");
Gl.DrawElements(BeginMode.Triangles, iindices.Length, DrawElementsType.UnsignedInt, 0);
CheckGlErrors("final");
Gl.BindVertexArray(0);
CheckGlErrors("unbind");
}
protected override void Renderer_ContextCreated(RenderThread sender, ContextCreationEventArgs args)
{
Log.WriteLine("Context created. Using: " + Gl.GetString(StringName.Renderer) + Gl.GetString(StringName.Version));
Log.WriteLine("Renderer_ContextCreated");
Renderer.TargetWindow.Resize += TargetWindow_Resize;
// Load Shaders
string vertex = File.ReadAllText("./shaders/hello.vert".Replace('/', Path.DirectorySeparatorChar));
string fragment = File.ReadAllText("./shaders/hello.frag".Replace('/', Path.DirectorySeparatorChar));
// Compile shaders
Log.WriteLine("Compiling shader 'hello'...");
shader = new ShaderProgram(vertex, fragment);
shader.Compile();
Log.WriteLine("Compiled shader index: %@", LogLevel.Message, shader.ProgramId);
// Load vertices and indices
vertices = new float[] {
0.5f, 0.5f, 0.0f, // top right
0.5f, -0.5f, 0.0f, // bottom right
-0.5f, -0.5f, 0.0f, // bottom left
-0.5f, 0.5f, 0.0f // top left
};
indices = new uint[] { // note that we start from 0!
0, 1, 3, // first Triangle
1, 2, 3 // second Triangle
};
// Setup global VAO
VAO = Gl.GenVertexArray();
Gl.BindVertexArray(VAO);
CheckGlErrors("Renderer_ContextCreated:AfterVAO");
// Setup VBO (vertices)
VBO = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, VBO);
int size = (sizeof(float) * vertices.Length); // size must be 48
Gl.BufferData(BufferTarget.ArrayBuffer, size, vertices, BufferUsageHint.StaticDraw);
CheckGlErrors("Renderer_ContextCreated:AfterBufferDataVBO");
Gl.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), 0);
CheckGlErrors("Renderer_ContextCreated:AfterVAP_VBO");
Gl.EnableVertexAttribArray(0);
CheckGlErrors("Renderer_ContextCreated:AfterVBO");
// Setup EBO (indices)
EBO = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, EBO);
size = (sizeof(float) * indices.Length); // Must be 24
Gl.BufferData(BufferTarget.ElementArrayBuffer, size, indices, BufferUsageHint.StaticDraw);
CheckGlErrors("Renderer_ContextCreated:AfterEBO");
// Unbind
Gl.BindVertexArray(0);
CheckGlErrors("Renderer_ContextCreated:End");
}
// Render loop
private void Start()
{
_timer.Start();
RenderThread.Start(_token.Token);
}
public void Exit()
{
UpdateThread.Exit();
RenderThread.Exit();
SystemManager.ExitSystems();
}
