diff --git a/examples/directx11_example/imgui_impl_dx11.cpp b/examples/directx11_example/imgui_impl_dx11.cpp index a5f61ba7..fb59efd9 100644 --- a/examples/directx11_example/imgui_impl_dx11.cpp +++ b/examples/directx11_example/imgui_impl_dx11.cpp @@ -50,13 +50,13 @@ static void ImGui_ImplDX11_RenderDrawLists(ImDrawData* draw_data) return; ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData; ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - memcpy(vtx_dst, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert)); - memcpy(idx_dst, &cmd_list->idx_buffer[0], cmd_list->idx_buffer.size() * sizeof(ImDrawIdx)); - vtx_dst += cmd_list->vtx_buffer.size(); - idx_dst += cmd_list->idx_buffer.size(); + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + memcpy(vtx_dst, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert)); + memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx)); + vtx_dst += cmd_list->VtxBuffer.size(); + idx_dst += cmd_list->IdxBuffer.size(); } g_pd3dDeviceContext->Unmap(g_pVB, 0); g_pd3dDeviceContext->Unmap(g_pIB, 0); @@ -116,26 +116,26 @@ static void ImGui_ImplDX11_RenderDrawLists(ImDrawData* draw_data) // Render command lists int vtx_offset = 0; int idx_offset = 0; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - for (int cmd_i = 0; cmd_i < cmd_list->cmd_buffer.size(); cmd_i++) + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) { - const ImDrawCmd* pcmd = &cmd_list->cmd_buffer[cmd_i]; - if (pcmd->user_callback) + const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; + if (pcmd->UserCallback) { - pcmd->user_callback(cmd_list, pcmd); + pcmd->UserCallback(cmd_list, pcmd); } else { - const D3D11_RECT r = { (LONG)pcmd->clip_rect.x, (LONG)pcmd->clip_rect.y, (LONG)pcmd->clip_rect.z, (LONG)pcmd->clip_rect.w }; - g_pd3dDeviceContext->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&pcmd->texture_id); + const D3D11_RECT r = { (LONG)pcmd->ClipRect.x, (LONG)pcmd->ClipRect.y, (LONG)pcmd->ClipRect.z, (LONG)pcmd->ClipRect.w }; + g_pd3dDeviceContext->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&pcmd->TextureId); g_pd3dDeviceContext->RSSetScissorRects(1, &r); - g_pd3dDeviceContext->DrawIndexed(pcmd->elem_count, idx_offset, vtx_offset); + g_pd3dDeviceContext->DrawIndexed(pcmd->ElemCount, idx_offset, vtx_offset); } - idx_offset += pcmd->elem_count; + idx_offset += pcmd->ElemCount; } - vtx_offset += (int)cmd_list->vtx_buffer.size(); + vtx_offset += cmd_list->VtxBuffer.size(); } // Restore modified state diff --git a/examples/directx9_example/imgui_impl_dx9.cpp b/examples/directx9_example/imgui_impl_dx9.cpp index cc52bbb1..ae26eed9 100644 --- a/examples/directx9_example/imgui_impl_dx9.cpp +++ b/examples/directx9_example/imgui_impl_dx9.cpp @@ -35,15 +35,15 @@ static void ImGui_ImplDX9_RenderDrawLists(ImDrawData* draw_data) // Copy and convert all vertices into a single contiguous buffer CUSTOMVERTEX* vtx_dst; ImDrawIdx* idx_dst; - if (g_pVB->Lock(0, (UINT)(draw_data->total_vtx_count * sizeof(CUSTOMVERTEX)), (void**)&vtx_dst, D3DLOCK_DISCARD) < 0) + if (g_pVB->Lock(0, (UINT)(draw_data->TotalVtxCount * sizeof(CUSTOMVERTEX)), (void**)&vtx_dst, D3DLOCK_DISCARD) < 0) return; - if (g_pIB->Lock(0, (UINT)(draw_data->total_idx_count * sizeof(ImDrawIdx)), (void**)&idx_dst, D3DLOCK_DISCARD) < 0) + if (g_pIB->Lock(0, (UINT)(draw_data->TotalIdxCount * sizeof(ImDrawIdx)), (void**)&idx_dst, D3DLOCK_DISCARD) < 0) return; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - const ImDrawVert* vtx_src = &cmd_list->vtx_buffer[0]; - for (int i = 0; i < cmd_list->vtx_buffer.size(); i++) + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + const ImDrawVert* vtx_src = &cmd_list->VtxBuffer[0]; + for (int i = 0; i < cmd_list->VtxBuffer.size(); i++) { vtx_dst->pos.x = vtx_src->pos.x; vtx_dst->pos.y = vtx_src->pos.y; @@ -54,8 +54,8 @@ static void ImGui_ImplDX9_RenderDrawLists(ImDrawData* draw_data) vtx_dst++; vtx_src++; } - memcpy(idx_dst, &cmd_list->idx_buffer[0], cmd_list->idx_buffer.size() * sizeof(ImDrawIdx)); - idx_dst += cmd_list->idx_buffer.size(); + memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx)); + idx_dst += cmd_list->IdxBuffer.size(); } g_pVB->Unlock(); g_pIB->Unlock(); @@ -94,26 +94,26 @@ static void ImGui_ImplDX9_RenderDrawLists(ImDrawData* draw_data) // Render command lists int vtx_offset = 0; int idx_offset = 0; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - for (int cmd_i = 0; cmd_i < cmd_list->cmd_buffer.size(); cmd_i++) + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) { - const ImDrawCmd* pcmd = &cmd_list->cmd_buffer[cmd_i]; - if (pcmd->user_callback) + const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; + if (pcmd->UserCallback) { - pcmd->user_callback(cmd_list, pcmd); + pcmd->UserCallback(cmd_list, pcmd); } else { - const RECT r = { (LONG)pcmd->clip_rect.x, (LONG)pcmd->clip_rect.y, (LONG)pcmd->clip_rect.z, (LONG)pcmd->clip_rect.w }; - g_pd3dDevice->SetTexture( 0, (LPDIRECT3DTEXTURE9)pcmd->texture_id ); + const RECT r = { (LONG)pcmd->ClipRect.x, (LONG)pcmd->ClipRect.y, (LONG)pcmd->ClipRect.z, (LONG)pcmd->ClipRect.w }; + g_pd3dDevice->SetTexture( 0, (LPDIRECT3DTEXTURE9)pcmd->TextureId ); g_pd3dDevice->SetScissorRect(&r); - g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, vtx_offset, 0, (UINT)cmd_list->vtx_buffer.size(), idx_offset, pcmd->elem_count/3); + g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, vtx_offset, 0, (UINT)cmd_list->VtxBuffer.size(), idx_offset, pcmd->ElemCount/3); } - idx_offset += pcmd->elem_count; + idx_offset += pcmd->ElemCount; } - vtx_offset += (int)cmd_list->vtx_buffer.size(); + vtx_offset += cmd_list->VtxBuffer.size(); } } diff --git a/examples/opengl3_example/imgui_impl_glfw_gl3.cpp b/examples/opengl3_example/imgui_impl_glfw_gl3.cpp index ce300c41..0090f9d6 100644 --- a/examples/opengl3_example/imgui_impl_glfw_gl3.cpp +++ b/examples/opengl3_example/imgui_impl_glfw_gl3.cpp @@ -59,7 +59,7 @@ static void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawData* draw_data) // Grow our buffer according to what we need glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); - int needed_vtx_size = draw_data->total_vtx_count * sizeof(ImDrawVert); + int needed_vtx_size = draw_data->TotalVtxCount * sizeof(ImDrawVert); if (g_VboSize < needed_vtx_size) { g_VboSize = needed_vtx_size + 5000 * sizeof(ImDrawVert); // Grow buffer @@ -70,38 +70,38 @@ static void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawData* draw_data) unsigned char* vtx_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); if (!vtx_data) return; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - memcpy(vtx_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert)); - vtx_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert); + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + memcpy(vtx_data, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert)); + vtx_data += cmd_list->VtxBuffer.size() * sizeof(ImDrawVert); } glUnmapBuffer(GL_ARRAY_BUFFER); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(g_VaoHandle); int vtx_offset = 0; - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - const ImDrawIdx* idx_buffer = (const unsigned short*)&cmd_list->idx_buffer.front(); + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front(); - const ImDrawCmd* pcmd_end = cmd_list->cmd_buffer.end(); - for (const ImDrawCmd* pcmd = cmd_list->cmd_buffer.begin(); pcmd != pcmd_end; pcmd++) + const ImDrawCmd* pcmd_end = cmd_list->CmdBuffer.end(); + for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != pcmd_end; pcmd++) { - if (pcmd->user_callback) + if (pcmd->UserCallback) { - pcmd->user_callback(cmd_list, pcmd); + pcmd->UserCallback(cmd_list, pcmd); } else { - glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->texture_id); - glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w), (int)(pcmd->clip_rect.z - pcmd->clip_rect.x), (int)(pcmd->clip_rect.w - pcmd->clip_rect.y)); - glDrawElementsBaseVertex(GL_TRIANGLES, (GLsizei)pcmd->elem_count, GL_UNSIGNED_SHORT, idx_buffer, vtx_offset); + glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); + glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); + glDrawElementsBaseVertex(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer, vtx_offset); } - idx_buffer += pcmd->elem_count; + idx_buffer += pcmd->ElemCount; } - vtx_offset += (int)cmd_list->vtx_buffer.size(); + vtx_offset += cmd_list->VtxBuffer.size(); } // Restore modified state diff --git a/examples/opengl_example/imgui_impl_glfw.cpp b/examples/opengl_example/imgui_impl_glfw.cpp index 246a8265..8338091e 100644 --- a/examples/opengl_example/imgui_impl_glfw.cpp +++ b/examples/opengl_example/imgui_impl_glfw.cpp @@ -53,29 +53,29 @@ static void ImGui_ImplGlfw_RenderDrawLists(ImDrawData* draw_data) // Render command lists #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT)) - for (int n = 0; n < draw_data->cmd_lists_count; n++) + for (int n = 0; n < draw_data->CmdListsCount; n++) { - const ImDrawList* cmd_list = draw_data->cmd_lists[n]; - const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->vtx_buffer.front(); - const ImDrawIdx* idx_buffer = (const unsigned short*)&cmd_list->idx_buffer.front(); + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front(); + const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front(); glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos))); glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv))); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col))); - for (int cmd_i = 0; cmd_i < cmd_list->cmd_buffer.size(); cmd_i++) + for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) { - const ImDrawCmd* pcmd = &cmd_list->cmd_buffer[cmd_i]; - if (pcmd->user_callback) + const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; + if (pcmd->UserCallback) { - pcmd->user_callback(cmd_list, pcmd); + pcmd->UserCallback(cmd_list, pcmd); } else { - glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->texture_id); - glScissor((int)pcmd->clip_rect.x, (int)(height - pcmd->clip_rect.w), (int)(pcmd->clip_rect.z - pcmd->clip_rect.x), (int)(pcmd->clip_rect.w - pcmd->clip_rect.y)); - glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->elem_count, GL_UNSIGNED_SHORT, idx_buffer); + glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); + glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); + glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer); } - idx_buffer += pcmd->elem_count; + idx_buffer += pcmd->ElemCount; } } #undef OFFSETOF diff --git a/imgui.cpp b/imgui.cpp index 27b3a5dd..a492f539 100644 --- a/imgui.cpp +++ b/imgui.cpp @@ -141,18 +141,19 @@ - 2015/07/07 (1.42) - switched rendering data to use indexed rendering. this is saving a fair amount of CPU/GPU and enables us to get anti-aliasing for a marginal cost. this necessary change will break your rendering function! the fix should be very easy. sorry for that :( - if you are using a vanilla copy of one of the imgui_impl_XXXX.cpp provided in the example, you just need to update your copy and you can ignore the rest. - - the signature of io.RenderDrawListsFn has changed! + - the signature of the io.RenderDrawListsFn handler has changed! ImGui_XXXX_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count) became: ImGui_XXXX_RenderDrawLists(ImDrawData* draw_data). - argument 'cmd_lists' -> 'draw_data->cmd_lists' - argument 'cmd_lists_count' -> 'draw_data->cmd_lists_count' - ImDrawList 'commands' -> 'cmd_buffer' - ImDrawCmd 'vtx_count' -> 'elem_count' (same value, multiple of 3) - - the ImDrawList and ImDrawCmd structures also have changed to allow for indexed rendering. - each ImDrawList now contains both a vertex buffer (vtx_buffer) and an index buffer (idx_buffer). For each command, render elem_count/3 triangles using indices from the index buffer. + argument 'cmd_lists' -> 'draw_data->CmdLists' + argument 'cmd_lists_count' -> 'draw_data->CmdListsCount' + ImDrawList 'commands' -> 'CmdBuffer' + ImDrawList 'vtx_buffer' -> 'VtxBuffer' + ImDrawList -> 'IdxBuffer' (new) + ImDrawCmd 'vtx_count' -> 'ElemCount' + - each ImDrawList now contains both a vertex buffer and an index buffer. For each command, render ElemCount/3 triangles using indices from the index buffer. - if you REALLY cannot render indexed primitives, you can call the draw_data->DeIndexAllBuffers() method to de-index your buffer. This is slow and a waste of CPU/GPU. Prefer using indexed rendering! - - refer to code in the examples/ folder or ask on the github if you are unsure of how to upgrade. + - refer to code in the examples/ folder or ask on the GitHub if you are unsure of how to upgrade. please upgrade! - removed the 'thickness' parameter from ImDrawList::AddLine(). - 2015/07/02 (1.42) - renamed SetScrollPosHere() to SetScrollFromCursorPos(). Kept inline redirection function (will obsolete). - 2015/07/02 (1.42) - renamed GetScrollPosY() to GetScrollY(). Necessary to reduce confusion along with other scrolling functions, because positions (e.g. cursor position) are not equivalent to scrolling amount. @@ -1412,7 +1413,7 @@ struct ImGuiState PrivateClipboard = NULL; ModalWindowDarkeningRatio = 0.0f; - OverlayDrawList.owner_name = "##Overlay"; // Give it a name for debugging + OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging MouseCursor = ImGuiMouseCursor_Arrow; LogEnabled = false; @@ -1833,7 +1834,7 @@ ImGuiWindow::ImGuiWindow(const char* name) DrawList = (ImDrawList*)ImGui::MemAlloc(sizeof(ImDrawList)); new(DrawList) ImDrawList(); - DrawList->owner_name = Name; + DrawList->_OwnerName = Name; RootWindow = NULL; RootNonPopupWindow = NULL; @@ -1903,13 +1904,13 @@ void ImGuiWindow::FocusItemUnregister() static inline void AddDrawListToRenderList(ImVector& out_render_list, ImDrawList* draw_list) { - if (!draw_list->cmd_buffer.empty() && !draw_list->vtx_buffer.empty()) + if (!draw_list->CmdBuffer.empty() && !draw_list->VtxBuffer.empty()) { - if (draw_list->cmd_buffer.back().elem_count == 0) - draw_list->cmd_buffer.pop_back(); + if (draw_list->CmdBuffer.back().ElemCount == 0) + draw_list->CmdBuffer.pop_back(); out_render_list.push_back(draw_list); - GImGui->IO.MetricsRenderVertices += draw_list->vtx_buffer.Size; - GImGui->IO.MetricsRenderIndices += draw_list->idx_buffer.Size; + GImGui->IO.MetricsRenderVertices += draw_list->VtxBuffer.Size; + GImGui->IO.MetricsRenderIndices += draw_list->IdxBuffer.Size; } } @@ -2400,7 +2401,7 @@ static void PopClipRect() { ImGuiWindow* window = GetCurrentWindow(); window->DrawList->PopClipRect(); - window->ClipRect = window->DrawList->clip_rect_stack.back(); + window->ClipRect = window->DrawList->_ClipRectStack.back(); } void ImGui::Render() @@ -2519,17 +2520,17 @@ void ImGui::Render() g.OverlayDrawList.AddImage(tex_id, pos, pos + size, cursor_data.TexUvMin[0], cursor_data.TexUvMax[0], 0xFFFFFFFF); // White fill g.OverlayDrawList.PopTextureID(); } - if (!g.OverlayDrawList.vtx_buffer.empty()) + if (!g.OverlayDrawList.VtxBuffer.empty()) AddDrawListToRenderList(g.RenderDrawLists[0], &g.OverlayDrawList); // Render if (!g.RenderDrawLists[0].empty()) { ImDrawData data; - data.cmd_lists = &g.RenderDrawLists[0][0]; - data.cmd_lists_count = g.RenderDrawLists[0].Size; - data.total_vtx_count = g.IO.MetricsRenderVertices; - data.total_idx_count = g.IO.MetricsRenderIndices; + data.CmdLists = &g.RenderDrawLists[0][0]; + data.CmdListsCount = g.RenderDrawLists[0].Size; + data.TotalVtxCount = g.IO.MetricsRenderVertices; + data.TotalIdxCount = g.IO.MetricsRenderIndices; g.IO.RenderDrawListsFn(&data); } } @@ -8965,78 +8966,79 @@ static ImVec4 GNullClipRect(-9999.0f,-9999.0f, +9999.0f, +9999.0f); void ImDrawList::Clear() { - cmd_buffer.resize(0); - vtx_buffer.resize(0); - vtx_write = NULL; - vtx_current_idx = 0; - idx_buffer.resize(0); - idx_write = NULL; - channel_current = 0; - clip_rect_stack.resize(0); - texture_id_stack.resize(0); + CmdBuffer.resize(0); + IdxBuffer.resize(0); + VtxBuffer.resize(0); + _VtxCurrentIdx = 0; + _VtxWritePtr = NULL; + _IdxWritePtr = NULL; + _ClipRectStack.resize(0); + _TextureIdStack.resize(0); + _Path.resize(0); + _ChannelCurrent = 0; // NB: Do not clear channels so our allocations are re-used after the first frame. } void ImDrawList::ClearFreeMemory() { - cmd_buffer.clear(); - vtx_buffer.clear(); - vtx_write = NULL; - vtx_current_idx = 0; - idx_buffer.clear(); - idx_write = NULL; - channel_current = 0; - clip_rect_stack.clear(); - texture_id_stack.clear(); - for (int i = 0; i < channels.Size; i++) + CmdBuffer.clear(); + IdxBuffer.clear(); + VtxBuffer.clear(); + _VtxCurrentIdx = 0; + _VtxWritePtr = NULL; + _IdxWritePtr = NULL; + _ClipRectStack.clear(); + _TextureIdStack.clear(); + _Path.clear(); + _ChannelCurrent = 0; + for (int i = 0; i < _Channels.Size; i++) { - if (i == 0) memset(&channels[0], 0, sizeof(channels[0])); // channel 0 is a copy of cmd_buffer/idx_buffer, don't destruct again - channels[i].cmd_buffer.clear(); - channels[i].idx_buffer.clear(); + if (i == 0) memset(&_Channels[0], 0, sizeof(_Channels[0])); // channel 0 is a copy of CmdBuffer/IdxBuffer, don't destruct again + _Channels[i].CmdBuffer.clear(); + _Channels[i].IdxBuffer.clear(); } - channels.clear(); + _Channels.clear(); } void ImDrawList::AddDrawCmd() { ImDrawCmd draw_cmd; - draw_cmd.elem_count = 0; - draw_cmd.clip_rect = clip_rect_stack.empty() ? GNullClipRect : clip_rect_stack.back(); - draw_cmd.texture_id = texture_id_stack.empty() ? NULL : texture_id_stack.back(); - draw_cmd.user_callback = NULL; - draw_cmd.user_callback_data = NULL; + draw_cmd.ElemCount = 0; + draw_cmd.ClipRect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect; + draw_cmd.TextureId = _TextureIdStack.Size ? _TextureIdStack.back() : NULL; + draw_cmd.UserCallback = NULL; + draw_cmd.UserCallbackData = NULL; - IM_ASSERT(draw_cmd.clip_rect.x <= draw_cmd.clip_rect.z && draw_cmd.clip_rect.y <= draw_cmd.clip_rect.w); - cmd_buffer.push_back(draw_cmd); + IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w); + CmdBuffer.push_back(draw_cmd); } void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data) { - ImDrawCmd* current_cmd = cmd_buffer.Size ? &cmd_buffer.back() : NULL; - if (!current_cmd || current_cmd->elem_count != 0 || current_cmd->user_callback != NULL) + ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL; + if (!current_cmd || current_cmd->ElemCount != 0 || current_cmd->UserCallback != NULL) { AddDrawCmd(); - current_cmd = &cmd_buffer.back(); + current_cmd = &CmdBuffer.back(); } - current_cmd->user_callback = callback; - current_cmd->user_callback_data = callback_data; + current_cmd->UserCallback = callback; + current_cmd->UserCallbackData = callback_data; - // Force a new command after us - // We function this way so that the most common calls (AddLine, AddRect..) always have a command to add to without doing any check. + // Force a new command after us (we function this way so that the most common calls AddLine, AddRect, etc. always have a command to add to without doing any check). AddDrawCmd(); } void ImDrawList::ChannelsSplit(int channel_count) { - IM_ASSERT(channel_current == 0); - int old_channels_count = channels.Size; + IM_ASSERT(_ChannelCurrent == 0); + int old_channels_count = _Channels.Size; if (old_channels_count < channel_count) - channels.resize(channel_count); + _Channels.resize(channel_count); for (int i = 0; i < channel_count; i++) if (i >= old_channels_count) - new(&channels[i]) ImDrawChannel(); + new(&_Channels[i]) ImDrawChannel(); else - channels[i].cmd_buffer.resize(0), channels[i].idx_buffer.resize(0); + _Channels[i].CmdBuffer.resize(0), _Channels[i].IdxBuffer.resize(0); } void ImDrawList::ChannelsMerge(int channel_count) @@ -9047,64 +9049,64 @@ void ImDrawList::ChannelsMerge(int channel_count) return; ChannelsSetCurrent(0); - if (cmd_buffer.Size && cmd_buffer.back().elem_count == 0) - cmd_buffer.pop_back(); + if (CmdBuffer.Size && CmdBuffer.back().ElemCount == 0) + CmdBuffer.pop_back(); int new_cmd_buffer_count = 0, new_idx_buffer_count = 0; for (int i = 1; i < channel_count; i++) { - ImDrawChannel& ch = channels[i]; - if (ch.cmd_buffer.Size && ch.cmd_buffer.back().elem_count == 0) - ch.cmd_buffer.pop_back(); - new_cmd_buffer_count += ch.cmd_buffer.Size; - new_idx_buffer_count += ch.idx_buffer.Size; + ImDrawChannel& ch = _Channels[i]; + if (ch.CmdBuffer.Size && ch.CmdBuffer.back().ElemCount == 0) + ch.CmdBuffer.pop_back(); + new_cmd_buffer_count += ch.CmdBuffer.Size; + new_idx_buffer_count += ch.IdxBuffer.Size; } - cmd_buffer.resize(cmd_buffer.Size + new_cmd_buffer_count); - idx_buffer.resize(idx_buffer.Size + new_idx_buffer_count); + CmdBuffer.resize(CmdBuffer.Size + new_cmd_buffer_count); + IdxBuffer.resize(IdxBuffer.Size + new_idx_buffer_count); - ImDrawCmd* cmd_write = cmd_buffer.Data + cmd_buffer.Size - new_cmd_buffer_count; - idx_write = idx_buffer.Data + idx_buffer.Size - new_idx_buffer_count; + ImDrawCmd* cmd_write = CmdBuffer.Data + CmdBuffer.Size - new_cmd_buffer_count; + _IdxWritePtr = IdxBuffer.Data + IdxBuffer.Size - new_idx_buffer_count; for (int i = 1; i < channel_count; i++) { - ImDrawChannel& ch = channels[i]; - if (int sz = ch.cmd_buffer.Size) { memcpy(cmd_write, ch.cmd_buffer.Data, sz * sizeof(ImDrawCmd)); cmd_write += sz; } - if (int sz = ch.idx_buffer.Size) { memcpy(idx_write, ch.idx_buffer.Data, sz * sizeof(ImDrawIdx)); idx_write += sz; } + ImDrawChannel& ch = _Channels[i]; + if (int sz = ch.CmdBuffer.Size) { memcpy(cmd_write, ch.CmdBuffer.Data, sz * sizeof(ImDrawCmd)); cmd_write += sz; } + if (int sz = ch.IdxBuffer.Size) { memcpy(_IdxWritePtr, ch.IdxBuffer.Data, sz * sizeof(ImDrawIdx)); _IdxWritePtr += sz; } } AddDrawCmd(); } void ImDrawList::ChannelsSetCurrent(int idx) { - if (channel_current == idx) return; - memcpy(&channels.Data[channel_current].cmd_buffer, &cmd_buffer, sizeof(cmd_buffer)); - memcpy(&channels.Data[channel_current].idx_buffer, &idx_buffer, sizeof(idx_buffer)); - channel_current = idx; - memcpy(&cmd_buffer, &channels.Data[channel_current].cmd_buffer, sizeof(cmd_buffer)); - memcpy(&idx_buffer, &channels.Data[channel_current].idx_buffer, sizeof(idx_buffer)); - idx_write = idx_buffer.Data + idx_buffer.Size; + if (_ChannelCurrent == idx) return; + memcpy(&_Channels.Data[_ChannelCurrent].CmdBuffer, &CmdBuffer, sizeof(CmdBuffer)); + memcpy(&_Channels.Data[_ChannelCurrent].IdxBuffer, &IdxBuffer, sizeof(IdxBuffer)); + _ChannelCurrent = idx; + memcpy(&CmdBuffer, &_Channels.Data[_ChannelCurrent].CmdBuffer, sizeof(CmdBuffer)); + memcpy(&IdxBuffer, &_Channels.Data[_ChannelCurrent].IdxBuffer, sizeof(IdxBuffer)); + _IdxWritePtr = IdxBuffer.Data + IdxBuffer.Size; } void ImDrawList::UpdateClipRect() { - ImDrawCmd* current_cmd = cmd_buffer.Size ? &cmd_buffer.back() : NULL; - if (!current_cmd || (current_cmd->elem_count != 0) || current_cmd->user_callback != NULL) + ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL; + if (!current_cmd || (current_cmd->ElemCount != 0) || current_cmd->UserCallback != NULL) { AddDrawCmd(); } else { - ImVec4 current_clip_rect = clip_rect_stack.Size ? clip_rect_stack.back() : GNullClipRect; - if (cmd_buffer.Size >= 2 && ImLengthSqr(cmd_buffer.Data[cmd_buffer.Size-2].clip_rect - current_clip_rect) < 0.00001f) - cmd_buffer.pop_back(); + ImVec4 current_clip_rect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect; + if (CmdBuffer.Size >= 2 && ImLengthSqr(CmdBuffer.Data[CmdBuffer.Size-2].ClipRect - current_clip_rect) < 0.00001f) + CmdBuffer.pop_back(); else - current_cmd->clip_rect = current_clip_rect; + current_cmd->ClipRect = current_clip_rect; } } // Scissoring. The values in clip_rect are x1, y1, x2, y2. void ImDrawList::PushClipRect(const ImVec4& clip_rect) { - clip_rect_stack.push_back(clip_rect); + _ClipRectStack.push_back(clip_rect); UpdateClipRect(); } @@ -9119,46 +9121,46 @@ void ImDrawList::PushClipRectFullScreen() void ImDrawList::PopClipRect() { - IM_ASSERT(clip_rect_stack.Size > 0); - clip_rect_stack.pop_back(); + IM_ASSERT(_ClipRectStack.Size > 0); + _ClipRectStack.pop_back(); UpdateClipRect(); } void ImDrawList::UpdateTextureID() { - ImDrawCmd* current_cmd = cmd_buffer.Size ? &cmd_buffer.back() : NULL; - const ImTextureID texture_id = texture_id_stack.Size ? texture_id_stack.back() : NULL; - if (!current_cmd || (current_cmd->elem_count != 0 && current_cmd->texture_id != texture_id) || current_cmd->user_callback != NULL) + ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL; + const ImTextureID texture_id = _TextureIdStack.Size ? _TextureIdStack.back() : NULL; + if (!current_cmd || (current_cmd->ElemCount != 0 && current_cmd->TextureId != texture_id) || current_cmd->UserCallback != NULL) AddDrawCmd(); else - current_cmd->texture_id = texture_id; + current_cmd->TextureId = texture_id; } void ImDrawList::PushTextureID(const ImTextureID& texture_id) { - texture_id_stack.push_back(texture_id); + _TextureIdStack.push_back(texture_id); UpdateTextureID(); } void ImDrawList::PopTextureID() { - IM_ASSERT(texture_id_stack.Size > 0); - texture_id_stack.pop_back(); + IM_ASSERT(_TextureIdStack.Size > 0); + _TextureIdStack.pop_back(); UpdateTextureID(); } void ImDrawList::PrimReserve(int idx_count, int vtx_count) { - ImDrawCmd& draw_cmd = cmd_buffer.Data[cmd_buffer.Size-1]; - draw_cmd.elem_count += idx_count; + ImDrawCmd& draw_cmd = CmdBuffer.Data[CmdBuffer.Size-1]; + draw_cmd.ElemCount += idx_count; - int vtx_buffer_size = vtx_buffer.Size; - vtx_buffer.resize(vtx_buffer_size + vtx_count); - vtx_write = vtx_buffer.Data + vtx_buffer_size; + int vtx_buffer_size = VtxBuffer.Size; + VtxBuffer.resize(vtx_buffer_size + vtx_count); + _VtxWritePtr = VtxBuffer.Data + vtx_buffer_size; - int idx_buffer_size = idx_buffer.Size; - idx_buffer.resize(idx_buffer_size + idx_count); - idx_write = idx_buffer.Data + idx_buffer_size; + int idx_buffer_size = IdxBuffer.Size; + IdxBuffer.resize(idx_buffer_size + idx_count); + _IdxWritePtr = IdxBuffer.Data + idx_buffer_size; } void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col) @@ -9166,15 +9168,15 @@ void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col) const ImVec2 uv = GImGui->FontTexUvWhitePixel; const ImVec2 b(c.x, a.y); const ImVec2 d(a.x, c.y); - idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+2); - idx_write[3] = (ImDrawIdx)(vtx_current_idx); idx_write[4] = (ImDrawIdx)(vtx_current_idx+2); idx_write[5] = (ImDrawIdx)(vtx_current_idx+3); - vtx_write[0].pos = a; vtx_write[0].uv = uv; vtx_write[0].col = col; - vtx_write[1].pos = b; vtx_write[1].uv = uv; vtx_write[1].col = col; - vtx_write[2].pos = c; vtx_write[2].uv = uv; vtx_write[2].col = col; - vtx_write[3].pos = d; vtx_write[3].uv = uv; vtx_write[3].col = col; - vtx_write += 4; - vtx_current_idx += 4; - idx_write += 6; + _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2); + _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3); + _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; + _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col; + _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col; + _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col; + _VtxWritePtr += 4; + _VtxCurrentIdx += 4; + _IdxWritePtr += 6; } void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col) @@ -9183,15 +9185,15 @@ void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a const ImVec2 d(a.x, c.y); const ImVec2 uv_b(uv_c.x, uv_a.y); const ImVec2 uv_d(uv_a.x, uv_c.y); - idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+2); - idx_write[3] = (ImDrawIdx)(vtx_current_idx); idx_write[4] = (ImDrawIdx)(vtx_current_idx+2); idx_write[5] = (ImDrawIdx)(vtx_current_idx+3); - vtx_write[0].pos = a; vtx_write[0].uv = uv_a; vtx_write[0].col = col; - vtx_write[1].pos = b; vtx_write[1].uv = uv_b; vtx_write[1].col = col; - vtx_write[2].pos = c; vtx_write[2].uv = uv_c; vtx_write[2].col = col; - vtx_write[3].pos = d; vtx_write[3].uv = uv_d; vtx_write[3].col = col; - vtx_write += 4; - vtx_current_idx += 4; - idx_write += 6; + _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2); + _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3); + _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col; + _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col; + _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col; + _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col; + _VtxWritePtr += 4; + _VtxCurrentIdx += 4; + _IdxWritePtr += 6; } void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, bool closed, bool anti_aliased) @@ -9218,8 +9220,8 @@ void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 const int idx_count = count*12; const int vtx_count = points_count*3; PrimReserve(idx_count, vtx_count); - unsigned int vtx_inner_idx = vtx_current_idx+1; - unsigned int vtx_outer_idx = vtx_current_idx+2; + unsigned int vtx_inner_idx = _VtxCurrentIdx+1; + unsigned int vtx_outer_idx = _VtxCurrentIdx+2; // Temporary buffer ImVec2* temp_inner = (ImVec2*)alloca(points_count * 3 * sizeof(ImVec2)); @@ -9267,22 +9269,22 @@ void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 temp_inner[i2] = points[i2] - dm; // Add indexes - idx_write[0] = (ImDrawIdx)(vtx_current_idx + i2*3); idx_write[1] = (ImDrawIdx)(vtx_current_idx + i1*3); idx_write[2] = (ImDrawIdx)(vtx_outer_idx + i1*3); - idx_write[3] = (ImDrawIdx)(vtx_outer_idx + i1*3); idx_write[4] = (ImDrawIdx)(vtx_outer_idx + i2*3); idx_write[5] = (ImDrawIdx)(vtx_current_idx + i2*3); - idx_write[6] = (ImDrawIdx)(vtx_inner_idx + i2*3); idx_write[7] = (ImDrawIdx)(vtx_inner_idx + i1*3); idx_write[8] = (ImDrawIdx)(vtx_current_idx + i1*3); - idx_write[9] = (ImDrawIdx)(vtx_current_idx + i1*3); idx_write[10]= (ImDrawIdx)(vtx_current_idx + i2*3); idx_write[11]= (ImDrawIdx)(vtx_inner_idx + i2*3); - idx_write += 12; + _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx + i2*3); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + i1*3); _IdxWritePtr[2] = (ImDrawIdx)(vtx_outer_idx + i1*3); + _IdxWritePtr[3] = (ImDrawIdx)(vtx_outer_idx + i1*3); _IdxWritePtr[4] = (ImDrawIdx)(vtx_outer_idx + i2*3); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx + i2*3); + _IdxWritePtr[6] = (ImDrawIdx)(vtx_inner_idx + i2*3); _IdxWritePtr[7] = (ImDrawIdx)(vtx_inner_idx + i1*3); _IdxWritePtr[8] = (ImDrawIdx)(_VtxCurrentIdx + i1*3); + _IdxWritePtr[9] = (ImDrawIdx)(_VtxCurrentIdx + i1*3); _IdxWritePtr[10]= (ImDrawIdx)(_VtxCurrentIdx + i2*3); _IdxWritePtr[11]= (ImDrawIdx)(vtx_inner_idx + i2*3); + _IdxWritePtr += 12; } // Add vertexes for (int i = 0; i < points_count; i++) { - vtx_write[0].pos = points[i]; vtx_write[0].uv = uv; vtx_write[0].col = col; - vtx_write[1].pos = temp_inner[i]; vtx_write[1].uv = uv; vtx_write[1].col = col_trans; - vtx_write[2].pos = temp_outer[i]; vtx_write[2].uv = uv; vtx_write[2].col = col_trans; - vtx_write += 3; + _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; + _VtxWritePtr[1].pos = temp_inner[i]; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; + _VtxWritePtr[2].pos = temp_outer[i]; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col_trans; + _VtxWritePtr += 3; } - vtx_current_idx += (ImDrawIdx)vtx_count; + _VtxCurrentIdx += (ImDrawIdx)vtx_count; } else { @@ -9301,16 +9303,16 @@ void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 const float dx = diff.x * 0.5f; const float dy = diff.y * 0.5f; - vtx_write[0].pos.x = p1.x + dy; vtx_write[0].pos.y = p1.y - dx; vtx_write[0].uv = uv; vtx_write[0].col = col; - vtx_write[1].pos.x = p2.x + dy; vtx_write[1].pos.y = p2.y - dx; vtx_write[1].uv = uv; vtx_write[1].col = col; - vtx_write[2].pos.x = p2.x - dy; vtx_write[2].pos.y = p2.y + dx; vtx_write[2].uv = uv; vtx_write[2].col = col; - vtx_write[3].pos.x = p1.x - dy; vtx_write[3].pos.y = p1.y + dx; vtx_write[3].uv = uv; vtx_write[3].col = col; - vtx_write += 4; + _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; + _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col; + _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col; + _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col; + _VtxWritePtr += 4; - idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+2); - idx_write[3] = (ImDrawIdx)(vtx_current_idx); idx_write[4] = (ImDrawIdx)(vtx_current_idx+2); idx_write[5] = (ImDrawIdx)(vtx_current_idx+3); - idx_write += 6; - vtx_current_idx += 4; + _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2); + _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3); + _IdxWritePtr += 6; + _VtxCurrentIdx += 4; } } } @@ -9331,12 +9333,12 @@ void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_coun PrimReserve(idx_count, vtx_count); // Add indexes for fill - unsigned int vtx_inner_idx = vtx_current_idx; - unsigned int vtx_outer_idx = vtx_current_idx+1; + unsigned int vtx_inner_idx = _VtxCurrentIdx; + unsigned int vtx_outer_idx = _VtxCurrentIdx+1; for (int i = 2; i < points_count; i++) { - idx_write[0] = (ImDrawIdx)(vtx_inner_idx); idx_write[1] = (ImDrawIdx)(vtx_inner_idx+((i-1)<<1)); idx_write[2] = (ImDrawIdx)(vtx_inner_idx+(i<<1)); - idx_write += 3; + _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx+((i-1)<<1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_inner_idx+(i<<1)); + _IdxWritePtr += 3; } // Compute normals @@ -9367,16 +9369,16 @@ void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_coun dm *= AA_SIZE * 0.5f; // Add vertices - vtx_write[0].pos = (points[i1] - dm); vtx_write[0].uv = uv; vtx_write[0].col = col; // Inner - vtx_write[1].pos = (points[i1] + dm); vtx_write[1].uv = uv; vtx_write[1].col = col_trans; // Outer - vtx_write += 2; + _VtxWritePtr[0].pos = (points[i1] - dm); _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; // Inner + _VtxWritePtr[1].pos = (points[i1] + dm); _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans; // Outer + _VtxWritePtr += 2; // Add indexes for fringes - idx_write[0] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); idx_write[1] = (ImDrawIdx)(vtx_inner_idx+(i0<<1)); idx_write[2] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); - idx_write[3] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); idx_write[4] = (ImDrawIdx)(vtx_outer_idx+(i1<<1)); idx_write[5] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); - idx_write += 6; + _IdxWritePtr[0] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); _IdxWritePtr[1] = (ImDrawIdx)(vtx_inner_idx+(i0<<1)); _IdxWritePtr[2] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); + _IdxWritePtr[3] = (ImDrawIdx)(vtx_outer_idx+(i0<<1)); _IdxWritePtr[4] = (ImDrawIdx)(vtx_outer_idx+(i1<<1)); _IdxWritePtr[5] = (ImDrawIdx)(vtx_inner_idx+(i1<<1)); + _IdxWritePtr += 6; } - vtx_current_idx += (ImDrawIdx)vtx_count; + _VtxCurrentIdx += (ImDrawIdx)vtx_count; } else { @@ -9386,15 +9388,15 @@ void ImDrawList::AddConvexPolyFilled(const ImVec2* points, const int points_coun PrimReserve(idx_count, vtx_count); for (int i = 0; i < vtx_count; i++) { - vtx_write[0].pos = points[i]; vtx_write[0].uv = uv; vtx_write[0].col = col; - vtx_write++; + _VtxWritePtr[0].pos = points[i]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col; + _VtxWritePtr++; } for (int i = 2; i < points_count; i++) { - idx_write[0] = (ImDrawIdx)(vtx_current_idx); idx_write[1] = (ImDrawIdx)(vtx_current_idx+i-1); idx_write[2] = (ImDrawIdx)(vtx_current_idx+i); - idx_write += 3; + _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+i-1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+i); + _IdxWritePtr += 3; } - vtx_current_idx += (ImDrawIdx)vtx_count; + _VtxCurrentIdx += (ImDrawIdx)vtx_count; } } @@ -9417,15 +9419,15 @@ void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int amin, int if (amin > amax) return; if (radius == 0.0f) { - path.push_back(centre); + _Path.push_back(centre); } else { - path.reserve(path.Size + (amax - amin + 1)); + _Path.reserve(_Path.Size + (amax - amin + 1)); for (int a = amin; a <= amax; a++) { const ImVec2& c = circle_vtx[a % circle_vtx_count]; - path.push_back(ImVec2(centre.x + c.x * radius, centre.y + c.y * radius)); + _Path.push_back(ImVec2(centre.x + c.x * radius, centre.y + c.y * radius)); } } } @@ -9433,12 +9435,12 @@ void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int amin, int void ImDrawList::PathArcTo(const ImVec2& centre, float radius, float amin, float amax, int num_segments) { if (radius == 0.0f) - path.push_back(centre); - path.reserve(path.Size + (num_segments + 1)); + _Path.push_back(centre); + _Path.reserve(_Path.Size + (num_segments + 1)); for (int i = 0; i <= num_segments; i++) { const float a = amin + ((float)i / (float)num_segments) * (amax - amin); - path.push_back(ImVec2(centre.x + cosf(a + IM_PI) * radius, centre.y + sinf(a + IM_PI) * radius)); + _Path.push_back(ImVec2(centre.x + cosf(a + IM_PI) * radius, centre.y + sinf(a + IM_PI) * radius)); } } @@ -9541,17 +9543,17 @@ void ImDrawList::AddText(const ImFont* font, float font_size, const ImVec2& pos, if (text_begin == text_end) return; - IM_ASSERT(font->ContainerAtlas->TexID == texture_id_stack.back()); // Use high-level ImGui::PushFont() or low-level ImDrawList::PushTextureId() to change font. + IM_ASSERT(font->ContainerAtlas->TexID == _TextureIdStack.back()); // Use high-level ImGui::PushFont() or low-level ImDrawList::PushTextureId() to change font. // reserve vertices for worse case const int char_count = (int)(text_end - text_begin); const int vtx_count_max = char_count * 4; const int idx_count_max = char_count * 6; - const int vtx_begin = vtx_buffer.Size; - const int idx_begin = idx_buffer.Size; + const int vtx_begin = VtxBuffer.Size; + const int idx_begin = IdxBuffer.Size; PrimReserve(idx_count_max, vtx_count_max); - ImVec4 clip_rect = clip_rect_stack.back(); + ImVec4 clip_rect = _ClipRectStack.back(); if (cpu_fine_clip_rect) { clip_rect.x = ImMax(clip_rect.x, cpu_fine_clip_rect->x); @@ -9563,14 +9565,14 @@ void ImDrawList::AddText(const ImFont* font, float font_size, const ImVec2& pos, // give back unused vertices // FIXME-OPT - vtx_buffer.resize((int)(vtx_write - vtx_buffer.Data)); - idx_buffer.resize((int)(idx_write - idx_buffer.Data)); - int vtx_unused = vtx_count_max - (vtx_buffer.Size - vtx_begin); - int idx_unused = idx_count_max - (idx_buffer.Size - idx_begin); - cmd_buffer.back().elem_count -= idx_unused; - vtx_write -= vtx_unused; - idx_write -= idx_unused; - vtx_current_idx = (ImDrawIdx)vtx_buffer.Size; + VtxBuffer.resize((int)(_VtxWritePtr - VtxBuffer.Data)); + IdxBuffer.resize((int)(_IdxWritePtr - IdxBuffer.Data)); + int vtx_unused = vtx_count_max - (VtxBuffer.Size - vtx_begin); + int idx_unused = idx_count_max - (IdxBuffer.Size - idx_begin); + CmdBuffer.back().ElemCount -= idx_unused; + _VtxWritePtr -= vtx_unused; + _IdxWritePtr -= idx_unused; + _VtxCurrentIdx = (ImDrawIdx)VtxBuffer.Size; } void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col) @@ -9579,7 +9581,7 @@ void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const Im return; // FIXME-OPT: This is wasting draw calls. - const bool push_texture_id = texture_id_stack.empty() || user_texture_id != texture_id_stack.back(); + const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back(); if (push_texture_id) PushTextureID(user_texture_id); @@ -9598,18 +9600,18 @@ void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const Im void ImDrawData::DeIndexAllBuffers() { ImVector new_vtx_buffer; - total_vtx_count = total_idx_count = 0; - for (int i = 0; i < cmd_lists_count; i++) + TotalVtxCount = TotalIdxCount = 0; + for (int i = 0; i < CmdListsCount; i++) { - ImDrawList* cmd_list = cmd_lists[i]; - if (cmd_list->idx_buffer.empty()) + ImDrawList* cmd_list = CmdLists[i]; + if (cmd_list->IdxBuffer.empty()) continue; - new_vtx_buffer.resize(cmd_list->idx_buffer.Size); - for (int i = 0; i < cmd_list->idx_buffer.Size; i++) - new_vtx_buffer[i] = cmd_list->vtx_buffer[cmd_list->idx_buffer[i]]; - cmd_list->vtx_buffer.swap(new_vtx_buffer); - cmd_list->idx_buffer.resize(0); - total_vtx_count += cmd_list->vtx_buffer.Size; + new_vtx_buffer.resize(cmd_list->IdxBuffer.Size); + for (int i = 0; i < cmd_list->IdxBuffer.Size; i++) + new_vtx_buffer[i] = cmd_list->VtxBuffer[cmd_list->IdxBuffer[i]]; + cmd_list->VtxBuffer.swap(new_vtx_buffer); + cmd_list->IdxBuffer.resize(0); + TotalVtxCount += cmd_list->VtxBuffer.Size; } } @@ -10626,9 +10628,9 @@ void ImFont::RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_re const bool word_wrap_enabled = (wrap_width > 0.0f); const char* word_wrap_eol = NULL; - ImDrawVert* vtx_write = draw_list->vtx_write; - ImDrawIdx* idx_write = draw_list->idx_write; - unsigned int vtx_current_idx = draw_list->vtx_current_idx; + ImDrawVert* vtx_write = draw_list->_VtxWritePtr; + ImDrawIdx* idx_write = draw_list->_IdxWritePtr; + unsigned int vtx_current_idx = draw_list->_VtxCurrentIdx; const char* s = text_begin; if (!word_wrap_enabled && y + line_height < clip_rect.y) @@ -10761,9 +10763,9 @@ void ImFont::RenderText(float size, ImVec2 pos, ImU32 col, const ImVec4& clip_re x += char_width; } - draw_list->vtx_write = vtx_write; - draw_list->vtx_current_idx = vtx_current_idx; - draw_list->idx_write = idx_write; + draw_list->_VtxWritePtr = vtx_write; + draw_list->_VtxCurrentIdx = vtx_current_idx; + draw_list->_IdxWritePtr = idx_write; } //----------------------------------------------------------------------------- @@ -12295,7 +12297,7 @@ void ImGui::ShowMetricsWindow(bool* opened) { static void NodeDrawList(ImDrawList* draw_list, const char* label) { - bool node_opened = ImGui::TreeNode(draw_list, "%s: '%s' %d vtx, %d indices, %d cmds", label, draw_list->owner_name ? draw_list->owner_name : "", draw_list->vtx_buffer.Size, draw_list->idx_buffer.Size, draw_list->cmd_buffer.Size); + bool node_opened = ImGui::TreeNode(draw_list, "%s: '%s' %d vtx, %d indices, %d cmds", label, draw_list->_OwnerName ? draw_list->_OwnerName : "", draw_list->VtxBuffer.Size, draw_list->IdxBuffer.Size, draw_list->CmdBuffer.Size); if (draw_list == ImGui::GetWindowDrawList()) { ImGui::SameLine(); @@ -12305,18 +12307,18 @@ void ImGui::ShowMetricsWindow(bool* opened) return; int elem_offset = 0; - for (const ImDrawCmd* pcmd = draw_list->cmd_buffer.begin(); pcmd < draw_list->cmd_buffer.end(); elem_offset += pcmd->elem_count, pcmd++) - if (pcmd->user_callback) - ImGui::BulletText("Callback %p, user_data %p", pcmd->user_callback, pcmd->user_callback_data); + for (const ImDrawCmd* pcmd = draw_list->CmdBuffer.begin(); pcmd < draw_list->CmdBuffer.end(); elem_offset += pcmd->ElemCount, pcmd++) + if (pcmd->UserCallback) + ImGui::BulletText("Callback %p, user_data %p", pcmd->UserCallback, pcmd->UserCallbackData); else { - ImGui::BulletText("Draw %d indexed vtx, tex = %p, clip_rect = (%.0f,%.0f)..(%.0f,%.0f)", pcmd->elem_count, pcmd->texture_id, pcmd->clip_rect.x, pcmd->clip_rect.y, pcmd->clip_rect.z, pcmd->clip_rect.w); + ImGui::BulletText("Draw %d indexed vtx, tex = %p, clip_rect = (%.0f,%.0f)..(%.0f,%.0f)", pcmd->ElemCount, pcmd->TextureId, pcmd->ClipRect.x, pcmd->ClipRect.y, pcmd->ClipRect.z, pcmd->ClipRect.w); if (show_clip_rects && ImGui::IsItemHovered()) { - ImRect clip_rect = pcmd->clip_rect; + ImRect clip_rect = pcmd->ClipRect; ImRect vtxs_rect; - for (int i = elem_offset; i < elem_offset + (int)pcmd->elem_count; i++) - vtxs_rect.Add(draw_list->vtx_buffer[draw_list->idx_buffer[i]].pos); + for (int i = elem_offset; i < elem_offset + (int)pcmd->ElemCount; i++) + vtxs_rect.Add(draw_list->VtxBuffer[draw_list->IdxBuffer[i]].pos); GImGui->OverlayDrawList.PushClipRectFullScreen(); clip_rect.Round(); GImGui->OverlayDrawList.AddRect(clip_rect.Min, clip_rect.Max, ImColor(255,255,0)); vtxs_rect.Round(); GImGui->OverlayDrawList.AddRect(vtxs_rect.Min, vtxs_rect.Max, ImColor(255,0,255)); diff --git a/imgui.h b/imgui.h index 521e3098..757dbfe1 100644 --- a/imgui.h +++ b/imgui.h @@ -982,8 +982,8 @@ struct ImGuiListClipper // NB- You most likely do NOT need to use draw callbacks just to create your own widget or customized UI rendering (you can poke into the draw list for that) // Draw callback are useful for example if you want to render a complex 3D scene inside a UI element. // The expected behavior from your rendering loop is: -// if (cmd.user_callback != NULL) -// cmd.user_callback(parent_list, cmd); +// if (cmd.UserCallback != NULL) +// cmd.UserCallback(parent_list, cmd); // else // RenderTriangles() // It is up to you to decide if your rendering loop or the callback should be responsible for backup/restoring rendering state. @@ -992,11 +992,11 @@ typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* c // Typically, 1 command = 1 gpu draw call (unless command is a callback) struct ImDrawCmd { - unsigned int elem_count; // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[]. - ImVec4 clip_rect; // Clipping rectangle (x1, y1, x2, y2) - ImTextureID texture_id; // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas. - ImDrawCallback user_callback; // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally. - void* user_callback_data; // The draw callback code can access this. + unsigned int ElemCount; // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[]. + ImVec4 ClipRect; // Clipping rectangle (x1, y1, x2, y2) + ImTextureID TextureId; // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas. + ImDrawCallback UserCallback; // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally. + void* UserCallbackData; // The draw callback code can access this. }; // Vertex index @@ -1020,8 +1020,8 @@ IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT; // Draw channels are used by the Columns API to "split" the render list into different channels while building, so items of each column can be batched together. struct ImDrawChannel { - ImVector cmd_buffer; - ImVector idx_buffer; + ImVector CmdBuffer; + ImVector IdxBuffer; }; // Draw command list @@ -1034,22 +1034,22 @@ struct ImDrawChannel struct ImDrawList { // This is what you have to render - ImVector cmd_buffer; // Commands. Typically 1 command = 1 gpu draw call. - ImVector idx_buffer; // Index buffer. Each command consume ImDrawCmd::idx_count of those - ImVector vtx_buffer; // Vertex buffer. + ImVector CmdBuffer; // Commands. Typically 1 command = 1 gpu draw call. + ImVector IdxBuffer; // Index buffer. Each command consume ImDrawCmd::ElemCount of those + ImVector VtxBuffer; // Vertex buffer. // [Internal, used while building lists] - const char* owner_name; // Pointer to owner window's name (if any) for debugging - ImDrawVert* vtx_write; // [Internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much) - unsigned int vtx_current_idx; // [Internal] == vtx_buffer.Size - ImDrawIdx* idx_write; // [Internal] point within idx_buffer after each add command (to avoid using the ImVector<> operators too much) - ImVector clip_rect_stack; // [Internal] - ImVector texture_id_stack; // [Internal] - ImVector path; // [Internal] current path building - int channel_current; // - ImVector channels; // [Internal] draw channels for layering or columns API + const char* _OwnerName; // Pointer to owner window's name (if any) for debugging + unsigned int _VtxCurrentIdx; // [Internal] == VtxBuffer.Size + ImDrawVert* _VtxWritePtr; // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much) + ImDrawIdx* _IdxWritePtr; // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much) + ImVector _ClipRectStack; // [Internal] + ImVector _TextureIdStack; // [Internal] + ImVector _Path; // [Internal] current path building + int _ChannelCurrent; // [Internal] current channel number (0) + ImVector _Channels; // [Internal] draw channels for columns API - ImDrawList() { owner_name = NULL; Clear(); } + ImDrawList() { _OwnerName = NULL; Clear(); } ~ImDrawList() { ClearFreeMemory(); } IMGUI_API void Clear(); IMGUI_API void ClearFreeMemory(); @@ -1072,16 +1072,16 @@ struct ImDrawList IMGUI_API void AddConvexPolyFilled(const ImVec2* points, const int num_points, ImU32 col, bool anti_aliased); // Stateful path API, add points then finish with PathFill() or PathStroke() - inline void PathClear() { path.resize(0); } - inline void PathLineTo(const ImVec2& p) { path.push_back(p); } + inline void PathClear() { _Path.resize(0); } + inline void PathLineTo(const ImVec2& p) { _Path.push_back(p); } IMGUI_API void PathArcToFast(const ImVec2& centre, float radius, int a_min, int a_max); IMGUI_API void PathArcTo(const ImVec2& centre, float radius, float a_min, float a_max, int num_segments = 12); IMGUI_API void PathRect(const ImVec2& a, const ImVec2& b, float rounding = 0.0f, int rounding_corners = 0x0F); - inline void PathFill(ImU32 col) { AddConvexPolyFilled(path.Data, path.Size, col, true); PathClear(); } - inline void PathStroke(ImU32 col, bool closed) { AddPolyline(path.Data, path.Size, col, closed, true); PathClear(); } + inline void PathFill(ImU32 col) { AddConvexPolyFilled(_Path.Data, _Path.Size, col, true); PathClear(); } + inline void PathStroke(ImU32 col, bool closed) { AddPolyline(_Path.Data, _Path.Size, col, closed, true); PathClear(); } // Advanced - IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'user_callback' in ImDrawCmd and call the function instead of rendering triangles. + IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles. IMGUI_API void AddDrawCmd(); // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible IMGUI_API void ChannelsSplit(int channel_count); IMGUI_API void ChannelsMerge(int channel_count); @@ -1098,10 +1098,10 @@ struct ImDrawList // All draw data to render an ImGui frame struct ImDrawData { - ImDrawList** cmd_lists; - int cmd_lists_count; - int total_vtx_count; // For convenience, sum of all cmd_lists vtx_buffer.Size - int total_idx_count; // For convenience, sum of all cmd_lists idx_buffer.Size + ImDrawList** CmdLists; + int CmdListsCount; + int TotalVtxCount; // For convenience, sum of all cmd_lists vtx_buffer.Size + int TotalIdxCount; // For convenience, sum of all cmd_lists idx_buffer.Size // Functions void DeIndexAllBuffers(); // For backward compatibility: convert all buffers from indexed to de-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!