public ForwardRenderPipeline()
{
framebuffer_color = Ogl.GenFramebuffer("Forward Color");
Ogl.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer_color);
Ogl.DrawBuffer(DrawBufferMode.ColorAttachment0);
Ogl.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
}
internal void UpdateTexturesOfCurrentModel(Dictionary <Material, Image> snapshot)
{
void updateTextures(Renderer rndr)
{
foreach (var kvp in snapshot)
{
if (kvp.Value != kvp.Key.Image)
{
rndr.UpdateTexture(kvp.Value, kvp.Key.Image);
}
}
}
if (cVisualMap is object && Maps.rndrVisualMap is object)
{
updateTextures(rndrVisualMap);
}
foreach (var rndrObj in Main.ObjectModels.Values)
{
updateTextures(rndrObj);
}
Ogl.Invalidate();
}
protected override void Draw(List <GizmoPoint> gizmoData)
{
if (gizmoData.Count == 0)
{
return;
}
if (data.Length < gizmoData.Count * 3)
{
Array.Resize(ref data, gizmoData.Count * 3);
}
int dataIndex = 0;
for (int i = 0; i < gizmoData.Count; i++)
{
GizmoPoint gizmo = gizmoData[i];
data[dataIndex++] = gizmo.Point.x;
data[dataIndex++] = gizmo.Point.y;
data[dataIndex++] = gizmo.Point.z;
}
//VBO config
Ogl.BindBuffer(BufferTarget.ArrayBuffer, vbo);
Ogl.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * dataIndex, data, BufferUsageHint.StreamDraw);
//VAO config
Ogl.BindVertexArray(vao);
Ogl.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 3, 0);
Ogl.EnableVertexAttribArray(0);
Ogl.DrawArray(PrimitiveType.Points, 0, gizmoData.Count);
}
protected override void OnResize(ResizeEventArgs e)
{
base.OnResize(e);
AppScreen.Resolution = new Entygine.Mathematics.Vec2i(Size.X, Size.Y);
Ogl.Viewport(0, 0, Size.X, Size.Y);
}
internal void LoadAreaModel(ModelDrawMod modelMode)
{
if (Main.CArea is object)
{
Main.ProgressControl(true);
switch (modelMode)
{
case ModelDrawMod.Collision:
{
if (cCollisionMap is null)
{
LoadAreaCollisionAsObject3D();
rndrCollisionMap?.ReleaseBuffers();
rndrCollisionMap = null;
}
if (rndrCollisionMap is null)
{
rndrCollisionMap = new Renderer(cCollisionMap);
rndrCollisionMap.RenderModel();
}
break;
}
case ModelDrawMod.VisualMap:
{
if (cVisualMap is null)
{
LoadAreaVisualMapAsObject3D();
rndrVisualMap?.ReleaseBuffers();
rndrVisualMap = null;
}
if (rndrVisualMap is null)
{
rndrVisualMap = new Renderer(cVisualMap);
rndrVisualMap.RenderModel();
}
break;
}
}
Ogl.Invalidate();
Main.ProgressControl(false);
// Console.WriteLine("Done!")
}
}
private static void RenderEditor(FrameEventArgs e)
{
imgui.Update(mainWindow.KeyboardState, mainWindow.MouseState, (float)e.Time);
Ogl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
Ogl.ClearColor(0.1f, 0.1f, 0.1f, 255);
EntygineApp.RenderFrame(e);
Ogl.Viewport(0, 0, mainWindow.Size.X, mainWindow.Size.Y);
imgui.WindowResized(mainWindow.Size.X, mainWindow.Size.Y);
mainEditorDrawer.Draw();
imgui.Render();
}
public void CreateDeviceResources()
{
vertexBufferSize = 100_000;
indexBufferSize = 20_000;
vao = Ogl.GenVertexArray("Dear IMGUI");
Ogl.BindVertexArray(vao);
vertexBuffer = Ogl.GenBuffer("Dear IMGUI - Vertex Buffer");
indexBuffer = Ogl.GenBuffer("Dear IMGUI - Index Buffer");
Ogl.BindBuffer(BufferTarget.ArrayBuffer, vertexBuffer);
Ogl.BufferData(BufferTarget.ArrayBuffer, vertexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
//Ogl.NamedBufferData(vertexBuffer, vertexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
Ogl.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
Ogl.BufferData(BufferTarget.ElementArrayBuffer, indexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
//Ogl.NamedBufferData(indexBuffer, indexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
RecreateFontDeviceTexture();
Shader shader = Shader.CreateShaderWithProgram(imgui_vert, imgui_frag, "ImGUI Shader");
material = new Material(shader, fontTexture);
material.LoadMaterial();
Ogl.VertexArrayVertexBuffer(vao, 0, vertexBuffer, IntPtr.Zero, Unsafe.SizeOf <ImDrawVert>());
Ogl.VertexArrayElementBuffer(vao, indexBuffer);
Ogl.EnableVertexArrayAttrib(vao, 0);
Ogl.VertexArrayAttribBinding(vao, 0, 0);
Ogl.VertexArrayAttribFormat(vao, 0, 2, VertexAttribType.Float, false, 0);
Ogl.EnableVertexArrayAttrib(vao, 1);
Ogl.VertexArrayAttribBinding(vao, 1, 0);
Ogl.VertexArrayAttribFormat(vao, 1, 2, VertexAttribType.Float, false, 8);
Ogl.EnableVertexArrayAttrib(vao, 2);
Ogl.VertexArrayAttribBinding(vao, 2, 0);
Ogl.VertexArrayAttribFormat(vao, 2, 4, VertexAttribType.UnsignedByte, true, 16);
}
public void Render(ref RenderContext context, CameraData[] cameras, Matrix4[] transforms)
{
context.CommandBuffer.QueueCommand(RenderCommandsLibrary.GenerateShadowMaps());
for (int i = 0; i < cameras.Length; i++)
{
Matrix4 cameraTransform = transforms[i];
CameraData camera = cameras[i];
context.CommandBuffer.QueueCommand(new RenderCommand("Bind color FBO", (ref RenderContext context) =>
{
camera.Framebuffer.Bind();
//Ogl.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer_color);
//Ogl.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, TextureTarget.Texture2D, camera.DepthTargetTexture.Handle, 0);
//Ogl.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, camera.ColorTargetTexture.handle, 0);
//FramebufferErrorCode status = Ogl.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
//if (status != FramebufferErrorCode.FramebufferComplete)
// DevTools.DevConsole.Log(DevTools.LogType.Error, status);
Ogl.Enable(EnableCap.DepthTest);
Ogl.Enable(EnableCap.CullFace);
Ogl.Enable(EnableCap.ProgramPointSize);
Ogl.Enable(EnableCap.Multisample);
Ogl.PointSize(10f);
}));
context.CommandBuffer.QueueCommand(RenderCommandsLibrary.DrawGeometry(camera, cameraTransform));
context.CommandBuffer.QueueCommand(RenderCommandsLibrary.DrawGizmos(camera, cameraTransform));
context.CommandBuffer.QueueCommand(RenderCommandsLibrary.DrawSkybox(camera, cameraTransform));
context.CommandBuffer.QueueCommand(new RenderCommand("Unbind FBO", (ref RenderContext context) =>
{
//TODO: Blit f*****g up at some point wtf
Framebuffer.Blit(camera.Framebuffer, camera.FinalFramebuffer, ClearBufferMask.ColorBufferBit);
Ogl.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
}));
}
//context.CommandBuffer.QueueCommand(RenderCommandsLibrary.DrawUI());
}
public static RenderCommand DrawUI()
{
return(new RenderCommand("Draw UI", (ref RenderContext context) =>
{
if (!context.TryGetData(out UICanvasRenderData canvasRenderData))
{
return;
}
Ogl.Disable(EnableCap.CullFace);
Ogl.Disable(EnableCap.DepthTest);
Ogl.Enable(EnableCap.Blend);
Ogl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
Matrix4 projection = canvasRenderData.Camera.CalculateProjection();
List <UICanvas> canvases = canvasRenderData.GetCanvases();
for (int i = 0; i < canvases.Count; i++)
{
UICanvas canvas = canvases[i];
canvas.deltaTimeText.Text = $"{FrameContext.Current.count} frame - {FrameContext.Current.delta * 1000:F1}ms - {1 / FrameContext.Current.delta:F1}fps";
canvas.UpdateRenderers();
var renderables = canvas.GetRenderables();
for (int m = 0; m < renderables.Count; m++)
{
UI_IRenderable currRenderable = renderables[m];
currRenderable.Material.SetMatrix("projection", projection);
currRenderable.DrawUI(canvasRenderData.Mesh);
}
}
Ogl.Enable(EnableCap.CullFace);
Ogl.Enable(EnableCap.DepthTest);
Ogl.Disable(EnableCap.Blend);
}));
public static RenderCommand DrawGeometry(CameraData camera, Matrix4 cameraTransform)
{
return(new RenderCommand("Draw Geometry", (ref RenderContext context) =>
{
if (!context.TryGetData(out GeometryRenderData geometryData))
{
return;
}
if (!context.TryGetData(out LightsRenderData lightData))
{
return;
}
//if (MainDevWindowGL.Window.KeyboardState.IsKeyDown(OpenTK.Windowing.GraphicsLibraryFramework.Keys.I))
// yaw += 0.1f;
//if (MainDevWindowGL.Window.KeyboardState.IsKeyDown(OpenTK.Windowing.GraphicsLibraryFramework.Keys.O))
// yaw -= 0.1f;
//if (MainDevWindowGL.Window.KeyboardState.IsKeyDown(OpenTK.Windowing.GraphicsLibraryFramework.Keys.K))
// pitch += 0.1f;
//if (MainDevWindowGL.Window.KeyboardState.IsKeyDown(OpenTK.Windowing.GraphicsLibraryFramework.Keys.L))
// pitch -= 0.1f;
Ogl.Viewport(0, 0, AppScreen.Resolution.x, AppScreen.Resolution.y);
Ogl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Light mainLight = lightData.lights[0];
Matrix4 projection = camera.CalculateProjection();
List <MeshRenderGroup> renderGroups = geometryData.GetRenderGroups();
for (int i = 0; i < renderGroups.Count; i++)
{
MeshRenderGroup renderGroup = renderGroups[i];
RenderMesh pair = renderGroup.MeshRender;
List <Matrix4> positions = renderGroup.Transforms;
pair.mat.SetDepthMap(new DepthTexture(mainLight.Framebuffer.DepthBuffer));
GraphicsAPI.UseMeshMaterial(pair.mesh, pair.mat);
//Update camera pos for material
//TODO: Use 'Uniform buffer objects' to globally share this data
pair.mat.SetMatrix("view", cameraTransform);
pair.mat.SetMatrix("projection", projection);
pair.mat.SetVector3("directionalLight", new Vector3(1, 1, 1));
pair.mat.SetVector3("ambientLight", new Vector3(0.5f, 0.5f, 0.5f));
pair.mat.SetVector3("directionalDir", LIGHT_FORWARD_NORMALIZED);
pair.mat.SetMatrix("lightSpace", LIGHT_VIEW * mainLight.GetProjection());
for (int p = 0; p < positions.Count; p++)
{
pair.mat.SetMatrix("model", positions[p]);
GraphicsAPI.DrawTriangles(pair.mesh.GetIndiceCount());
}
GraphicsAPI.FreeMeshMaterial(pair.mesh, pair.mat);
}
}));
public GizmoLineOrder()
{
vao = Ogl.GenVertexArray("Gizmo - Lines");
vbo = Ogl.GenBuffer("Gizmo Lines");
}
internal void CheckAndLoadNew()
{
Ogl.MakeCurrent();
bool loadAreaIDs = false;
if (Main.CArea is null)
{
loadAreaIDs = true;
}
if (Main.CLevel.Areas.Count != Main.ComboBoxItem_Area.Items.Count)
{
loadAreaIDs = true;
}
else
{
foreach (ComboItem ci in Main.ComboBoxItem_Area.Items)
{
if (!Main.CLevel.Areas.Contains((LevelArea)ci.Tag))
{
loadAreaIDs = true;
}
}
}
if (loadAreaIDs)
{
Main.LoadAreaIDs();
}
else
{
bool loadAreaMdl = false;
if (hashCollisionMap != Main.CArea.AreaModel.Collision.GetHashCode())
{
hashCollisionMap = 0;
cCollisionMap = null;
if (Ogl.CurrentModelDrawMod == ModelDrawMod.Collision)
{
loadAreaMdl = true;
}
}
if (hashVisualMap != Main.CArea.AreaModel.Fast3DBuffer.GetBuffer().GetHashCode())
{
hashVisualMap = 0;
cVisualMap = null;
if (Ogl.CurrentModelDrawMod == ModelDrawMod.VisualMap)
{
loadAreaMdl = true;
}
}
if (loadAreaMdl)
{
Maps.LoadAreaModel();
}
else
{
Ogl.Invalidate();
}
}
}
public void ImportAreaModel(bool convertModel, bool convertCollision, string inputKey)
{
var res = PublicFunctions.GetModelViaModelConverter(loadVisualMapAsDefault: convertModel, loadCollisionAsDefault: convertCollision, inputsKey: inputKey);
if (res is object)
{
Ogl.MakeCurrent();
Main.SuspendLayout();
{
var withBlock = Main.CArea;
HistoryPoint hp = null;
var OldAreaModel = withBlock.AreaModel;
if (res.Value.hasCollision && res.Value.hasVisualMap == true)
{
hp = HistoryPoint.FromObject(this, ObjectValueType.Field, new MemberWhiteList(new[] { "rndrVisualMap", "cVisualMap", "rndrCollisionMap", "cCollisionMap" }), BindingFlags.Instance | BindingFlags.NonPublic);
var os = new ObjectState();
os.Object = Main.CArea;
os.ValueToPatch = withBlock.AreaModel;
os.MemberFlags = BindingFlags.Instance | BindingFlags.Public;
os.MemberType = ObjectValueType.Property;
os.MemberName = "AreaModel";
hp.Entries.Add(os);
withBlock.AreaModel = res?.mdl;
withBlock.AreaModel.Collision.SpecialBoxes = OldAreaModel.Collision.SpecialBoxes;
cVisualMap = null;
cCollisionMap = null;
}
else if (res.Value.hasCollision == true)
{
hp = HistoryPoint.FromObject(this, ObjectValueType.Field, new MemberWhiteList(new[] { "rndrCollisionMap", "cCollisionMap" }), BindingFlags.Instance | BindingFlags.NonPublic);
var os = new ObjectState();
os.Object = Main.CArea.AreaModel;
os.ValueToPatch = withBlock.AreaModel.Collision;
os.MemberFlags = BindingFlags.Instance | BindingFlags.Public;
os.MemberType = ObjectValueType.Property;
os.MemberName = "Collision";
hp.Entries.Add(os);
withBlock.AreaModel.Collision = res?.mdl.Collision;
withBlock.AreaModel.Collision.SpecialBoxes = OldAreaModel.Collision.SpecialBoxes;
cCollisionMap = null;
}
else if (res.Value.hasVisualMap == true)
{
hp = HistoryPoint.FromObject(this, ObjectValueType.Field, new MemberWhiteList(new[] { "rndrVisualMap", "cVisualMap" }), BindingFlags.Instance | BindingFlags.NonPublic);
var os = new ObjectState();
os.Object = Main.CArea.AreaModel;
os.ValueToPatch = withBlock.AreaModel.Fast3DBuffer;
os.MemberFlags = BindingFlags.Instance | BindingFlags.Public;
os.MemberType = ObjectValueType.Property;
os.MemberName = "Fast3DBuffer";
hp.Entries.Add(os);
withBlock.AreaModel = res?.mdl;
withBlock.AreaModel.Collision = OldAreaModel.Collision;
cVisualMap = null;
}
if (res.Value.hasVisualMap == true)
{
withBlock.ScrollingTextures.Clear();
withBlock.ScrollingTextures.AddRange(withBlock.AreaModel.Fast3DBuffer.ConvertResult.ScrollingCommands.ToArray());
Main.Rommgr.RomConfig.GetLevelConfig(Main.CLevel.LevelID).GetLevelAreaConfig(withBlock.AreaID).ScrollingNames = res?.mdl.Fast3DBuffer.ConvertResult.ScrollingNames;
}
if (hp != null && hp.Entries.Any())
{
Main.history.Store(hp);
}
}
Main.CArea.SetSegmentedBanks(Main.Rommgr);
LoadAreaModel();
Main.ResumeLayout();
}
else
{
Ogl.MakeCurrent();
}
}
public static void LoadEngine()
{
if (loadedEngine)
{
return;
}
loadedEngine = true;
Ogl.enableErrorCheck = true;
InitConsole();
DevConsole.Log(LogType.Info, "Creating Entity World...");
coreWorker = new WorkerCycleCore();
EntityWorld world = InitEcs();
RenderPipelineCore.SetPipeline(new ForwardRenderPipeline());
InitPhysics();
InitSkybox();
InitUI(world);
InitLight();
InitScene(world);
DevConsole.Log(LogType.Info, "Entity world created.");
Ogl.ClearColor(0.1f, 0.1f, 0.2f, 1.0f);
Ogl.Enable(EnableCap.DepthTest);
Ogl.Enable(EnableCap.CullFace);
Ogl.Enable(EnableCap.ProgramPointSize);
Ogl.PointSize(10f);
EntityWorld InitEcs()
{
EntityWorld world = EntityWorld.CreateWorld();
world.Runner.AssignToWorker(coreWorker).CreateSystemsAuto(world);
EntityWorld.SetActive(world);
return(world);
}
void InitPhysics()
{
PhysicsRunner physicsRunner = new PhysicsRunner();
PhysicsWorld world = new PhysicsWorld();
PhysicsWorld.SetDefaultWorld(world);
physicsRunner.AddWorld(world);
physicsRunner.AssignToWorker(coreWorker);
}
void InitScene(EntityWorld world)
{
Mesh meshResource = MeshPrimitives.CreateCube(1);
Shader shaderResource = Shader.CreateShaderWithPath(AssetBrowser.Utilities.LocalToAbsolutePath(@"Shaders\standard.vert"),
AssetBrowser.Utilities.LocalToAbsolutePath(@"Shaders\standard.frag"), "Standard Shader");
Texture2D texture = new Texture2D(AssetBrowser.Utilities.LocalToAbsolutePath(@"Textures\Box.png"), "Box");
Material materialResource = new Material(shaderResource, texture);
SC_RenderMesh renderMesh = new SC_RenderMesh(meshResource, materialResource);
EntityArchetype meshArchetype = new EntityArchetype(typeof(SC_RenderMesh), typeof(C_Transform), typeof(C_Position));
EntityArchetype boxArchetype = new EntityArchetype(typeof(SC_RenderMesh), typeof(C_Transform), typeof(C_Position), typeof(C_BoxTag));
Entity planeEntity = world.EntityManager.CreateEntity(meshArchetype);
world.EntityManager.SetComponent(planeEntity, new C_Position()
{
value = new Vec3f(0, 0, 0)
});
//world.EntityManager.SetComponent(planeEntity, new C_PhysicsBody() { body = new PhysicBody() { isStatic = true } });
Mesh planeMesh = MeshPrimitives.CreatePlaneXZ(50);
Material planeMaterial = new Material(shaderResource, Texture2D.CreateWhiteTexture(64, 64));
world.EntityManager.SetSharedComponent(planeEntity, new SC_RenderMesh(planeMesh, planeMaterial));
Entity planeEntity2 = world.EntityManager.CreateEntity(meshArchetype);
world.EntityManager.SetComponent(planeEntity2, new C_Position()
{
value = new Vec3f(0, 5, -10)
});
//world.EntityManager.SetComponent(planeEntity2, new C_PhysicsBody() { body = new PhysicBody() { isStatic = true } });
Mesh planeMesh2 = MeshPrimitives.CreatePlaneXY(10);
Material planeMaterial2 = new Material(shaderResource, texture);
world.EntityManager.SetSharedComponent(planeEntity2, new SC_RenderMesh(planeMesh2, planeMaterial2));
Entity boxEntity = world.EntityManager.CreateEntity(boxArchetype);
world.EntityManager.SetComponent(boxEntity, new C_Position()
{
value = new Vec3f(0, 2, 0)
});
//world.EntityManager.SetComponent(boxEntity, new C_PhysicsBody() { body = new PhysicBody() });
world.EntityManager.SetSharedComponent(boxEntity, renderMesh);
Entity boxEntity2 = world.EntityManager.CreateEntity(boxArchetype);
world.EntityManager.SetComponent(boxEntity2, new C_Position()
{
value = new Vec3f(2, 2, 0)
});
//world.EntityManager.SetComponent(boxEntity2, new C_PhysicsBody() { body = new PhysicBody() });
world.EntityManager.SetSharedComponent(boxEntity2, renderMesh);
Entity boxEntity3 = world.EntityManager.CreateEntity(boxArchetype);
world.EntityManager.SetComponent(boxEntity3, new C_Position()
{
value = new Vec3f(-2, 2, 0)
});
//world.EntityManager.SetComponent(boxEntity3, new C_PhysicsBody() { body = new PhysicBody() });
world.EntityManager.SetSharedComponent(boxEntity3, renderMesh);
EntityArchetype editorCameraArchetype = new EntityArchetype(typeof(C_Camera), typeof(C_Transform), typeof(C_EditorCamera));
Entity cameraEditorEntity = world.EntityManager.CreateEntity(editorCameraArchetype);
world.EntityManager.SetComponent(cameraEditorEntity, new C_Camera()
{
cameraData = CameraData.CreatePerpectiveCamera(45f, 800f / 600f, 0.1f, 100f)
});
world.EntityManager.SetComponent(cameraEditorEntity, new C_EditorCamera()
{
speed = 10f, focusPoint = new Vector3(0, 2, 0), focusDistance = 12, pitch = 20, yaw = 115, sensitivity = 20
});
}
void InitLight()
{
if (RenderPipelineCore.TryGetContext(out LightsRenderData lightData))
{
lightData.lights.Add(new DirectionalLight());
}
}
void InitUI(EntityWorld world)
{
EntityArchetype canvasArch = new EntityArchetype(typeof(C_UICanvas));
var entity = world.EntityManager.CreateEntity(canvasArch);
world.EntityManager.SetComponent(entity, new C_UICanvas()
{
canvas = new UICanvas()
});
}
public GizmoPointOrder()
{
vao = Ogl.GenVertexArray("Gizmos - Points");
vbo = Ogl.GenBuffer("Gizmos - Points");
}
private void RenderImDrawData(ImDrawDataPtr draw_data)
{
if (draw_data.CmdListsCount == 0)
{
return;
}
for (int i = 0; i < draw_data.CmdListsCount; i++)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[i];
int vertexSize = cmd_list.VtxBuffer.Size * Unsafe.SizeOf <ImDrawVert>();
if (vertexSize > vertexBufferSize)
{
int newSize = (int)Math.Max(vertexBufferSize * 1.5f, vertexSize);
GL.NamedBufferData(vertexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
vertexBufferSize = newSize;
DevConsole.Log(LogType.Verbose, $"Resized dear imgui vertex buffer to new size {vertexBufferSize}");
}
int indexSize = cmd_list.IdxBuffer.Size * sizeof(ushort);
if (indexSize > indexBufferSize)
{
int newSize = (int)Math.Max(indexBufferSize * 1.5f, indexSize);
GL.NamedBufferData(indexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
indexBufferSize = newSize;
DevConsole.Log(LogType.Verbose, $"Resized dear imgui index buffer to new size {indexBufferSize}");
}
}
ImGuiIOPtr io = ImGui.GetIO();
Matrix4 mvp = Matrix4.CreateOrthographicOffCenter(0.0f, io.DisplaySize.X, io.DisplaySize.Y, 0.0f, -1.0f, 1.0f);
material.UseMaterial();
Ogl.UniformMatrix4(material.shader.GetUniformLocation("projection_matrix"), false, ref mvp);
Ogl.Uniform1(material.shader.GetUniformLocation("in_fontTexture"), 0);
Ogl.BindVertexArray(vao);
GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBuffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
draw_data.ScaleClipRects(io.DisplayFramebufferScale);
GL.Enable(EnableCap.Blend);
GL.Enable(EnableCap.ScissorTest);
GL.BlendEquation(BlendEquationMode.FuncAdd);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
// Render command lists
for (int n = 0; n < draw_data.CmdListsCount; n++)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[n];
GL.NamedBufferSubData(vertexBuffer, IntPtr.Zero, cmd_list.VtxBuffer.Size * Unsafe.SizeOf <ImDrawVert>(), cmd_list.VtxBuffer.Data);
GL.NamedBufferSubData(indexBuffer, IntPtr.Zero, cmd_list.IdxBuffer.Size * sizeof(ushort), cmd_list.IdxBuffer.Data);
int vtx_offset = 0;
int idx_offset = 0;
for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++)
{
ImDrawCmdPtr pcmd = cmd_list.CmdBuffer[cmd_i];
if (pcmd.UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, (int)pcmd.TextureId);
var clip = pcmd.ClipRect;
GL.Scissor((int)clip.X, windowHeight - (int)clip.W, (int)(clip.Z - clip.X), (int)(clip.W - clip.Y));
if ((io.BackendFlags & ImGuiBackendFlags.RendererHasVtxOffset) != 0)
{
GL.DrawElementsBaseVertex(PrimitiveType.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (IntPtr)(idx_offset * sizeof(ushort)), vtx_offset);
//GL.DrawElements(BeginMode.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (int)pcmd.IdxOffset * sizeof(ushort));
}
else
{
GL.DrawElements(BeginMode.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (int)pcmd.IdxOffset * sizeof(ushort));
}
}
idx_offset += (int)pcmd.ElemCount;
}
vtx_offset += cmd_list.VtxBuffer.Size;
}
GL.Disable(EnableCap.Blend);
GL.Disable(EnableCap.ScissorTest);
}
