mirror of https://github.com/ocornut/imgui
ImDrawListSplitter: extracted out of ImDrawList. Down the line we may obsolete the ImDrawList functions and encourage users to store the splitter aside, in the meanwhile ImDrawList holds a splitter.
(This will allow columns/table to recurse.)
This commit is contained in:
omar
parent
8abf1313aa
commit
f1f4b42d91
54
imgui.h
54
imgui.h
|
|
@ -20,7 +20,7 @@ Index of this file:
|
|||
// Misc data structures (ImGuiInputTextCallbackData, ImGuiSizeCallbackData, ImGuiPayload)
|
||||
// Obsolete functions
|
||||
// Helpers (ImGuiOnceUponAFrame, ImGuiTextFilter, ImGuiTextBuffer, ImGuiStorage, ImGuiListClipper, ImColor)
|
||||
// Draw List API (ImDrawCallback, ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListFlags, ImDrawList, ImDrawData)
|
||||
// Draw List API (ImDrawCallback, ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListSplitter, ImDrawListFlags, ImDrawList, ImDrawData)
|
||||
// Font API (ImFontConfig, ImFontGlyph, ImFontGlyphRangesBuilder, ImFontAtlasFlags, ImFontAtlas, ImFont)
|
||||
|
||||
*/
|
||||
|
|
@ -91,11 +91,12 @@ Index of this file:
|
|||
// Forward declarations and basic types
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
struct ImDrawChannel; // Temporary storage for ImDrawList ot output draw commands out of order, used by ImDrawList::ChannelsSplit()
|
||||
struct ImDrawChannel; // Temporary storage to output draw commands out of order, used by ImDrawListSplitter and ImDrawList::ChannelsSplit()
|
||||
struct ImDrawCmd; // A single draw command within a parent ImDrawList (generally maps to 1 GPU draw call, unless it is a callback)
|
||||
struct ImDrawData; // All draw command lists required to render the frame + pos/size coordinates to use for the projection matrix.
|
||||
struct ImDrawList; // A single draw command list (generally one per window, conceptually you may see this as a dynamic "mesh" builder)
|
||||
struct ImDrawListSharedData; // Data shared among multiple draw lists (typically owned by parent ImGui context, but you may create one yourself)
|
||||
struct ImDrawListSplitter; // Helper to split a draw list into different layers which can be drawn into out of order, then flattened back.
|
||||
struct ImDrawVert; // A single vertex (pos + uv + col = 20 bytes by default. Override layout with IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT)
|
||||
struct ImFont; // Runtime data for a single font within a parent ImFontAtlas
|
||||
struct ImFontAtlas; // Runtime data for multiple fonts, bake multiple fonts into a single texture, TTF/OTF font loader
|
||||
|
|
@ -1760,7 +1761,7 @@ struct ImColor
|
|||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Draw List API (ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListFlags, ImDrawList, ImDrawData)
|
||||
// Draw List API (ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListSplitter, ImDrawListFlags, ImDrawList, ImDrawData)
|
||||
// Hold a series of drawing commands. The user provides a renderer for ImDrawData which essentially contains an array of ImDrawList.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
|
@ -1817,12 +1818,27 @@ struct ImDrawVert
|
|||
IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
|
||||
#endif
|
||||
|
||||
// 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.
|
||||
// You can also use them to simulate drawing layers and submit primitives in a different order than how they will be rendered.
|
||||
// For use by ImDrawListSplitter.
|
||||
struct ImDrawChannel
|
||||
{
|
||||
ImVector<ImDrawCmd> CmdBuffer;
|
||||
ImVector<ImDrawIdx> IdxBuffer;
|
||||
ImVector<ImDrawCmd> CmdBuffer;
|
||||
ImVector<ImDrawIdx> IdxBuffer;
|
||||
};
|
||||
|
||||
// Split/Merge functions are used to split the draw list into different layers which can be drawn into out of order.
|
||||
// This is used by the Columns api, so items of each column can be batched together in a same draw call.
|
||||
struct ImDrawListSplitter
|
||||
{
|
||||
int _Current; // Current channel number (0)
|
||||
int _Count; // Number of active channels (1+)
|
||||
ImVector<ImDrawChannel> _Channels; // Draw channels (not resized down so Count might be < Channels.Size)
|
||||
|
||||
inline ImDrawListSplitter() { Clear(); }
|
||||
inline void Clear() { _Current = 0; _Count = 1; } // Do not clear Channels[] so our allocations are reused next frame
|
||||
IMGUI_API void ClearFreeMemory();
|
||||
IMGUI_API void Split(ImDrawList* draw_list, int count);
|
||||
IMGUI_API void Merge(ImDrawList* draw_lists);
|
||||
IMGUI_API void SetCurrentChannel(ImDrawList* draw_list, int channel_idx);
|
||||
};
|
||||
|
||||
enum ImDrawCornerFlags_
|
||||
|
|
@ -1847,8 +1863,10 @@ enum ImDrawListFlags_
|
|||
};
|
||||
|
||||
// Draw command list
|
||||
// This is the low-level list of polygons that ImGui functions are filling. At the end of the frame, all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
|
||||
// Each ImGui window contains its own ImDrawList. You can use ImGui::GetWindowDrawList() to access the current window draw list and draw custom primitives.
|
||||
// This is the low-level list of polygons that ImGui:: functions are filling. At the end of the frame,
|
||||
// all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
|
||||
// Each dear imgui window contains its own ImDrawList. You can use ImGui::GetWindowDrawList() to
|
||||
// access the current window draw list and draw custom primitives.
|
||||
// You can interleave normal ImGui:: calls and adding primitives to the current draw list.
|
||||
// All positions are generally in pixel coordinates (top-left at (0,0), bottom-right at io.DisplaySize), but you are totally free to apply whatever transformation matrix to want to the data (if you apply such transformation you'll want to apply it to ClipRect as well)
|
||||
// Important: Primitives are always added to the list and not culled (culling is done at higher-level by ImGui:: functions), if you use this API a lot consider coarse culling your drawn objects.
|
||||
|
|
@ -1870,9 +1888,7 @@ struct ImDrawList
|
|||
ImVector<ImVec4> _ClipRectStack; // [Internal]
|
||||
ImVector<ImTextureID> _TextureIdStack; // [Internal]
|
||||
ImVector<ImVec2> _Path; // [Internal] current path building
|
||||
int _ChannelsCurrent; // [Internal] current channel number (0)
|
||||
int _ChannelsCount; // [Internal] number of active channels (1+)
|
||||
ImVector<ImDrawChannel> _Channels; // [Internal] draw channels for columns API (not resized down so _ChannelsCount may be smaller than _Channels.Size)
|
||||
ImDrawListSplitter _Splitter; // [Internal] for channels api
|
||||
|
||||
// If you want to create ImDrawList instances, pass them ImGui::GetDrawListSharedData() or create and use your own ImDrawListSharedData (so you can use ImDrawList without ImGui)
|
||||
ImDrawList(const ImDrawListSharedData* shared_data) { _Data = shared_data; _OwnerName = NULL; Clear(); }
|
||||
|
|
@ -1916,18 +1932,18 @@ struct ImDrawList
|
|||
IMGUI_API void PathBezierCurveTo(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, int num_segments = 0);
|
||||
IMGUI_API void PathRect(const ImVec2& rect_min, const ImVec2& rect_max, float rounding = 0.0f, int rounding_corners_flags = ImDrawCornerFlags_All);
|
||||
|
||||
// Channels
|
||||
// - Use to simulate layers. By switching channels to can render out-of-order (e.g. submit foreground primitives before background primitives)
|
||||
// - Use to minimize draw calls (e.g. if going back-and-forth between multiple non-overlapping clipping rectangles, prefer to append into separate channels then merge at the end)
|
||||
IMGUI_API void ChannelsSplit(int channels_count);
|
||||
IMGUI_API void ChannelsMerge();
|
||||
IMGUI_API void ChannelsSetCurrent(int channel_index);
|
||||
|
||||
// Advanced
|
||||
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 ImDrawList* CloneOutput() const; // Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer.
|
||||
|
||||
// Advanced: Channels
|
||||
// - Use to split render into layers. By switching channels to can render out-of-order (e.g. submit foreground primitives before background primitives)
|
||||
// - Use to minimize draw calls (e.g. if going back-and-forth between multiple non-overlapping clipping rectangles, prefer to append into separate channels then merge at the end)
|
||||
inline void ChannelsSplit(int count) { _Splitter.Split(this, count); }
|
||||
inline void ChannelsMerge() { _Splitter.Merge(this); }
|
||||
inline void ChannelsSetCurrent(int n) { _Splitter.SetCurrentChannel(this, n); }
|
||||
|
||||
// Internal helpers
|
||||
// NB: all primitives needs to be reserved via PrimReserve() beforehand!
|
||||
IMGUI_API void Clear();
|
||||
|
|
|
|||
215
imgui_draw.cpp
215
imgui_draw.cpp
|
|
@ -8,6 +8,7 @@ Index of this file:
|
|||
// [SECTION] STB libraries implementation
|
||||
// [SECTION] Style functions
|
||||
// [SECTION] ImDrawList
|
||||
// [SECTION] ImDrawListSplitter
|
||||
// [SECTION] ImDrawData
|
||||
// [SECTION] Helpers ShadeVertsXXX functions
|
||||
// [SECTION] ImFontConfig
|
||||
|
|
@ -372,9 +373,7 @@ void ImDrawList::Clear()
|
|||
_ClipRectStack.resize(0);
|
||||
_TextureIdStack.resize(0);
|
||||
_Path.resize(0);
|
||||
_ChannelsCurrent = 0;
|
||||
_ChannelsCount = 1;
|
||||
// NB: Do not clear channels so our allocations are re-used after the first frame.
|
||||
_Splitter.Clear();
|
||||
}
|
||||
|
||||
void ImDrawList::ClearFreeMemory()
|
||||
|
|
@ -388,15 +387,7 @@ void ImDrawList::ClearFreeMemory()
|
|||
_ClipRectStack.clear();
|
||||
_TextureIdStack.clear();
|
||||
_Path.clear();
|
||||
_ChannelsCurrent = 0;
|
||||
_ChannelsCount = 1;
|
||||
for (int i = 0; i < _Channels.Size; i++)
|
||||
{
|
||||
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();
|
||||
_Splitter.ClearFreeMemory();
|
||||
}
|
||||
|
||||
ImDrawList* ImDrawList::CloneOutput() const
|
||||
|
|
@ -526,94 +517,6 @@ void ImDrawList::PopTextureID()
|
|||
UpdateTextureID();
|
||||
}
|
||||
|
||||
void ImDrawList::ChannelsSplit(int channels_count)
|
||||
{
|
||||
IM_ASSERT(_ChannelsCurrent == 0 && _ChannelsCount == 1);
|
||||
int old_channels_count = _Channels.Size;
|
||||
if (old_channels_count < channels_count)
|
||||
_Channels.resize(channels_count);
|
||||
_ChannelsCount = channels_count;
|
||||
|
||||
// _Channels[] (24/32 bytes each) hold storage that we'll swap with this->_CmdBuffer/_IdxBuffer
|
||||
// The content of _Channels[0] at this point doesn't matter. We clear it to make state tidy in a debugger but we don't strictly need to.
|
||||
// When we switch to the next channel, we'll copy _CmdBuffer/_IdxBuffer into _Channels[0] and then _Channels[1] into _CmdBuffer/_IdxBuffer
|
||||
memset(&_Channels[0], 0, sizeof(ImDrawChannel));
|
||||
for (int i = 1; i < channels_count; i++)
|
||||
{
|
||||
if (i >= old_channels_count)
|
||||
{
|
||||
IM_PLACEMENT_NEW(&_Channels[i]) ImDrawChannel();
|
||||
}
|
||||
else
|
||||
{
|
||||
_Channels[i].CmdBuffer.resize(0);
|
||||
_Channels[i].IdxBuffer.resize(0);
|
||||
}
|
||||
if (_Channels[i].CmdBuffer.Size == 0)
|
||||
{
|
||||
ImDrawCmd draw_cmd;
|
||||
draw_cmd.ClipRect = _ClipRectStack.back();
|
||||
draw_cmd.TextureId = _TextureIdStack.back();
|
||||
_Channels[i].CmdBuffer.push_back(draw_cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ImDrawList::ChannelsMerge()
|
||||
{
|
||||
// Note that we never use or rely on channels.Size because it is merely a buffer that we never shrink back to 0 to keep all sub-buffers ready for use.
|
||||
if (_ChannelsCount <= 1)
|
||||
return;
|
||||
|
||||
ChannelsSetCurrent(0);
|
||||
if (CmdBuffer.Size != 0 && CmdBuffer.back().ElemCount == 0)
|
||||
CmdBuffer.pop_back();
|
||||
|
||||
// Calculate our final buffer sizes. Also fix the incorrect IdxOffset values in each command.
|
||||
int new_cmd_buffer_count = 0;
|
||||
int new_idx_buffer_count = 0;
|
||||
int idx_offset = (CmdBuffer.Size != 0) ? (CmdBuffer.back().IdxOffset + CmdBuffer.back().ElemCount) : 0;
|
||||
for (int i = 1; i < _ChannelsCount; i++)
|
||||
{
|
||||
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;
|
||||
for (int cmd_n = 0; cmd_n < ch.CmdBuffer.Size; cmd_n++)
|
||||
{
|
||||
ch.CmdBuffer.Data[cmd_n].IdxOffset = idx_offset;
|
||||
idx_offset += ch.CmdBuffer.Data[cmd_n].ElemCount;
|
||||
}
|
||||
}
|
||||
CmdBuffer.resize(CmdBuffer.Size + new_cmd_buffer_count);
|
||||
IdxBuffer.resize(IdxBuffer.Size + new_idx_buffer_count);
|
||||
|
||||
// Flatten our N channels at the end of the first one.
|
||||
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 < _ChannelsCount; i++)
|
||||
{
|
||||
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; }
|
||||
}
|
||||
UpdateClipRect(); // We call this instead of AddDrawCmd(), so that empty channels won't produce an extra draw call.
|
||||
_ChannelsCount = 1;
|
||||
}
|
||||
|
||||
void ImDrawList::ChannelsSetCurrent(int idx)
|
||||
{
|
||||
IM_ASSERT(idx < _ChannelsCount);
|
||||
if (_ChannelsCurrent == idx) return;
|
||||
memcpy(&_Channels.Data[_ChannelsCurrent].CmdBuffer, &CmdBuffer, sizeof(CmdBuffer)); // copy 12 bytes, four times
|
||||
memcpy(&_Channels.Data[_ChannelsCurrent].IdxBuffer, &IdxBuffer, sizeof(IdxBuffer));
|
||||
_ChannelsCurrent = idx;
|
||||
memcpy(&CmdBuffer, &_Channels.Data[_ChannelsCurrent].CmdBuffer, sizeof(CmdBuffer));
|
||||
memcpy(&IdxBuffer, &_Channels.Data[_ChannelsCurrent].IdxBuffer, sizeof(IdxBuffer));
|
||||
_IdxWritePtr = IdxBuffer.Data + IdxBuffer.Size;
|
||||
}
|
||||
|
||||
// NB: this can be called with negative count for removing primitives (as long as the result does not underflow)
|
||||
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
|
||||
{
|
||||
|
|
@ -1287,6 +1190,118 @@ void ImDrawList::AddImageRounded(ImTextureID user_texture_id, const ImVec2& a, c
|
|||
PopTextureID();
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// ImDrawListSplitter
|
||||
//-----------------------------------------------------------------------------
|
||||
// FIXME: This may be a little confusing, trying to be a little too low-level/optimal instead of just doing vector swap..
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void ImDrawListSplitter::ClearFreeMemory()
|
||||
{
|
||||
for (int i = 0; i < _Channels.Size; i++)
|
||||
{
|
||||
if (i == _Current)
|
||||
memset(&_Channels[i], 0, sizeof(_Channels[i])); // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again
|
||||
_Channels[i].CmdBuffer.clear();
|
||||
_Channels[i].IdxBuffer.clear();
|
||||
}
|
||||
_Current = 0;
|
||||
_Count = 1;
|
||||
_Channels.clear();
|
||||
}
|
||||
|
||||
void ImDrawListSplitter::Split(ImDrawList* draw_list, int channels_count)
|
||||
{
|
||||
IM_ASSERT(_Current == 0 && _Count == 1);
|
||||
int old_channels_count = _Channels.Size;
|
||||
if (old_channels_count < channels_count)
|
||||
_Channels.resize(channels_count);
|
||||
_Count = channels_count;
|
||||
|
||||
// Channels[] (24/32 bytes each) hold storage that we'll swap with draw_list->_CmdBuffer/_IdxBuffer
|
||||
// The content of Channels[0] at this point doesn't matter. We clear it to make state tidy in a debugger but we don't strictly need to.
|
||||
// When we switch to the next channel, we'll copy draw_list->_CmdBuffer/_IdxBuffer into Channels[0] and then Channels[1] into draw_list->CmdBuffer/_IdxBuffer
|
||||
memset(&_Channels[0], 0, sizeof(ImDrawChannel));
|
||||
for (int i = 1; i < channels_count; i++)
|
||||
{
|
||||
if (i >= old_channels_count)
|
||||
{
|
||||
IM_PLACEMENT_NEW(&_Channels[i]) ImDrawChannel();
|
||||
}
|
||||
else
|
||||
{
|
||||
_Channels[i].CmdBuffer.resize(0);
|
||||
_Channels[i].IdxBuffer.resize(0);
|
||||
}
|
||||
if (_Channels[i].CmdBuffer.Size == 0)
|
||||
{
|
||||
ImDrawCmd draw_cmd;
|
||||
draw_cmd.ClipRect = draw_list->_ClipRectStack.back();
|
||||
draw_cmd.TextureId = draw_list->_TextureIdStack.back();
|
||||
_Channels[i].CmdBuffer.push_back(draw_cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ImDrawListSplitter::Merge(ImDrawList* draw_list)
|
||||
{
|
||||
// Note that we never use or rely on channels.Size because it is merely a buffer that we never shrink back to 0 to keep all sub-buffers ready for use.
|
||||
if (_Count <= 1)
|
||||
return;
|
||||
|
||||
SetCurrentChannel(draw_list, 0);
|
||||
if (draw_list->CmdBuffer.Size != 0 && draw_list->CmdBuffer.back().ElemCount == 0)
|
||||
draw_list->CmdBuffer.pop_back();
|
||||
|
||||
// Calculate our final buffer sizes. Also fix the incorrect IdxOffset values in each command.
|
||||
int new_cmd_buffer_count = 0;
|
||||
int new_idx_buffer_count = 0;
|
||||
int idx_offset = (draw_list->CmdBuffer.Size != 0) ? (draw_list->CmdBuffer.back().IdxOffset + draw_list->CmdBuffer.back().ElemCount) : 0;
|
||||
for (int i = 1; i < _Count; i++)
|
||||
{
|
||||
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;
|
||||
for (int cmd_n = 0; cmd_n < ch.CmdBuffer.Size; cmd_n++)
|
||||
{
|
||||
ch.CmdBuffer.Data[cmd_n].IdxOffset = idx_offset;
|
||||
idx_offset += ch.CmdBuffer.Data[cmd_n].ElemCount;
|
||||
}
|
||||
}
|
||||
draw_list->CmdBuffer.resize(draw_list->CmdBuffer.Size + new_cmd_buffer_count);
|
||||
draw_list->IdxBuffer.resize(draw_list->IdxBuffer.Size + new_idx_buffer_count);
|
||||
|
||||
// Write commands and indices in order (they are fairly small structures, we don't copy vertices only indices)
|
||||
ImDrawCmd* cmd_write = draw_list->CmdBuffer.Data + draw_list->CmdBuffer.Size - new_cmd_buffer_count;
|
||||
ImDrawIdx* idx_write = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size - new_idx_buffer_count;
|
||||
for (int i = 1; i < _Count; i++)
|
||||
{
|
||||
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(idx_write, ch.IdxBuffer.Data, sz * sizeof(ImDrawIdx)); idx_write += sz; }
|
||||
}
|
||||
draw_list->_IdxWritePtr = idx_write;
|
||||
draw_list->UpdateClipRect(); // We call this instead of AddDrawCmd(), so that empty channels won't produce an extra draw call.
|
||||
_Count = 1;
|
||||
}
|
||||
|
||||
void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx)
|
||||
{
|
||||
IM_ASSERT(idx < _Count);
|
||||
if (_Current == idx)
|
||||
return;
|
||||
// Overwrite ImVector (12/16 bytes), four times. This is merely a silly optimization instead of doing .swap()
|
||||
memcpy(&_Channels.Data[_Current].CmdBuffer, &draw_list->CmdBuffer, sizeof(draw_list->CmdBuffer));
|
||||
memcpy(&_Channels.Data[_Current].IdxBuffer, &draw_list->IdxBuffer, sizeof(draw_list->IdxBuffer));
|
||||
_Current = idx;
|
||||
memcpy(&draw_list->CmdBuffer, &_Channels.Data[idx].CmdBuffer, sizeof(draw_list->CmdBuffer));
|
||||
memcpy(&draw_list->IdxBuffer, &_Channels.Data[idx].IdxBuffer, sizeof(draw_list->IdxBuffer));
|
||||
draw_list->_IdxWritePtr = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] ImDrawData
|
||||
//-----------------------------------------------------------------------------
|
||||
|
|
|
|||
Loading…
Reference in New Issue