Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/wolfpld/tracy.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/imgui/imgui_draw.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'imgui/imgui_draw.cpp')
-rw-r--r--imgui/imgui_draw.cpp265
1 files changed, 159 insertions, 106 deletions
diff --git a/imgui/imgui_draw.cpp b/imgui/imgui_draw.cpp
index 63d99a29..8d0c31de 100644
--- a/imgui/imgui_draw.cpp
+++ b/imgui/imgui_draw.cpp
@@ -1,4 +1,4 @@
-// dear imgui, v1.70
+// dear imgui, v1.71
// (drawing and font code)
/*
@@ -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
@@ -33,7 +34,7 @@ Index of this file:
#include <stdio.h> // vsnprintf, sscanf, printf
#if !defined(alloca)
-#if defined(__GLIBC__) || defined(__sun) || defined(__CYGWIN__) || defined(__APPLE__)
+#if defined(__GLIBC__) || defined(__sun) || defined(__CYGWIN__) || defined(__APPLE__) || defined(__SWITCH__)
#include <alloca.h> // alloca (glibc uses <alloca.h>. Note that Cygwin may have _WIN32 defined, so the order matters here)
#elif defined(_WIN32)
#include <malloc.h> // alloca
@@ -47,12 +48,13 @@ Index of this file:
// Visual Studio warnings
#ifdef _MSC_VER
+#pragma warning (disable: 4127) // condition expression is constant
#pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff)
#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
#endif
// Clang/GCC warnings with -Weverything
-#ifdef __clang__
+#if defined(__clang__)
#pragma clang diagnostic ignored "-Wold-style-cast" // warning : use of old-style cast // yes, they are more terse.
#pragma clang diagnostic ignored "-Wfloat-equal" // warning : comparing floating point with == or != is unsafe // storing and comparing against same constants ok.
#pragma clang diagnostic ignored "-Wglobal-constructors" // warning : declaration requires a global destructor // similar to above, not sure what the exact difference is.
@@ -100,7 +102,7 @@ namespace IMGUI_STB_NAMESPACE
#pragma warning (disable: 4456) // declaration of 'xx' hides previous local declaration
#endif
-#ifdef __clang__
+#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#pragma clang diagnostic ignored "-Wmissing-prototypes"
@@ -108,7 +110,7 @@ namespace IMGUI_STB_NAMESPACE
#pragma clang diagnostic ignored "-Wcast-qual" // warning : cast from 'const xxxx *' to 'xxx *' drops const qualifier //
#endif
-#ifdef __GNUC__
+#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits" // warning: comparison is always true due to limited range of data type [-Wtype-limits]
#pragma GCC diagnostic ignored "-Wcast-qual" // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers
@@ -151,15 +153,15 @@ namespace IMGUI_STB_NAMESPACE
#endif
#endif
-#ifdef __GNUC__
+#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
-#ifdef __clang__
+#if defined(__clang__)
#pragma clang diagnostic pop
#endif
-#ifdef _MSC_VER
+#if defined(_MSC_VER)
#pragma warning (pop)
#endif
@@ -348,6 +350,7 @@ ImDrawListSharedData::ImDrawListSharedData()
FontSize = 0.0f;
CurveTessellationTol = 0.0f;
ClipRectFullscreen = ImVec4(-8192.0f, -8192.0f, +8192.0f, +8192.0f);
+ InitialFlags = ImDrawListFlags_None;
// Const data
for (int i = 0; i < IM_ARRAYSIZE(CircleVtx12); i++)
@@ -362,16 +365,15 @@ void ImDrawList::Clear()
CmdBuffer.resize(0);
IdxBuffer.resize(0);
VtxBuffer.resize(0);
- Flags = ImDrawListFlags_AntiAliasedLines | ImDrawListFlags_AntiAliasedFill;
+ Flags = _Data->InitialFlags;
+ _VtxCurrentOffset = 0;
_VtxCurrentIdx = 0;
_VtxWritePtr = NULL;
_IdxWritePtr = NULL;
_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()
@@ -385,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
@@ -415,6 +409,8 @@ void ImDrawList::AddDrawCmd()
ImDrawCmd draw_cmd;
draw_cmd.ClipRect = GetCurrentClipRect();
draw_cmd.TextureId = GetCurrentTextureId();
+ draw_cmd.VtxOffset = _VtxCurrentOffset;
+ draw_cmd.IdxOffset = IdxBuffer.Size;
IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
CmdBuffer.push_back(draw_cmd);
@@ -521,88 +517,17 @@ 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()
+// 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)
{
- // 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 && CmdBuffer.back().ElemCount == 0)
- CmdBuffer.pop_back();
-
- int new_cmd_buffer_count = 0, new_idx_buffer_count = 0;
- for (int i = 1; i < _ChannelsCount; i++)
+ // Large mesh support (when enabled)
+ if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
{
- 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;
- }
- CmdBuffer.resize(CmdBuffer.Size + new_cmd_buffer_count);
- IdxBuffer.resize(IdxBuffer.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 < _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; }
+ _VtxCurrentOffset = VtxBuffer.Size;
+ _VtxCurrentIdx = 0;
+ AddDrawCmd();
}
- 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)
-{
ImDrawCmd& draw_cmd = CmdBuffer.Data[CmdBuffer.Size-1];
draw_cmd.ElemCount += idx_count;
@@ -1265,6 +1190,133 @@ 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);
+ }
+ }
+}
+
+static inline bool CanMergeDrawCommands(ImDrawCmd* a, ImDrawCmd* b)
+{
+ return memcmp(&a->ClipRect, &b->ClipRect, sizeof(a->ClipRect)) == 0 && a->TextureId == b->TextureId && a->VtxOffset == b->VtxOffset && !a->UserCallback && !b->UserCallback;
+}
+
+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;
+ ImDrawCmd* last_cmd = (_Count > 0 && _Channels[0]._CmdBuffer.Size > 0) ? &_Channels[0]._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];
+ if (ch._CmdBuffer.Size > 0 && ch._CmdBuffer.back().ElemCount == 0)
+ ch._CmdBuffer.pop_back();
+ if (ch._CmdBuffer.Size > 0 && last_cmd != NULL && CanMergeDrawCommands(last_cmd, &ch._CmdBuffer[0]))
+ {
+ // Merge previous channel last draw command with current channel first draw command if matching.
+ last_cmd->ElemCount += ch._CmdBuffer[0].ElemCount;
+ idx_offset += ch._CmdBuffer[0].ElemCount;
+ ch._CmdBuffer.erase(ch._CmdBuffer.Data);
+ }
+ 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;
+ 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
//-----------------------------------------------------------------------------
@@ -1382,7 +1434,7 @@ ImFontConfig::ImFontConfig()
//-----------------------------------------------------------------------------
// A work of art lies ahead! (. = white layer, X = black layer, others are blank)
-// The white texels on the top left are the ones we'll use everywhere in ImGui to render filled shapes.
+// The white texels on the top left are the ones we'll use everywhere in Dear ImGui to render filled shapes.
const int FONT_ATLAS_DEFAULT_TEX_DATA_W_HALF = 108;
const int FONT_ATLAS_DEFAULT_TEX_DATA_H = 27;
const unsigned int FONT_ATLAS_DEFAULT_TEX_DATA_ID = 0x80000000;
@@ -1779,7 +1831,7 @@ static void UnpackBoolVectorToFlatIndexList(const ImBoolVector* in, ImVector<int
for (const int* it = it_begin; it < it_end; it++)
if (int entries_32 = *it)
for (int bit_n = 0; bit_n < 32; bit_n++)
- if (entries_32 & (1 << bit_n))
+ if (entries_32 & (1u << bit_n))
out->push_back((int)((it - it_begin) << 5) + bit_n);
}
@@ -2391,11 +2443,12 @@ void ImFontGlyphRangesBuilder::AddRanges(const ImWchar* ranges)
void ImFontGlyphRangesBuilder::BuildRanges(ImVector<ImWchar>* out_ranges)
{
- for (int n = 0; n < 0x10000; n++)
+ int max_codepoint = 0x10000;
+ for (int n = 0; n < max_codepoint; n++)
if (GetBit(n))
{
out_ranges->push_back((ImWchar)n);
- while (n < 0x10000 && GetBit(n + 1))
+ while (n < max_codepoint - 1 && GetBit(n + 1))
n++;
out_ranges->push_back((ImWchar)n);
}
@@ -2765,7 +2818,7 @@ void ImFont::RenderChar(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col
void ImFont::RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, float wrap_width, bool cpu_fine_clip) const
{
if (!text_end)
- text_end = text_begin + strlen(text_begin); // ImGui functions generally already provides a valid text_end, so this is merely to handle direct calls.
+ text_end = text_begin + strlen(text_begin); // ImGui:: functions generally already provides a valid text_end, so this is merely to handle direct calls.
// Align to be pixel perfect
pos.x = (float)(int)pos.x + DisplayOffset.x;
@@ -2948,7 +3001,7 @@ void ImFont::RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col
draw_list->CmdBuffer[draw_list->CmdBuffer.Size-1].ElemCount -= (idx_expected_size - draw_list->IdxBuffer.Size);
draw_list->_VtxWritePtr = vtx_write;
draw_list->_IdxWritePtr = idx_write;
- draw_list->_VtxCurrentIdx = (unsigned int)draw_list->VtxBuffer.Size;
+ draw_list->_VtxCurrentIdx = vtx_current_idx;
}
//-----------------------------------------------------------------------------
@@ -3071,7 +3124,7 @@ void ImGui::RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, Im
// FIXME: Rendering an ellipsis "..." is a surprisingly tricky problem for us... we cannot rely on font glyph having it,
// and regular dot are typically too wide. If we render a dot/shape ourselves it comes with the risk that it wouldn't match
// the boldness or positioning of what the font uses...
-void ImGui::RenderPixelEllipsis(ImDrawList* draw_list, ImVec2 pos, int count, ImU32 col)
+void ImGui::RenderPixelEllipsis(ImDrawList* draw_list, ImVec2 pos, ImU32 col, int count)
{
ImFont* font = draw_list->_Data->Font;
const float font_scale = draw_list->_Data->FontSize / font->FontSize;
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-14 09:16:05 +0300