ImDrawListSplitter Struct Reference

#include <src/imgui/imgui.h>

Collaboration diagram for ImDrawListSplitter:

Public Member Functions
	ImDrawListSplitter ()
	~ImDrawListSplitter ()
void	Clear ()
IMGUI_API void	ClearFreeMemory ()
IMGUI_API void	Split (ImDrawList *draw_list, int count)
IMGUI_API void	Merge (ImDrawList *draw_list)
IMGUI_API void	SetCurrentChannel (ImDrawList *draw_list, int channel_idx)

Public Attributes
int	_Current
int	_Count
ImVector< ImDrawChannel >	_Channels

Detailed Description

Constructor & Destructor Documentation

ImDrawListSplitter()

ImDrawListSplitter::ImDrawListSplitter ( )

inline

{ memset(this, 0, sizeof(*this)); }

~ImDrawListSplitter()

ImDrawListSplitter::~ImDrawListSplitter ( )

inline

{ ClearFreeMemory(); }

Member Function Documentation

Clear()

void ImDrawListSplitter::Clear ( )

inline

{ _Current = 0; _Count = 1; } // Do not clear Channels[] so our allocations are reused next frame

Referenced by ImDrawList::_ResetForNewFrame(), and ImGui::BeginTableEx().

Here is the caller graph for this function:

ClearFreeMemory()

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();
}

References _Channels, _Count, _Current, ImVector< T >::clear(), and ImVector< T >::Size.

Referenced by ImDrawList::_ClearFreeMemory(), and ImGui::TableGcCompactTransientBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

Merge()

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);
    draw_list->_PopUnusedDrawCmd();
 
    // 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;
    ImDrawCmd* last_cmd = (_Count > 0 && draw_list->CmdBuffer.Size > 0) ? &draw_list->CmdBuffer.back() : NULL;
    int idx_offset = last_cmd ? last_cmd->IdxOffset + last_cmd->ElemCount : 0;
    for (int i = 1; i < _Count; i++)
    {
        ImDrawChannel& ch = _Channels[i];
 
        // Equivalent of PopUnusedDrawCmd() for this channel's cmdbuffer and except we don't need to test for UserCallback.
        if (ch._CmdBuffer.Size > 0 && ch._CmdBuffer.back().ElemCount == 0)
            ch._CmdBuffer.pop_back();
 
        if (ch._CmdBuffer.Size > 0 && last_cmd != NULL)
        {
            ImDrawCmd* next_cmd = &ch._CmdBuffer[0];
            if (ImDrawCmd_HeaderCompare(last_cmd, next_cmd) == 0 && last_cmd->UserCallback == NULL && next_cmd->UserCallback == NULL)
            {
                // Merge previous channel last draw command with current channel first draw command if matching.
                last_cmd->ElemCount += next_cmd->ElemCount;
                idx_offset += next_cmd->ElemCount;
                ch._CmdBuffer.erase(ch._CmdBuffer.Data); // FIXME-OPT: Improve for multiple merges.
            }
        }
        if (ch._CmdBuffer.Size > 0)
            last_cmd = &ch._CmdBuffer.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;
 
    // Ensure there's always a non-callback draw command trailing the command-buffer
    if (draw_list->CmdBuffer.Size == 0 || draw_list->CmdBuffer.back().UserCallback != NULL)
        draw_list->AddDrawCmd();
 
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &draw_list->CmdBuffer.Data[draw_list->CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount == 0)
        ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TextureId, VtxOffset
    else if (ImDrawCmd_HeaderCompare(curr_cmd, &draw_list->_CmdHeader) != 0)
        draw_list->AddDrawCmd();
 
    _Count = 1;
}

References _Channels, ImDrawChannel::_CmdBuffer, ImDrawList::_CmdHeader, _Count, ImDrawChannel::_IdxBuffer, ImDrawList::_IdxWritePtr, ImDrawList::_PopUnusedDrawCmd(), ImDrawList::AddDrawCmd(), ImVector< T >::back(), cmd_write(), ImDrawList::CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, ImVector< T >::erase(), ImDrawList::IdxBuffer, ImDrawCmd::IdxOffset, ImDrawCmd_HeaderCompare, ImDrawCmd_HeaderCopy, ImVector< T >::pop_back(), ImVector< T >::resize(), SetCurrentChannel(), ImVector< T >::Size, and ImDrawCmd::UserCallback.

Referenced by ImDrawList::ChannelsMerge(), ImGui::EndColumns(), and ImGui::EndTable().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCurrentChannel()

void ImDrawListSplitter::SetCurrentChannel	(	ImDrawList *	draw_list,
		int	channel_idx
	)

{
    IM_ASSERT(idx >= 0 && 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;
 
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = (draw_list->CmdBuffer.Size == 0) ? NULL : &draw_list->CmdBuffer.Data[draw_list->CmdBuffer.Size - 1];
    if (curr_cmd == NULL)
        draw_list->AddDrawCmd();
    else if (curr_cmd->ElemCount == 0)
        ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TextureId, VtxOffset
    else if (ImDrawCmd_HeaderCompare(curr_cmd, &draw_list->_CmdHeader) != 0)
        draw_list->AddDrawCmd();
}

References _Channels, ImDrawChannel::_CmdBuffer, ImDrawList::_CmdHeader, _Count, _Current, ImDrawChannel::_IdxBuffer, ImDrawList::_IdxWritePtr, ImDrawList::AddDrawCmd(), ImDrawList::CmdBuffer, ImVector< T >::Data, ImDrawCmd::ElemCount, ImDrawList::IdxBuffer, IM_ASSERT, ImDrawCmd_HeaderCompare, ImDrawCmd_HeaderCopy, and ImVector< T >::Size.

Referenced by ImGui::BeginColumns(), ImDrawList::ChannelsSetCurrent(), ImGui::EndTable(), Merge(), ImGui::NextColumn(), ImGui::PopColumnsBackground(), ImGui::PushColumnsBackground(), ImGui::TableBeginCell(), ImGui::TableDrawBorders(), ImGui::TableEndRow(), ImGui::TablePopBackgroundChannel(), ImGui::TablePushBackgroundChannel(), and ImGui::TableUpdateLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

Split()

void ImDrawListSplitter::Split	(	ImDrawList *	draw_list,
		int	count
	)

{
    IM_UNUSED(draw_list);
    IM_ASSERT(_Current == 0 && _Count <= 1 && "Nested channel splitting is not supported. Please use separate instances of ImDrawListSplitter.");
    int old_channels_count = _Channels.Size;
    if (old_channels_count < channels_count)
    {
        _Channels.reserve(channels_count); // Avoid over reserving since this is likely to stay stable
        _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);
        }
    }
}

References _Channels, _Count, _Current, IM_ASSERT, IM_PLACEMENT_NEW, IM_UNUSED, ImVector< T >::reserve(), ImVector< T >::resize(), and ImVector< T >::Size.

Referenced by ImGui::BeginColumns(), ImDrawList::ChannelsSplit(), and ImGui::TableSetupDrawChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_Channels

ImVector<ImDrawChannel> ImDrawListSplitter::_Channels

Referenced by ClearFreeMemory(), ImGui::EndTable(), Merge(), SetCurrentChannel(), Split(), and ImGui::TableMergeDrawChannels().

_Count

int ImDrawListSplitter::_Count

Referenced by ClearFreeMemory(), Merge(), SetCurrentChannel(), Split(), and ImGui::TableMergeDrawChannels().

_Current

int ImDrawListSplitter::_Current

Referenced by ClearFreeMemory(), SetCurrentChannel(), Split(), and ImGui::TableMergeDrawChannels().

---

The documentation for this struct was generated from the following files:

• src/imgui/imgui.h
• src/imgui/imgui_draw.cpp