Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Simplify code to not require Shader.cs, Texture.cs and lower gl requirement to 3.3 #20

Merged
merged 6 commits into from
Jun 17, 2022
Merged

Simplify code to not require Shader.cs, Texture.cs and lower gl requirement to 3.3 #20

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
05f785a
Started simplifying the sample
NogginBops Jan 20, 2022
296a7bf
More simplification and lowered the required GL version to 3.3
NogginBops Jan 20, 2022
c38595a
Implemented proper disposing of VAO, VBO, and EBO
NogginBops Mar 18, 2022
45309dd
Removed old comments
NogginBops Mar 18, 2022
2e40891
Fixed state saving and restoring
NogginBops Jun 17, 2022
5c6bf38
Merge branch 'opentk4.0' of github.com:NogginBops/ImGui.NET_OpenTK_Sa…
NogginBops Jun 17, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
257 changes: 214 additions & 43 deletions Dear ImGui Sample/ImGuiController.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,8 @@
using OpenTK.Windowing.Common.Input;
using OpenTK.Windowing.Desktop;
using OpenTK.Windowing.GraphicsLibraryFramework;
using System.Diagnostics;
using ErrorCode = OpenTK.Graphics.OpenGL4.ErrorCode;

namespace Dear_ImGui_Sample
{
Expand All @@ -20,14 +22,21 @@ public class ImGuiController : IDisposable
private int _indexBuffer;
private int _indexBufferSize;

private Texture _fontTexture;
private Shader _shader;
//private Texture _fontTexture;

private int _fontTexture;

private int _shader;
private int _shaderFontTextureLocation;
private int _shaderProjectionMatrixLocation;

private int _windowWidth;
private int _windowHeight;

private System.Numerics.Vector2 _scaleFactor = System.Numerics.Vector2.One;

private static bool KHRDebugAvailable = false;

/// <summary>
/// Constructs a new ImGuiController.
/// </summary>
Expand All @@ -36,6 +45,11 @@ public ImGuiController(int width, int height)
_windowWidth = width;
_windowHeight = height;

int major = GL.GetInteger(GetPName.MajorVersion);
int minor = GL.GetInteger(GetPName.MinorVersion);

KHRDebugAvailable = (major == 4 && minor >= 3) || IsExtensionSupported("KHR_debug");

IntPtr context = ImGui.CreateContext();
ImGui.SetCurrentContext(context);
var io = ImGui.GetIO();
Expand Down Expand Up @@ -65,15 +79,25 @@ public void DestroyDeviceObjects()

public void CreateDeviceResources()
{
Util.CreateVertexArray("ImGui", out _vertexArray);

_vertexBufferSize = 10000;
_indexBufferSize = 2000;

Util.CreateVertexBuffer("ImGui", out _vertexBuffer);
Util.CreateElementBuffer("ImGui", out _indexBuffer);
GL.NamedBufferData(_vertexBuffer, _vertexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
GL.NamedBufferData(_indexBuffer, _indexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
int prevVAO = GL.GetInteger(GetPName.VertexArrayBinding);
int prevArrayBuffer = GL.GetInteger(GetPName.ArrayBufferBinding);

_vertexArray = GL.GenVertexArray();
GL.BindVertexArray(_vertexArray);
LabelObject(ObjectLabelIdentifier.VertexArray, _vertexArray, "ImGui");

_vertexBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, _vertexBuffer);
LabelObject(ObjectLabelIdentifier.Buffer, _vertexBuffer, "VBO: ImGui");
GL.BufferData(BufferTarget.ArrayBuffer, _vertexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);

_indexBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _indexBuffer);
LabelObject(ObjectLabelIdentifier.Buffer, _indexBuffer, "EBO: ImGui");
GL.BufferData(BufferTarget.ElementArrayBuffer, _indexBufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);

RecreateFontDeviceTexture();

Expand Down Expand Up @@ -107,24 +131,24 @@ void main()
{
outputColor = color * texture(in_fontTexture, texCoord);
}";
_shader = new Shader("ImGui", VertexSource, FragmentSource);

GL.VertexArrayVertexBuffer(_vertexArray, 0, _vertexBuffer, IntPtr.Zero, Unsafe.SizeOf<ImDrawVert>());
GL.VertexArrayElementBuffer(_vertexArray, _indexBuffer);
_shader = CreateProgram("ImGui", VertexSource, FragmentSource);
_shaderProjectionMatrixLocation = GL.GetUniformLocation(_shader, "projection_matrix");
_shaderFontTextureLocation = GL.GetUniformLocation(_shader, "in_fontTexture");

GL.EnableVertexArrayAttrib(_vertexArray, 0);
GL.VertexArrayAttribBinding(_vertexArray, 0, 0);
GL.VertexArrayAttribFormat(_vertexArray, 0, 2, VertexAttribType.Float, false, 0);
int stride = Unsafe.SizeOf<ImDrawVert>();
GL.VertexAttribPointer(0, 2, VertexAttribPointerType.Float, false, stride, 0);
GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, stride, 8);
GL.VertexAttribPointer(2, 4, VertexAttribPointerType.UnsignedByte, true, stride, 16);

GL.EnableVertexArrayAttrib(_vertexArray, 1);
GL.VertexArrayAttribBinding(_vertexArray, 1, 0);
GL.VertexArrayAttribFormat(_vertexArray, 1, 2, VertexAttribType.Float, false, 8);
GL.EnableVertexAttribArray(0);
GL.EnableVertexAttribArray(1);
GL.EnableVertexAttribArray(2);

GL.EnableVertexArrayAttrib(_vertexArray, 2);
GL.VertexArrayAttribBinding(_vertexArray, 2, 0);
GL.VertexArrayAttribFormat(_vertexArray, 2, 4, VertexAttribType.UnsignedByte, true, 16);
GL.BindVertexArray(prevVAO);
GL.BindBuffer(BufferTarget.ArrayBuffer, prevArrayBuffer);

Util.CheckGLError("End of ImGui setup");
CheckGLError("End of ImGui setup");
}

/// <summary>
Expand All @@ -135,11 +159,34 @@ public void RecreateFontDeviceTexture()
ImGuiIOPtr io = ImGui.GetIO();
io.Fonts.GetTexDataAsRGBA32(out IntPtr pixels, out int width, out int height, out int bytesPerPixel);

_fontTexture = new Texture("ImGui Text Atlas", width, height, pixels);
_fontTexture.SetMagFilter(TextureMagFilter.Linear);
_fontTexture.SetMinFilter(TextureMinFilter.Linear);

io.Fonts.SetTexID((IntPtr)_fontTexture.GLTexture);
int mips = (int)Math.Floor(Math.Log(Math.Max(width, height), 2));

int prevActiveTexture = GL.GetInteger(GetPName.ActiveTexture);
GL.ActiveTexture(0);
int prevTexture2D = GL.GetInteger(GetPName.Texture2D);

_fontTexture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, _fontTexture);
GL.TexStorage2D(TextureTarget2d.Texture2D, mips, SizedInternalFormat.Rgba8, width, height);
LabelObject(ObjectLabelIdentifier.Texture, _fontTexture, "ImGui Text Atlas");

GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, width, height, PixelFormat.Bgra, PixelType.UnsignedByte, pixels);

GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);

GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);

GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMaxLevel, mips - 1);

GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);

// Restore state
GL.BindTexture(TextureTarget.Texture2D, prevTexture2D);
GL.ActiveTexture((TextureUnit)prevActiveTexture);

io.Fonts.SetTexID((IntPtr)_fontTexture);

io.Fonts.ClearTexData();
}
Expand Down Expand Up @@ -270,6 +317,36 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
return;
}

// Get intial state.
int prevVAO = GL.GetInteger(GetPName.VertexArrayBinding);
int prevArrayBuffer = GL.GetInteger(GetPName.ArrayBufferBinding);
int prevProgram = GL.GetInteger(GetPName.CurrentProgram);
bool prevBlendEnabled = GL.GetBoolean(GetPName.Blend);
bool prevScissorTestEnabled = GL.GetBoolean(GetPName.ScissorTest);
int prevBlendEquationRgb = GL.GetInteger(GetPName.BlendEquationRgb);
int prevBlendEquationAlpha = GL.GetInteger(GetPName.BlendEquationAlpha);
int prevBlendFuncSrcRgb = GL.GetInteger(GetPName.BlendSrcRgb);
int prevBlendFuncSrcAlpha = GL.GetInteger(GetPName.BlendSrcAlpha);
int prevBlendFuncDstRgb = GL.GetInteger(GetPName.BlendDstRgb);
int prevBlendFuncDstAlpha = GL.GetInteger(GetPName.BlendDstAlpha);
bool prevCullFaceEnabled = GL.GetBoolean(GetPName.CullFace);
bool prevDepthTestEnabled = GL.GetBoolean(GetPName.DepthTest);
int prevActiveTexture = GL.GetInteger(GetPName.ActiveTexture);
GL.ActiveTexture(TextureUnit.Texture0);
int prevTexture2D = GL.GetInteger(GetPName.Texture2D);
Span<int> prevScissorBox = stackalloc int[4];
unsafe
{
fixed (int* iptr = &prevScissorBox[0])
{
GL.GetInteger(GetPName.ScissorBox, iptr);
}
}

// Bind the element buffer (thru the VAO) so that we can resize it.
GL.BindVertexArray(_vertexArray);
// Bind the vertex buffer so that we can resize it.
GL.BindBuffer(BufferTarget.ArrayBuffer, _vertexBuffer);
for (int i = 0; i < draw_data.CmdListsCount; i++)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[i];
Expand All @@ -278,7 +355,8 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
if (vertexSize > _vertexBufferSize)
{
int newSize = (int)Math.Max(_vertexBufferSize * 1.5f, vertexSize);
GL.NamedBufferData(_vertexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);

GL.BufferData(BufferTarget.ArrayBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
_vertexBufferSize = newSize;

Console.WriteLine($"Resized dear imgui vertex buffer to new size {_vertexBufferSize}");
Expand All @@ -288,7 +366,7 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
if (indexSize > _indexBufferSize)
{
int newSize = (int)Math.Max(_indexBufferSize * 1.5f, indexSize);
GL.NamedBufferData(_indexBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
GL.BufferData(BufferTarget.ElementArrayBuffer, newSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
_indexBufferSize = newSize;

Console.WriteLine($"Resized dear imgui index buffer to new size {_indexBufferSize}");
Expand All @@ -305,13 +383,13 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
-1.0f,
1.0f);

_shader.UseShader();
GL.UniformMatrix4(_shader.GetUniformLocation("projection_matrix"), false, ref mvp);
GL.Uniform1(_shader.GetUniformLocation("in_fontTexture"), 0);
Util.CheckGLError("Projection");
GL.UseProgram(_shader);
GL.UniformMatrix4(_shaderProjectionMatrixLocation, false, ref mvp);
GL.Uniform1(_shaderFontTextureLocation, 0);
CheckGLError("Projection");

GL.BindVertexArray(_vertexArray);
Util.CheckGLError("VAO");
CheckGLError("VAO");

draw_data.ScaleClipRects(io.DisplayFramebufferScale);

Expand All @@ -327,11 +405,11 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
{
ImDrawListPtr cmd_list = draw_data.CmdListsRange[n];

GL.NamedBufferSubData(_vertexBuffer, IntPtr.Zero, cmd_list.VtxBuffer.Size * Unsafe.SizeOf<ImDrawVert>(), cmd_list.VtxBuffer.Data);
Util.CheckGLError($"Data Vert {n}");
GL.BufferSubData(BufferTarget.ArrayBuffer, IntPtr.Zero, cmd_list.VtxBuffer.Size * Unsafe.SizeOf<ImDrawVert>(), cmd_list.VtxBuffer.Data);
CheckGLError($"Data Vert {n}");

GL.NamedBufferSubData(_indexBuffer, IntPtr.Zero, cmd_list.IdxBuffer.Size * sizeof(ushort), cmd_list.IdxBuffer.Data);
Util.CheckGLError($"Data Idx {n}");
GL.BufferSubData(BufferTarget.ElementArrayBuffer, IntPtr.Zero, cmd_list.IdxBuffer.Size * sizeof(ushort), cmd_list.IdxBuffer.Data);
CheckGLError($"Data Idx {n}");

for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++)
{
Expand All @@ -344,28 +422,46 @@ private void RenderImDrawData(ImDrawDataPtr draw_data)
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, (int)pcmd.TextureId);
Util.CheckGLError("Texture");
CheckGLError("Texture");

// We do _windowHeight - (int)clip.W instead of (int)clip.Y because gl has flipped Y when it comes to these coordinates
var clip = pcmd.ClipRect;
GL.Scissor((int)clip.X, _windowHeight - (int)clip.W, (int)(clip.Z - clip.X), (int)(clip.W - clip.Y));
Util.CheckGLError("Scissor");
CheckGLError("Scissor");

if ((io.BackendFlags & ImGuiBackendFlags.RendererHasVtxOffset) != 0)
{
GL.DrawElementsBaseVertex(PrimitiveType.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (IntPtr)(pcmd.IdxOffset * sizeof(ushort)), (int)pcmd.VtxOffset);
GL.DrawElementsBaseVertex(PrimitiveType.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (IntPtr)(pcmd.IdxOffset * sizeof(ushort)), unchecked((int)pcmd.VtxOffset));
}
else
{
GL.DrawElements(BeginMode.Triangles, (int)pcmd.ElemCount, DrawElementsType.UnsignedShort, (int)pcmd.IdxOffset * sizeof(ushort));
}
Util.CheckGLError("Draw");
CheckGLError("Draw");
}
}
}

GL.Disable(EnableCap.Blend);
GL.Disable(EnableCap.ScissorTest);

// Reset state
GL.BindTexture(TextureTarget.Texture2D, prevTexture2D);
GL.ActiveTexture((TextureUnit)prevActiveTexture);
GL.UseProgram(prevProgram);
GL.BindVertexArray(prevVAO);
GL.Scissor(prevScissorBox[0], prevScissorBox[1], prevScissorBox[2], prevScissorBox[3]);
GL.BindBuffer(BufferTarget.ArrayBuffer, prevArrayBuffer);
GL.BlendEquationSeparate((BlendEquationMode)prevBlendEquationRgb, (BlendEquationMode)prevBlendEquationAlpha);
GL.BlendFuncSeparate(
(BlendingFactorSrc)prevBlendFuncSrcRgb,
(BlendingFactorDest)prevBlendFuncDstRgb,
(BlendingFactorSrc)prevBlendFuncSrcAlpha,
(BlendingFactorDest)prevBlendFuncDstAlpha);
if (prevBlendEnabled) GL.Enable(EnableCap.Blend); else GL.Disable(EnableCap.Blend);
if (prevDepthTestEnabled) GL.Enable(EnableCap.DepthTest); else GL.Disable(EnableCap.DepthTest);
if (prevCullFaceEnabled) GL.Enable(EnableCap.CullFace); else GL.Disable(EnableCap.CullFace);
if (prevScissorTestEnabled) GL.Enable(EnableCap.ScissorTest); else GL.Disable(EnableCap.ScissorTest);
}

/// <summary>
Expand All @@ -377,8 +473,83 @@ public void Dispose()
GL.DeleteBuffer(_vertexBuffer);
GL.DeleteBuffer(_indexBuffer);

_fontTexture.Dispose();
_shader.Dispose();
GL.DeleteTexture(_fontTexture);
GL.DeleteProgram(_shader);
}

public static void LabelObject(ObjectLabelIdentifier objLabelIdent, int glObject, string name)
{
if (KHRDebugAvailable)
GL.ObjectLabel(objLabelIdent, glObject, name.Length, name);
}

static bool IsExtensionSupported(string name)
{
int n = GL.GetInteger(GetPName.NumExtensions);
for (int i = 0; i < n; i++)
{
string extension = GL.GetString(StringNameIndexed.Extensions, i);
if (extension == name) return true;
}

return false;
}

public static int CreateProgram(string name, string vertexSource, string fragmentSoruce)
{
int program = GL.CreateProgram();
LabelObject(ObjectLabelIdentifier.Program, program, $"Program: {name}");

int vertex = CompileShader(name, ShaderType.VertexShader, vertexSource);
int fragment = CompileShader(name, ShaderType.FragmentShader, fragmentSoruce);

GL.AttachShader(program, vertex);
GL.AttachShader(program, fragment);

GL.LinkProgram(program);

GL.GetProgram(program, GetProgramParameterName.LinkStatus, out int success);
if (success == 0)
{
string info = GL.GetProgramInfoLog(program);
Debug.WriteLine($"GL.LinkProgram had info log [{name}]:\n{info}");
}

GL.DetachShader(program, vertex);
GL.DetachShader(program, fragment);

GL.DeleteShader(vertex);
GL.DeleteShader(fragment);

return program;
}

private static int CompileShader(string name, ShaderType type, string source)
{
int shader = GL.CreateShader(type);
LabelObject(ObjectLabelIdentifier.Shader, shader, $"Shader: {name}");

GL.ShaderSource(shader, source);
GL.CompileShader(shader);

GL.GetShader(shader, ShaderParameter.CompileStatus, out int success);
if (success == 0)
{
string info = GL.GetShaderInfoLog(shader);
Debug.WriteLine($"GL.CompileShader for shader '{name}' [{type}] had info log:\n{info}");
}

return shader;
}

public static void CheckGLError(string title)
{
ErrorCode error;
int i = 1;
while ((error = GL.GetError()) != ErrorCode.NoError)
{
Debug.Print($"{title} ({i++}): {error}");
}
}
}
}
Loading