private void RenderImDrawData(DrawData *data)
{
for (int n = 0; n < data->CmdListsCount; n++)
{
NativeDrawList *cmdList = data->CmdLists[n];
byte * vb = (byte *)cmdList->VtxBuffer.Data;
ushort * ib = (ushort *)cmdList->IdxBuffer.Data;
UpdateVB(cmdList->VtxBuffer.Size, vb);
for (int cmd_i = 0; cmd_i < cmdList->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmdList->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
var texid = pcmd->TextureId.ToInt32();
UpdateIB((int)pcmd->ElemCount, ib);
_indexBuffer.Draw(_vertexBuffer, 0, (int)pcmd->ElemCount);
}
ib += pcmd->ElemCount;
}
}
}
/// <summary>
/// Helper to scale the ClipRect field of each ImDrawCmd.
/// Use if your final output buffer is at a different scale than ImGui expects,
/// or if there is a difference between your window resolution and framebuffer resolution.
/// </summary>
/// <param name="drawData">Pointer to the DrawData to scale.</param>
/// <param name="scale">The scale to apply.</param>
public static unsafe void ScaleClipRects(DrawData *drawData, Vector2 scale)
{
for (int i = 0; i < drawData->CmdListsCount; i++)
{
NativeDrawList *cmd_list = drawData->CmdLists[i];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *drawCmdList = (DrawCmd *)cmd_list->CmdBuffer.Data;
DrawCmd *cmd = &drawCmdList[cmd_i];
cmd->ClipRect = new Vector4(cmd->ClipRect.X * scale.X, cmd->ClipRect.Y * scale.Y, cmd->ClipRect.Z * scale.X, cmd->ClipRect.W * scale.Y);
}
}
}
private unsafe void RenderImDrawData(DrawData *draw_data, RenderContext rc)
{
VertexDescriptor descriptor = new VertexDescriptor((byte)sizeof(DrawVert), 3, IntPtr.Zero);
int vertexOffsetInVertices = 0;
int indexOffsetInElements = 0;
if (draw_data->CmdListsCount == 0)
{
return;
}
for (int i = 0; i < draw_data->CmdListsCount; i++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[i];
_vertexBuffer.SetVertexData(new IntPtr(cmd_list->VtxBuffer.Data), descriptor, cmd_list->VtxBuffer.Size, vertexOffsetInVertices);
_indexBuffer.SetIndices(new IntPtr(cmd_list->IdxBuffer.Data), IndexFormat.UInt16, cmd_list->IdxBuffer.Size, indexOffsetInElements);
vertexOffsetInVertices += cmd_list->VtxBuffer.Size;
indexOffsetInElements += cmd_list->IdxBuffer.Size;
}
// Setup orthographic projection matrix into our constant buffer
{
var io = ImGui.GetIO();
Matrix4x4 mvp = Matrix4x4.CreateOrthographicOffCenter(
0f,
io.DisplaySize.X,
io.DisplaySize.Y,
0.0f,
-1.0f,
1.0f);
_projMatrixBuffer.SetData(ref mvp, sizeof(Matrix4x4));
}
BlendState previousBlendState = rc.BlendState;
rc.SetBlendState(_blendState);
rc.SetDepthStencilState(_depthDisabledState);
RasterizerState previousRasterizerState = rc.RasterizerState;
rc.SetRasterizerState(_rasterizerState);
rc.VertexBuffer = _vertexBuffer;
rc.IndexBuffer = _indexBuffer;
rc.ShaderSet = _shaderSet;
rc.ShaderResourceBindingSlots = _resourceBindings;
rc.SetConstantBuffer(0, _projMatrixBuffer);
rc.SetSamplerState(2, _rc.PointSampler);
ImGui.ScaleClipRects(draw_data, ImGui.GetIO().DisplayFramebufferScale);
// Render command lists
int vtx_offset = 0;
int idx_offset = 0;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmd_list->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
if (pcmd->TextureId != IntPtr.Zero)
{
if (pcmd->TextureId == new IntPtr(_fontAtlasID))
{
_rc.SetTexture(1, _fontTextureBinding);
}
else
{
ShaderTextureBinding binding = ImGuiImageHelper.GetShaderTextureBinding(pcmd->TextureId);
_rc.SetTexture(1, binding);
}
}
// TODO: This doesn't take into account viewport coordinates.
rc.SetScissorRectangle(
(int)pcmd->ClipRect.X,
(int)pcmd->ClipRect.Y,
(int)pcmd->ClipRect.Z,
(int)pcmd->ClipRect.W);
rc.DrawIndexedPrimitives((int)pcmd->ElemCount, idx_offset, vtx_offset);
}
idx_offset += (int)pcmd->ElemCount;
}
vtx_offset += cmd_list->VtxBuffer.Size;
}
rc.ClearScissorRectangle();
rc.SetBlendState(previousBlendState);
rc.SetDepthStencilState(rc.DefaultDepthStencilState);
rc.SetRasterizerState(previousRasterizerState);
}
private unsafe void RenderImDrawData(DrawData *draw_data)
{
// Rendering
int display_w, display_h;
display_w = _nativeWindow.Width;
display_h = _nativeWindow.Height;
Vector4 clear_color = new Vector4(114f / 255f, 144f / 255f, 154f / 255f, 1.0f);
GL.Viewport(0, 0, display_w, display_h);
GL.ClearColor(clear_color.X, clear_color.Y, clear_color.Z, clear_color.W);
GL.Clear(ClearBufferMask.ColorBufferBit);
// We are using the OpenGL fixed pipeline to make the example code simpler to read!
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
int last_texture;
GL.GetInteger(GetPName.TextureBinding2D, out last_texture);
GL.PushAttrib(AttribMask.EnableBit | AttribMask.ColorBufferBit | AttribMask.TransformBit);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.ScissorTest);
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.ColorArray);
GL.Enable(EnableCap.Texture2D);
GL.UseProgram(0);
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
IO io = ImGui.GetIO();
ImGui.ScaleClipRects(draw_data, io.DisplayFramebufferScale);
// Setup orthographic projection matrix
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix();
GL.LoadIdentity();
GL.Ortho(
0.0f,
io.DisplaySize.X / io.DisplayFramebufferScale.X,
io.DisplaySize.Y / io.DisplayFramebufferScale.Y,
0.0f,
-1.0f,
1.0f);
GL.MatrixMode(MatrixMode.Modelview);
GL.PushMatrix();
GL.LoadIdentity();
// Render command lists
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[n];
byte * vtx_buffer = (byte *)cmd_list->VtxBuffer.Data;
ushort * idx_buffer = (ushort *)cmd_list->IdxBuffer.Data;
DrawVert vert0 = *((DrawVert *)vtx_buffer);
DrawVert vert1 = *(((DrawVert *)vtx_buffer) + 1);
DrawVert vert2 = *(((DrawVert *)vtx_buffer) + 2);
GL.VertexPointer(2, VertexPointerType.Float, sizeof(DrawVert), new IntPtr(vtx_buffer + DrawVert.PosOffset));
GL.TexCoordPointer(2, TexCoordPointerType.Float, sizeof(DrawVert), new IntPtr(vtx_buffer + DrawVert.UVOffset));
GL.ColorPointer(4, ColorPointerType.UnsignedByte, sizeof(DrawVert), new IntPtr(vtx_buffer + DrawVert.ColOffset));
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmd_list->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
GL.BindTexture(TextureTarget.Texture2D, pcmd->TextureId.ToInt32());
GL.Scissor(
(int)pcmd->ClipRect.X,
(int)(io.DisplaySize.Y - pcmd->ClipRect.W),
(int)(pcmd->ClipRect.Z - pcmd->ClipRect.X),
(int)(pcmd->ClipRect.W - pcmd->ClipRect.Y));
ushort[] indices = new ushort[pcmd->ElemCount];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = idx_buffer[i];
}
GL.DrawElements(PrimitiveType.Triangles, (int)pcmd->ElemCount, DrawElementsType.UnsignedShort, new IntPtr(idx_buffer));
}
idx_buffer += pcmd->ElemCount;
}
}
// Restore modified state
GL.DisableClientState(ArrayCap.ColorArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.VertexArray);
GL.BindTexture(TextureTarget.Texture2D, last_texture);
GL.MatrixMode(MatrixMode.Modelview);
GL.PopMatrix();
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix();
GL.PopAttrib();
_graphicsContext.SwapBuffers();
}
private unsafe void RenderImDrawData(DrawData *draw_data, GraphicsDevice gd, CommandList cl)
{
uint vertexOffsetInVertices = 0;
uint indexOffsetInElements = 0;
if (draw_data->CmdListsCount == 0)
{
return;
}
uint totalVBSize = (uint)(draw_data->TotalVtxCount * sizeof(DrawVert));
if (totalVBSize > _vertexBuffer.SizeInBytes)
{
gd.DisposeWhenIdle(_vertexBuffer);
_vertexBuffer = gd.ResourceFactory.CreateBuffer(new BufferDescription((uint)(totalVBSize * 1.5f), BufferUsage.VertexBuffer | BufferUsage.Dynamic));
}
uint totalIBSize = (uint)(draw_data->TotalIdxCount * sizeof(ushort));
if (totalIBSize > _indexBuffer.SizeInBytes)
{
gd.DisposeWhenIdle(_indexBuffer);
_indexBuffer = gd.ResourceFactory.CreateBuffer(new BufferDescription((uint)(totalIBSize * 1.5f), BufferUsage.IndexBuffer | BufferUsage.Dynamic));
}
for (int i = 0; i < draw_data->CmdListsCount; i++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[i];
cl.UpdateBuffer(
_vertexBuffer,
vertexOffsetInVertices * (uint)sizeof(DrawVert),
(IntPtr)cmd_list->VtxBuffer.Data,
(uint)(cmd_list->VtxBuffer.Size * sizeof(DrawVert)));
cl.UpdateBuffer(
_indexBuffer,
indexOffsetInElements * (uint)sizeof(ushort),
(IntPtr)cmd_list->IdxBuffer.Data,
(uint)(cmd_list->IdxBuffer.Size * sizeof(ushort)));
vertexOffsetInVertices += (uint)cmd_list->VtxBuffer.Size;
indexOffsetInElements += (uint)cmd_list->IdxBuffer.Size;
}
// Setup orthographic projection matrix into our constant buffer
{
IO io = ImGui.GetIO();
Matrix4x4 mvp = Matrix4x4.CreateOrthographicOffCenter(
0f,
io.DisplaySize.X,
io.DisplaySize.Y,
0.0f,
-1.0f,
1.0f);
_gd.UpdateBuffer(_projMatrixBuffer, 0, ref mvp);
}
cl.SetVertexBuffer(0, _vertexBuffer);
cl.SetIndexBuffer(_indexBuffer, IndexFormat.UInt16);
cl.SetPipeline(_pipeline);
cl.SetGraphicsResourceSet(0, _mainResourceSet);
ImGui.ScaleClipRects(draw_data, ImGui.GetIO().DisplayFramebufferScale);
// Render command lists
int vtx_offset = 0;
int idx_offset = 0;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmd_list->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
if (pcmd->TextureId != IntPtr.Zero)
{
if (pcmd->TextureId == _fontAtlasID)
{
cl.SetGraphicsResourceSet(1, _fontTextureResourceSet);
}
else
{
cl.SetGraphicsResourceSet(1, GetImageResourceSet(pcmd->TextureId));
}
}
cl.SetScissorRect(
0,
(uint)pcmd->ClipRect.X,
(uint)pcmd->ClipRect.Y,
(uint)(pcmd->ClipRect.Z - pcmd->ClipRect.X),
(uint)(pcmd->ClipRect.W - pcmd->ClipRect.Y));
cl.DrawIndexed(pcmd->ElemCount, 1, (uint)idx_offset, vtx_offset, 0);
}
idx_offset += (int)pcmd->ElemCount;
}
vtx_offset += cmd_list->VtxBuffer.Size;
}
}
private unsafe void RenderImDrawData(DrawData *drawData)
{
IO io = ImGui.GetIO();
int fbWidth = (int)(io.DisplaySize.X * io.DisplayFramebufferScale.X);
int fbHeight = (int)(io.DisplaySize.Y * io.DisplayFramebufferScale.Y);
if (fbWidth != 0 || fbHeight != 0)
{
ImGui.ScaleClipRects(drawData, io.DisplayFramebufferScale);
int lastActiveTexture; GL.GetInteger(GetPName.ActiveTexture, out lastActiveTexture);
//Console.WriteLine(GL.GetError());
GL.ActiveTexture(TextureUnit.Texture0);
//Console.WriteLine(GL.GetError());
int lastProgram; GL.GetInteger(GetPName.CurrentProgram, out lastProgram);
//Console.WriteLine(GL.GetError());
int lastTexture; GL.GetInteger(GetPName.TextureBinding2D, out lastTexture);
//Console.WriteLine(GL.GetError());
int lastArrayBuffer; GL.GetInteger(GetPName.ArrayBufferBinding, out lastArrayBuffer);
int lastElementArrayBuffer; GL.GetInteger(GetPName.ElementArrayBufferBinding, out lastElementArrayBuffer);
int lastVertexArray; GL.GetInteger(GetPName.VertexArrayBinding, out lastVertexArray);
int lastBlendSrcRgb; GL.GetInteger(GetPName.BlendSrcRgb, out lastBlendSrcRgb);
int lastBlendDstRgb; GL.GetInteger(GetPName.BlendDstRgb, out lastBlendDstRgb);
int lastBlendSrcAlpha; GL.GetInteger(GetPName.BlendSrcAlpha, out lastBlendSrcAlpha);
int lastBlendDstAlpha; GL.GetInteger(GetPName.BlendDstAlpha, out lastBlendDstAlpha);
int lastBlendEquationRgb; GL.GetInteger(GetPName.BlendEquationRgb, out lastBlendEquationRgb);
int lastBlendEquationAlpha; GL.GetInteger(GetPName.BlendEquationAlpha, out lastBlendEquationAlpha);
//Console.WriteLine(GL.GetError());
int[] lastViewport = new int[4]; GL.GetInteger(GetPName.Viewport, lastViewport);
int[] lastScissorBox = new int[4]; GL.GetInteger(GetPName.ScissorBox, lastScissorBox);
//Console.WriteLine(GL.GetError());
bool lastEnableBlend = GL.IsEnabled(EnableCap.Blend);
bool lastEnableCullFace = GL.IsEnabled(EnableCap.CullFace);
bool lastEnableDepthTest = GL.IsEnabled(EnableCap.DepthTest);
bool lastEnableScissorTest = GL.IsEnabled(EnableCap.ScissorTest);
GL.Enable(EnableCap.Blend);
GL.BlendEquation(BlendEquationMode.FuncAdd);
//GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.ScissorTest);
GL.Viewport(0, 0, fbWidth, fbHeight);
Matrix4 orthoProjection = new Matrix4(
2.0f / io.DisplaySize.X, 0.0f, 0.0f, 0.0f,
0.0f, 2.0f / -io.DisplaySize.Y, 0.0f, 0.0f,
0.0f, 0.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f);
GL.UseProgram(shaderHandle);
GL.Uniform1(attribLocationTex, 0);
GL.UniformMatrix4(attribLocationProjMtx, false, ref orthoProjection);
GL.BindVertexArray(vaoHandle);
for (int i = 0; i < drawData->CmdListsCount; i++)
{
NativeDrawList *cmdList = drawData->CmdLists[i];
ushort * idxBuffer = (ushort *)0;
GL.BindBuffer(BufferTarget.ArrayBuffer, vboHandle);
GL.BufferData(BufferTarget.ArrayBuffer, cmdList->VtxBuffer.Size * sizeof(DrawVert), new IntPtr(cmdList->VtxBuffer.Data), BufferUsageHint.StreamDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, elementsHandle);
GL.BufferData(BufferTarget.ElementArrayBuffer, cmdList->IdxBuffer.Size * sizeof(ushort *), new IntPtr(cmdList->IdxBuffer.Data), BufferUsageHint.StreamDraw);
for (int cmd_i = 0; cmd_i < cmdList->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &((DrawCmd *)cmdList->CmdBuffer.Data)[cmd_i];
if (pcmd->UserCallback != IntPtr.Zero)
{
Console.WriteLine("User callback not implemented");
throw new NotImplementedException();
}
else
{
//GL.BindTexture(TextureTarget.Texture2D, (int)pcmd->TextureId);
GL.BindTexture(TextureTarget.Texture2D, pcmd->TextureId.ToInt32());
GL.Scissor(
(int)pcmd->ClipRect.X,
(int)(fbHeight - pcmd->ClipRect.W),
(int)(pcmd->ClipRect.Z - pcmd->ClipRect.X),
(int)(pcmd->ClipRect.W - pcmd->ClipRect.Y));
GL.DrawElements(PrimitiveType.Triangles, (int)pcmd->ElemCount, DrawElementsType.UnsignedShort, new IntPtr(idxBuffer));
}
idxBuffer += pcmd->ElemCount;
}
}
GL.UseProgram(lastProgram);
GL.BindTexture(TextureTarget.Texture2D, lastTexture);
//Console.WriteLine(GL.GetError());
GL.ActiveTexture((TextureUnit)lastActiveTexture);
//Console.WriteLine(GL.GetError());
GL.BindVertexArray(lastVertexArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, lastArrayBuffer);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, lastElementArrayBuffer);
GL.BlendEquationSeparate((BlendEquationMode)lastBlendEquationRgb, (BlendEquationMode)lastBlendEquationAlpha);
GL.BlendFuncSeparate((ArbDrawBuffersBlend)lastBlendSrcRgb, (ArbDrawBuffersBlend)lastBlendDstRgb, (ArbDrawBuffersBlend)lastBlendSrcAlpha, (ArbDrawBuffersBlend)lastBlendDstAlpha);
if (lastEnableBlend)
{
GL.Enable(EnableCap.Blend);
}
else
{
GL.Disable(EnableCap.Blend);
}
if (lastEnableCullFace)
{
GL.Enable(EnableCap.CullFace);
}
else
{
GL.Disable(EnableCap.CullFace);
}
if (lastEnableDepthTest)
{
GL.Enable(EnableCap.DepthTest);
}
else
{
GL.Disable(EnableCap.DepthTest);
}
if (lastEnableScissorTest)
{
GL.Enable(EnableCap.ScissorTest);
}
else
{
GL.Disable(EnableCap.ScissorTest);
}
GL.Viewport(lastViewport[0], lastViewport[1], lastViewport[2], lastViewport[3]);
GL.Scissor(lastScissorBox[0], lastScissorBox[1], lastScissorBox[2], lastScissorBox[3]);
if (GL.GetError() != ErrorCode.NoError)
{
Console.WriteLine(GL.GetError());
//Debugger.Break();
}
}
}
public unsafe static void RenderDrawData(DrawData *drawData, int displayW, int displayH)
{
// We are using the OpenGL fixed pipeline to make the example code simpler to read!
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
int lastTexture;
GL.GetInteger(GetPName.TextureBinding2D, out lastTexture);
Int4 lastViewport = new Int4();
TypedReference tr = __makeref(lastViewport);
IntPtr ptr = **(IntPtr **)(&tr);
GL.GetInteger(GetPName.Viewport, (int *)ptr);
Int4 lastScissorBox = new Int4();
tr = __makeref(lastScissorBox);
ptr = **(IntPtr **)(&tr);
GL.GetInteger(GetPName.ScissorBox, (int *)ptr);
GL.PushAttrib(AttribMask.EnableBit | AttribMask.ColorBufferBit | AttribMask.TransformBit);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.ScissorTest);
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.EnableClientState(ArrayCap.ColorArray);
GL.Enable(EnableCap.Texture2D);
GL.UseProgram(0);
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
IO io = ImGui.GetIO();
ImGui.ScaleClipRects(drawData, io.DisplayFramebufferScale);
// Setup orthographic projection matrix
GL.Viewport(0, 0, displayW, displayH);
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix();
GL.LoadIdentity();
GL.Ortho(
0.0f,
io.DisplaySize.X / io.DisplayFramebufferScale.X,
io.DisplaySize.Y / io.DisplayFramebufferScale.Y,
0.0f,
-1.0f,
1.0f
);
GL.MatrixMode(MatrixMode.Modelview);
GL.PushMatrix();
GL.LoadIdentity();
// Render command lists
for (int n = 0; n < drawData->CmdListsCount; n++)
{
DrawList cmddList = new DrawList(drawData->CmdLists[n]);
NativeDrawList *cmdList = drawData->CmdLists[n];
ImVector vtxBuffer = cmdList->VtxBuffer;
ImVector idxBuffer = cmdList->IdxBuffer;
GL.VertexPointer(2, VertexPointerType.Float, sizeof(DrawVert),
new IntPtr((long)vtxBuffer.Data + DrawVert.PosOffset));
GL.TexCoordPointer(2, TexCoordPointerType.Float, sizeof(DrawVert),
new IntPtr((long)vtxBuffer.Data + DrawVert.UVOffset));
GL.ColorPointer(4, ColorPointerType.UnsignedByte, sizeof(DrawVert),
new IntPtr((long)vtxBuffer.Data + DrawVert.ColOffset));
long idxBufferOffset = 0;
for (int cmdi = 0; cmdi < cmdList->CmdBuffer.Size; cmdi++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmdList->CmdBuffer.Data)[cmdi]);
/* if (pcmd->UserCallback!= IntPtr.Zero) {
* pcmd->(ref cmdList, ref pcmd);
* } else {*/
GL.BindTexture(TextureTarget.Texture2D, (int)pcmd->TextureId);
GL.Scissor(
(int)pcmd->ClipRect.X,
(int)(io.DisplaySize.Y - pcmd->ClipRect.W),
(int)(pcmd->ClipRect.Z - pcmd->ClipRect.X),
(int)(pcmd->ClipRect.W - pcmd->ClipRect.Y)
);
GL.DrawElements(PrimitiveType.Triangles, (int)pcmd->ElemCount, DrawElementsType.UnsignedByte,
new IntPtr((long)idxBuffer.Data + idxBufferOffset));
idxBufferOffset += pcmd->ElemCount * 2 /*sizeof(ushort)*/;
}
}
// Restore modified state
GL.DisableClientState(ArrayCap.ColorArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.DisableClientState(ArrayCap.VertexArray);
GL.BindTexture(TextureTarget.Texture2D, lastTexture);
GL.MatrixMode(MatrixMode.Modelview);
GL.PopMatrix();
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix();
GL.PopAttrib();
GL.Viewport(lastViewport.X, lastViewport.Y, lastViewport.Z, lastViewport.W);
GL.Scissor(lastScissorBox.X, lastScissorBox.Y, lastScissorBox.Z, lastScissorBox.W);
}
public static unsafe void render(BasicEffect effect)
{
IO io = ImGui.GetIO();
ImGui.Render();
DrawData *draw_data = ImGui.GetDrawData();
var graphicsDevice = _game.GraphicsDevice;
graphicsDevice.DepthStencilState = DepthStencilState.None;
graphicsDevice.RasterizerState = new RasterizerState()
{
ScissorTestEnable = true, CullMode = CullMode.None
};
graphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
graphicsDevice.BlendState = BlendState.AlphaBlend;
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
ImGui.ScaleClipRects(draw_data, io.DisplayFramebufferScale);
//var effect = Assets.defaultEffect;
//effect.Texture = Assets.dummyTexture;
effect.World = Matrix.Identity;
effect.View = Matrix.Identity;// camera.viewMatrix3D;
effect.Projection =
Matrix.CreateOrthographicOffCenter(
0.0f,
io.DisplaySize.X / io.DisplayFramebufferScale.X,
io.DisplaySize.Y / io.DisplayFramebufferScale.Y,
0.0f,
-1.0f,
1.0f
);
// Render command lists
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[n];
DrawVert * vtx_buffer = (DrawVert *)cmd_list->VtxBuffer.Data;
ushort * idx_buffer = (ushort *)cmd_list->IdxBuffer.Data;
var vertexElements = cmd_list->VtxBuffer.Size;
var indexElements = cmd_list->IdxBuffer.Size;
var idxPos = 0;
if (vertices.Length < vertexElements)
{
vertices = new ImGuiVertex[vertexElements / 2 * 3];
_vertexBuffer.Dispose();
_vertexBuffer = new VertexBuffer(graphicsDevice, ImGuiVertex.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
}
for (int i = 0; i < vertexElements; i++)
{
DrawVert vert = *vtx_buffer++;
vertices[i].x = vert.pos.X;
vertices[i].y = vert.pos.Y;
vertices[i].tx = vert.uv.X;
vertices[i].ty = vert.uv.Y;
vertices[i].color = vert.col;
}
_vertexBuffer.SetData(vertices, 0, vertexElements);
if (indices.Length < indexElements)
{
indices = new short[indexElements / 2 * 3];
_indexBuffer.Dispose();
_indexBuffer = new IndexBuffer(graphicsDevice, IndexElementSize.SixteenBits, indices.Length, BufferUsage.WriteOnly);
}
for (int i = 0; i < indexElements; i++)
{
indices[i] = (short)idx_buffer[i];
}
_indexBuffer.SetData(indices, 0, indexElements);
graphicsDevice.Indices = _indexBuffer;
graphicsDevice.SetVertexBuffer(_vertexBuffer);
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmd_list->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
graphicsDevice.ScissorRectangle = new Rectangle((int)pcmd->ClipRect.X, (int)pcmd->ClipRect.Y, (int)(pcmd->ClipRect.Z - pcmd->ClipRect.X), (int)(pcmd->ClipRect.W - pcmd->ClipRect.Y));
if (pcmd->TextureId.ToInt32() == fontTexture.GetHashCode())
{
effect.Texture = fontTexture;
}
else
{
throw new NotImplementedException();
}
var primivites = (int)pcmd->ElemCount / 3;
foreach (var pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, idxPos, primivites);
//graphicsDevice.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, vertices, 0, vertexElements, indices, 0, indexElements / 3);
}
}
idxPos += (int)pcmd->ElemCount;
}
}
}
public override void Render(RenderContext context, DeviceContextProxy deviceContext)
{
if (Buffer == null || TextureView == null || spritePass.IsNULL)
{
return;
}
IO io = ImGui.GetIO();
float mouseWheel = io.MouseWheel;
ImGui.Render();
if (!UpdateBuffer(deviceContext))
{
return;
}
ProjectionMatrix = Matrix.OrthoOffCenterRH(
0f,
io.DisplaySize.X,
io.DisplaySize.Y,
0.0f,
-1.0f,
1.0f);
int slot = 0;
if (!Buffer.AttachBuffers(deviceContext, ref slot, EffectTechnique.EffectsManager))
{
return;
}
var globalTrans = context.GlobalTransform;
globalTrans.Projection = ProjectionMatrix;
globalTransformCB.Upload(deviceContext, ref globalTrans);
spritePass.BindShader(deviceContext);
spritePass.BindStates(deviceContext, StateType.All);
spritePass.PixelShader.BindTexture(deviceContext, texSlot, TextureView);
spritePass.PixelShader.BindSampler(deviceContext, samplerSlot, sampler);
deviceContext.SetViewport(0, 0, io.DisplaySize.X, io.DisplaySize.Y);
#region Render
unsafe
{
var draw_data = ImGui.GetDrawData();
int idx_offset = 0;
int vtx_offset = 0;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
NativeDrawList *cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
DrawCmd *pcmd = &(((DrawCmd *)cmd_list->CmdBuffer.Data)[cmd_i]);
if (pcmd->UserCallback != IntPtr.Zero)
{
}
else
{
deviceContext.SetScissorRectangle(
(int)pcmd->ClipRect.X,
(int)pcmd->ClipRect.Y,
(int)(pcmd->ClipRect.Z),
(int)(pcmd->ClipRect.W));
deviceContext.DrawIndexed((int)pcmd->ElemCount,
idx_offset, vtx_offset);
}
idx_offset += (int)pcmd->ElemCount;
}
vtx_offset += cmd_list->VtxBuffer.Size;
}
#endregion
}
io.MouseWheel = mouseWheel;
ImGui.NewFrame();
io.MouseWheel = 0;
RaiseInvalidateRender();
}
private unsafe void ImGuiRenderDraw(DrawData *drawData)
{
if (drawData == null)
{
return;
}
var io = ImGui.GetIO();
if (io.DisplaySize.X <= 0.0f || io.DisplaySize.Y <= 0.0f)
{
return;
}
var st = new StateBlock(device, StateBlockType.All);
var vp = new Viewport();
vp.X = vp.Y = 0;
vp.Width = (int)io.DisplaySize.X;
vp.Height = (int)io.DisplaySize.Y;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
device.Viewport = vp;
device.PixelShader = null;
device.VertexShader = null;
device.SetRenderState(RenderState.CullMode, Cull.None);
device.SetRenderState(RenderState.Lighting, false);
device.SetRenderState(RenderState.ZEnable, false);
device.SetRenderState(RenderState.AlphaBlendEnable, true);
device.SetRenderState(RenderState.AlphaTestEnable, false);
device.SetRenderState(RenderState.BlendOperation, BlendOperation.Add);
device.SetRenderState(RenderState.SourceBlend, Blend.SourceAlpha);
device.SetRenderState(RenderState.DestinationBlend, Blend.BothInverseSourceAlpha);
device.SetRenderState(RenderState.ScissorTestEnable, true);
device.SetTextureStageState(0, TextureStage.ColorOperation, TextureOperation.Modulate);
device.SetTextureStageState(0, TextureStage.ColorArg1, TextureArgument.Texture);
device.SetTextureStageState(0, TextureStage.ColorArg2, TextureArgument.Diffuse);
device.SetTextureStageState(0, TextureStage.AlphaOperation, TextureOperation.Modulate);
device.SetTextureStageState(0, TextureStage.AlphaArg1, TextureArgument.Texture);
device.SetTextureStageState(0, TextureStage.AlphaArg2, TextureArgument.Diffuse);
device.SetSamplerState(0, SamplerState.MinFilter, TextureFilter.Linear);
device.SetSamplerState(0, SamplerState.MagFilter, TextureFilter.Linear);
// Setup orthographic projection matrix
{
const float L = 0.5f;
float R = io.DisplaySize.X + 0.5f;
const float T = 0.5f;
float B = io.DisplaySize.Y + 0.5f;
RawMatrix mat_identity = new Matrix(1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
RawMatrix mat_projection = new Matrix(
2.0f / (R - L), 0.0f, 0.0f, 0.0f,
0.0f, 2.0f / (T - B), 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
(L + R) / (L - R), (T + B) / (B - T), 0.5f, 1.0f);
device.SetTransform(TransformState.World, ref mat_identity);
device.SetTransform(TransformState.View, ref mat_identity);
device.SetTransform(TransformState.Projection, ref mat_projection);
}
using (device.VertexDeclaration = new VertexDeclaration(device, GuiVertex.VertexElements))
{
for (var n = 0; n < drawData->CmdListsCount; n++)
{
NativeDrawList *cmdList = drawData->CmdLists[n];
DrawVert * vtx_buffer = (DrawVert *)cmdList->VtxBuffer.Data;
ushort * idx_buffer = (ushort *)cmdList->IdxBuffer.Data;
var myCustomVertices = new GuiVertex[cmdList->VtxBuffer.Size];
for (var i = 0; i < myCustomVertices.Length; i++)
{
var cl = (vtx_buffer[i].col & 0xFF00FF00) | ((vtx_buffer[i].col & 0xFF0000) >> 16) | ((vtx_buffer[i].col & 0xFF) << 16);
myCustomVertices[i] =
new GuiVertex(vtx_buffer[i].pos.X, vtx_buffer[i].pos.Y, vtx_buffer[i].uv.X, vtx_buffer[i].uv.Y, cl);
}
for (var i = 0; i < cmdList->CmdBuffer.Size; i++)
{
DrawCmd *pcmd = &((DrawCmd *)cmdList->CmdBuffer.Data)[i];
if (pcmd->UserCallback != IntPtr.Zero)
{
throw new NotImplementedException();
}
else
{
device.SetTexture(0, new Texture(pcmd->TextureId));
device.ScissorRect = new RectangleF((int)pcmd->ClipRect.X,
(int)pcmd->ClipRect.Y,
(int)(pcmd->ClipRect.Z - pcmd->ClipRect.X),
(int)(pcmd->ClipRect.W - pcmd->ClipRect.Y));
ushort[] indices = new ushort[pcmd->ElemCount];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = idx_buffer[j];
}
device.DrawIndexedUserPrimitives(PrimitiveType.TriangleList, 0, myCustomVertices.Length, (int)(pcmd->ElemCount / 3), indices, Format.Index16, myCustomVertices);
}
idx_buffer += pcmd->ElemCount;
}
}
}
st.Apply();
st.Dispose();
}
private static unsafe void renderDrawData(DrawData *drawData)
{
// scale coordinates for retina displays
IO io = ImGui.GetIO();
int fbWidth = (int)(io.DisplaySize.X * io.DisplayFramebufferScale.X);
int fbHeight = (int)(io.DisplaySize.Y * io.DisplayFramebufferScale.Y);
if (fbWidth < 0 || fbHeight < 0)
{
return;
}
ImGui.ScaleClipRects(drawData, io.DisplayFramebufferScale);
// backup GL state
GL.GetInteger(GetPName.ActiveTexture, out int lastActiveTexture);
GL.ActiveTexture(TextureUnit.Texture0);
GL.GetInteger(GetPName.CurrentProgram, out int lastProgram);
GL.GetInteger(GetPName.TextureBinding2D, out int lastTexture);
GL.GetInteger(GetPName.SamplerBinding, out int lastSampler);
GL.GetInteger(GetPName.ArrayBufferBinding, out int lastArrayBuffer);
GL.GetInteger(GetPName.VertexArrayBinding, out int lastVertexArray);
int[] lastPolygonMode = new int[2]; GL.GetInteger(GetPName.PolygonMode, lastPolygonMode);
int[] lastViewport = new int[4]; GL.GetInteger(GetPName.Viewport, lastViewport);
int[] lastScissorBox = new int[4]; GL.GetInteger(GetPName.ScissorBox, lastScissorBox);
GL.GetInteger(GetPName.BlendSrcRgb, out int lastBlendSrcRgb);
GL.GetInteger(GetPName.BlendDstRgb, out int lastBlendDstRgb);
GL.GetInteger(GetPName.BlendSrcAlpha, out int lastBlendSrcAlpha);
GL.GetInteger(GetPName.BlendDstAlpha, out int lastBlendDstAlpha);
GL.GetInteger(GetPName.BlendEquationRgb, out int lastBlendEquationRgb);
GL.GetInteger(GetPName.BlendEquationAlpha, out int lastBlendEquationAlpha);
bool lastEnableBlend = GL.IsEnabled(EnableCap.Blend);
bool lastEnableCullFace = GL.IsEnabled(EnableCap.CullFace);
bool lastEnableDepthTest = GL.IsEnabled(EnableCap.DepthTest);
bool lastEnableScissorTest = GL.IsEnabled(EnableCap.ScissorTest);
// setup GL state
GL.Enable(EnableCap.Blend);
GL.BlendEquation(BlendEquationMode.FuncAdd);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.ScissorTest);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
// setup viewport with orthographic projecton matrix
GL.Viewport(0, 0, fbWidth, fbHeight);
float l = 0;
float r = io.DisplaySize.X;
float t = 0;
float b = io.DisplaySize.Y;
Matrix4 orthoProjection = new Matrix4(
2.0f / (r - l), 0, 0, 0,
0, 2.0f / (t - b), 0, 0,
0, 0, -1.0f, 0,
(r + l) / (l - r), (t + b) / (b - t), 0, 1.0f
);
GL.UseProgram(_programHandle);
GL.Uniform1(_attribLocationTex, 0);
GL.UniformMatrix4(_attribLocationProjMtx, false, ref orthoProjection);
GL.BindSampler(0, 0);
// recreate the VAO every time
int vaoHandle = GL.GenVertexArray();
GL.BindVertexArray(vaoHandle);
GL.BindBuffer(BufferTarget.ArrayBuffer, _vboHandle);
GL.EnableVertexAttribArray(_attribLocationPosition);
GL.EnableVertexAttribArray(_attribLocationUV);
GL.EnableVertexAttribArray(_attribLocationColor);
GL.VertexAttribPointer(_attribLocationPosition, 2, VertexAttribPointerType.Float, false,
ImGuiVert.Size,
ImGuiVert.PosOffset);
GL.VertexAttribPointer(_attribLocationUV, 2, VertexAttribPointerType.Float, false,
ImGuiVert.Size,
ImGuiVert.UVOffset);
GL.VertexAttribPointer(_attribLocationColor, 4, VertexAttribPointerType.UnsignedByte, false,
ImGuiVert.Size,
ImGuiVert.ColOffset);
// draw
Vector2 pos = new Vector2(l, t);
for (int n = 0; n < drawData->CmdListsCount; n++)
{
var cmdList = drawData->CmdLists[n];
int indexBufferOffset = 0;
GL.BindBuffer(BufferTarget.ArrayBuffer, _vboHandle);
GL.BufferData(BufferTarget.ArrayBuffer, cmdList->VtxBuffer.Size * ImGuiVert.Size,
new IntPtr(cmdList->VtxBuffer.Data), BufferUsageHint.StreamDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _elementsHandle);
GL.BufferData(BufferTarget.ElementArrayBuffer, cmdList->IdxBuffer.Size * sizeof(ushort),
new IntPtr(cmdList->IdxBuffer.Data), BufferUsageHint.StreamDraw);
DrawCmd *cmds = (DrawCmd *)cmdList->CmdBuffer.Data;
for (int cmdIndex = 0; cmdIndex < cmdList->CmdBuffer.Size; cmdIndex++)
{
DrawCmd *drawCmd = &cmds[cmdIndex];
Vector4 clipRect = new Vector4(
drawCmd->ClipRect.X - pos.X,
drawCmd->ClipRect.Y - pos.Y,
drawCmd->ClipRect.Z - pos.X,
drawCmd->ClipRect.W - pos.Y
);
GL.Scissor((int)clipRect.X, (int)(fbHeight - clipRect.W), (int)(clipRect.Z - clipRect.X),
(int)(clipRect.W - clipRect.Y));
GL.BindTexture(TextureTarget.Texture2D, drawCmd->TextureId.ToInt32());
GL.DrawElements(BeginMode.Triangles, (int)drawCmd->ElemCount,
DrawElementsType.UnsignedShort,
indexBufferOffset);
indexBufferOffset += (int)drawCmd->ElemCount * 2;
}
}
GL.DeleteVertexArray(vaoHandle);
// restore modified GL state
GL.UseProgram(lastProgram);
GL.BindTexture(TextureTarget.Texture2D, lastTexture);
GL.BindSampler(0, lastSampler);
GL.ActiveTexture((TextureUnit)lastActiveTexture);
GL.BindVertexArray(lastVertexArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, lastArrayBuffer);
GL.BlendEquationSeparate((BlendEquationMode)lastBlendEquationRgb,
(BlendEquationMode)lastBlendEquationAlpha);
GL.BlendFuncSeparate((BlendingFactorSrc)lastBlendSrcRgb, (BlendingFactorDest)lastBlendDstRgb,
(BlendingFactorSrc)lastBlendSrcAlpha, (BlendingFactorDest)lastBlendDstAlpha);
if (lastEnableBlend)
{
GL.Enable(EnableCap.Blend);
}
else
{
GL.Disable(EnableCap.Blend);
}
if (lastEnableCullFace)
{
GL.Enable(EnableCap.CullFace);
}
else
{
GL.Disable(EnableCap.CullFace);
}
if (lastEnableDepthTest)
{
GL.Enable(EnableCap.DepthTest);
}
else
{
GL.Disable(EnableCap.DepthTest);
}
if (lastEnableScissorTest)
{
GL.Enable(EnableCap.ScissorTest);
}
else
{
GL.Disable(EnableCap.ScissorTest);
}
GL.PolygonMode(MaterialFace.FrontAndBack, (PolygonMode)lastPolygonMode[0]);
GL.Viewport(lastViewport[0], lastViewport[1], lastViewport[2], lastViewport[3]);
GL.Scissor(lastScissorBox[0], lastScissorBox[1], lastScissorBox[2], lastScissorBox[3]);
}
